Blog posts by Per Nergård

Four database surprises when upgrading from CMS 11 to CMS 13

Fri, 12 Jun 2026 10:02:44 GMT

We're in the middle of migrating a fairly large site from CMS 11 / .NET Framework to CMS 13 / .NET 10. The code migration is one thing, but the database is where the real surprises live. Everything worked fine against our dev and stage databases — and then we pointed the upgrade at a copy of the production database.

Here are four things that bit us. Two of them are reported to Optimizely (one verified as a bug and fixed in the latest release, one in triage), so depending on when you read this you might be spared. The other two are by design in CMS 13 and you could hit them if your solution is old enough.

1. NULL values in tblSiteDefinition stop the site from booting

CMS 13 replaces `SiteDefinition` with the new `Application` model, and on first boot a schema migration moves your rows from `tblSiteDefinition` to `tblApplication` with a plain `INSERT ... SELECT`. The catch: `Saved` and `SavedBy` are `NOT NULL` in the new table, and in our production database some of the old rows had NULL in those columns. The migration rolls back with an INSERT NULL violation and the site doesn't start at all.

The kicker is that our stage databases didn't have this problem — only production did. So if your upgrade rehearsals all run against stage copies, you can sail through every test and still faceplant on go-live night.

The fix is a one-off backfill before the first CMS 13 boot:

UPDATE tblSiteDefinition
SET Saved   = ISNULL(Saved, GETUTCDATE()),
    SavedBy = ISNULL(SavedBy, 'system')
WHERE Saved IS NULL OR SavedBy IS NULL;

2. Tab names must be plain ASCII

CMS 13 validates tab definition names at model sync, and it's strict: no non-ASCII characters, no spaces, no hyphens. Being a Swedish project we had tab names like "Sökinställningar", "SEO-Settings" and "Externa länkar" — and the app refused to boot with:

```

ValidationException: The Name 'X' is not a valid format.

```

So all tab names need to be plain ASCII identifiers. They're internal keys though — if you want nicer editor-facing labels (or anything with åäö), that's handled with tab translations in your localization files.

3. "Content" and "Settings" are reserved tab names

This one is sneaky. CMS 13 reserves the tab names `Content` and `Settings` for its built-in tabs, and if you have those exact strings as your own tab names — which we did, in a perfectly innocent-looking GroupNames class — model sync throws a `ConflictingResourceException` against a freshly upgraded database.

The confusing part is that `SystemTabNames.Content` isn't the string "Content" at all — it's "Information". And `SystemTabNames.Settings` is "Advanced". So the constants never collide, only the literals do. The fix is simply to point your own constants at `SystemTabNames`:

public const string Content  = SystemTabNames.Content;   // "Information"
public const string Settings = SystemTabNames.Settings;  // "Advanced"

4. NULLs in tblSynchedUser break edit mode for everyone

The site authenticates with WS-Federation against an external ADFS, and not every identity comes with `email`, `givenname` or `surname` claims. After user sync those rows end up with NULL in the corresponding columns in `tblSynchedUser` — including one literally named `Metadata`. The columns are nullable, so we assumed that was fine.

It isn't. As soon as anyone opens edit mode, the CMS shell tries to subscribe the current user to feature notifications, reads through the user table, and dies:

System.Data.SqlTypes.SqlNullValueException: Data is Null.
   at EPiServer.DataAccess.Internal.SynchronizeUsersDB.<FindUsersAsync>g__CreateUser|18_0
   ...
   at FeatureNotificationService.SubscribeAsync

A single NULL row anywhere in the table is enough, and it doesn't have to belong to the user logging in. The public site keeps working — only edit mode breaks — which makes it genuinely confusing to troubleshoot.

The workaround is backfilling the nullable string columns with empty strings. The good news: we reported this one, Optimizely verified it as a bug, and a fix ships in the latest release. If you're on an earlier 13.x, the backfill is:

UPDATE tblSynchedUser SET Email            = '' WHERE Email IS NULL;
UPDATE tblSynchedUser SET GivenName        = '' WHERE GivenName IS NULL;
UPDATE tblSynchedUser SET LoweredGivenName = '' WHERE LoweredGivenName IS NULL;
UPDATE tblSynchedUser SET Surname          = '' WHERE Surname IS NULL;
UPDATE tblSynchedUser SET LoweredSurname   = '' WHERE LoweredSurname IS NULL;
UPDATE tblSynchedUser SET Metadata         = '' WHERE Metadata IS NULL;

Wrapping up

The common thread: none of this shows up on a clean database. It's the years of accumulated production data — old site definitions, legacy users synced before claims were complete, tab names from a more liberal era — that trip the upgrade. So rehearse against a fresh copy of *production*, not stage, before the real cutover.

Automatic assign of content reference properties on content creation

Fri, 05 Jun 2026 11:42:50 GMT

A long time ago I was tired of configuring setting properties on a settings page when deploying new functionality that needed global settings, so I did a way of accomplishaing that with attributes from the settings page.

Earlier this week I got tired of it again and did another version for CMS 13 but this time I did it from the other way around with an attribute on the content type.

Old blog post here: 2019

So the idea is that when building a new function and we need to configure a settings property to point to a new content type for some shared functionality you could configure that via an attribute on the content type so after deploy you just create your new page and it automatically wires up the setting for you. Done in an Alloy site so thats why I use StartPage.

Maybe not a super big problem if you just delploying a new features but if setting up a boilerplate solution of some sort from scratch it will make your life much easier.

// Auto-match: the settings property whose [AllowedTypes] most specifically accepts ContactPage is used.
[RegisterIn(typeof(StartPage))]
public class ContactPage : SitePageData { }

// Explicit property: recommended when the settings property allows a broad base type (e.g. PageData).
[RegisterIn(typeof(StartPage), nameof(StartPage.ContactsPageLink))]
public class ContactPage : SitePageData { }

// React on creation instead of publish.
[RegisterIn(typeof(StartPage), Trigger = RegisterTrigger.Created)]
public class ContactPage : SitePageData { }

Code over at my GitHub. Pnergard AutoRegister

Extending the Optimizely 11 Link Validation job with custom exclude patterns

Thu, 28 May 2026 10:49:20 GMT

This might be common knowledge but I have never done this in all my years working with Optimizely solutions.

On a customer I noticed that the link validation scheduled job had been failing for quite some time with the error: The scheme for the url "tel:00 000" in not http or https. So I needed to figure out if and how the configure the job to ignore certain patterns.

It turned out to be quite easy to just create a initialization module that hooked into the options for the job. Code snippet below and complete example on my Gist.

So adding that init module fixed the error and made the job to successfully run.

    [InitializableModule]
    [ModuleDependency(typeof(EPiServer.Web.InitializationModule))]
    public class LinkValidatorConfiguration : IConfigurableModule
    {
        public void ConfigureContainer(ServiceConfigurationContext context)
        {
            var options = new LinkValidatorOptions();
            options.ExcludePatterns.Add(@"^\s*tel:");
            options.ExcludePatterns.Add(@"^\s*mailto:");
            options.ExcludePatterns.Add(@"^\s*callto:");
            options.ExcludePatterns.Add(@"^\s*sms:");
            options.ExcludePatterns.Add(@"^\s*javascript:");
            options.ExcludePatterns.Add(@"^\s*skype:");
            context.Services.AddSingleton(options);
        }

        public void Initialize(InitializationEngine context) { }
        public void Uninitialize(InitializationEngine context) { }
    }

Hide built in scheduled job from the admin UI

Wed, 06 May 2026 08:52:48 GMT

Ok so this probably goes into the not so useful section but late last night I got a veery strong feeling that all projects I am involved with have alot of builtin scheduled jobs that are never used and only add noice to the admin ui scheduled job list. So there must be a way to hide them I thought...

And it turns out that you can, even though that in retrospect this isn't such a big problem maybe :). But I created a RCL project which you just register / configure in your solution.

You can get the code over at GitHub.

Usage
1. Add the below line to startup and then start in debug mode and check the output for a list of scheduledjobs and their guid / name

services.HideScheduledJobs(_ => { });

2. Add the Guids you want to hide

services.HideScheduledJobs(opts => opts
    .Hide(new Guid("e652f3bd-f550-40e8-8743-2c39cda651dc"), "Remove unrelated content assets")
    .Hide(new Guid("656e747e-b2cb-4930-83dc-5d8d97aeaabb"), "Trim content versions"));

Results

All jobs visible:

Here I have hidden the bottow two

Scheduled jobs with parameters

Tue, 14 Apr 2026 07:35:47 GMT

Scheduled jobs is an integral part of most Optimizely solution but the UI has, in my opinon, always been lacking in usability and features. Earlier this year I did a small tool that tried to give a better overview and make it easier digging into log messages when troubleshooting errors.

It kinda solved some issues but the look and feel was quite bad so I have been thinking about how to make it better now and then since then. Link to old blog post "Scheduled job overview" So this lead up to this blog post.

TL;DR

Nergard.ScheduledJobsAdmin is my new attemt on a complement or replacment for the built in scheduled jobs admin UI.

!Important! I have not been able to test it out fully in a production environment so use at your own risk. If you try it and run inte issues feedback or pull request are welcome.

Features

Searchable job roster - give a good overview of builtin and custom scheduled jobs

Health state indicator - at a glance you can see which jobs are healthy, failing, or overdue

Typed parameters - declare a strongly-typed parameters class on your job and the tool renders a form for it automatically. No more hardcoding values in job logic.

Sleep window - define quiet hours for a job in code or let operators configure them per-job in the UI. Manual runs always bypass them.

History drill down - click any run in the history timeline to see the full log output, which parameters were active, and how long it took

Feature details

Job roster

The left panel shows all your scheduled jobs in a scrollable list with a search box at the top. Jobs are split into two groups: your own custom jobs at the top, and Optimizely's built-in system jobs in a collapsed section below. The built-in section is collapsed by default so it does not clutter the view, but you can expand it if you need to manage one.

Each job in the list shows a colour-coded health state: succeeded, failed, overdue (has not run within twice its configured interval), never run, or manual-only. You can also exclude specific jobs entirely via configuration if there are system jobs you never want to see.

History tab

The History tab shows a paginated timeline of all past runs for the selected job, newest first. You can filter by keyword to find specific runs quickly.

Click any row to drill into that run: you see the start time, duration, whether it succeeded or failed, how it was triggered (scheduled or manual), and which parameter values were active when it ran. The full log output is shown below with its own search box so you can hunt for specific lines. Prev/Next buttons let you step through runs without going back to the list.

Parameters tab

This is the feature I been wanting forever for my self but never took the time to build it until now. The built-in scheduled jobs admin has no concept of job parameters — you either hardcode values in the job or manage your own settings page somewhere. With this tool you can declare a typed parameters class, decorate it with a couple of attributes, and the tool renders a form for it automatically.

Supported field types: `string` (single line or multiline), `int`, `decimal`, `bool` (toggle), `ContentReference` (numeric ID with live name resolution), `enum` (dropdown), `[Flags] enum` (checkboxes), `DateTime`, and `TimeSpan`.

public class MyJobParams
{
    [JobParam("Content root", Description = "The page to process.")]
    public ContentReference? ContentRoot { get; set; }

    [JobParam("Batch size")]
    public int BatchSize { get; set; } = 100;

    [JobParam("Dry run", Group = "Safety")]
    public bool DryRun { get; set; }

    [JobParam("Run mode")]
    public RunMode Mode { get; set; } = RunMode.Incremental;
}

Parameters are saved to DDS per job and loaded automatically before each execution — whether the job runs on schedule or is triggered manually.

Schedule tab

The Schedule tab lets you enable or disable a job and change its run interval without going through the built-in admin. It also exposes the sleep window configuration (see below).

A warning is shown if you select a built-in Optimizely job, since schedule changes for those may get reset by CMS updates.

Sleep windows

Sleep windows let you define a time range during which a job should not execute — useful for jobs that should not run during business hours or during nightly maintenance windows.

You can declare a default sleep window directly on your job class:

[ScheduledPlugIn(DisplayName = "My nightly import")]
[SleepWindow("07:00", "22:00", "Europe/Stockholm")]
public class MyImportJob : ParameterizedScheduledJob<MyImportParams> { ... }

Operators can override the sleep window per-job in the Schedule tab without touching code. The UI always shows what the code default is so it is clear what the fallback is if the override is cleared. Manual runs always bypass the sleep window regardless.

Sleep window enforcement only applies to jobs that extend `ParameterizedScheduledJob<TParams>`.

Run tab

The Run tab has one job: start the selected job right now. While the job is running a progress bar and live status log are shown, updating every 500 ms as the job reports progress. A Stop button appears next to the Run button during execution.

Adding a parameterized job

To take advantage of typed parameters your job extends `ParameterizedScheduledJob<TParams>` instead of `ScheduledJobBase`, and you implement `ExecuteInternal()` instead of `Execute()`.

[ScheduledPlugIn(DisplayName = "My job")]
[JobParameters(typeof(MyJobParams))]
public class MyJob : ParameterizedScheduledJob<MyJobParams>
{
    public MyJob(JobConfigRepository cfg, IManualRunFlagService flag)
        : base(cfg, flag) { }

    protected override void ExecuteInternal()
    {
        Status.Add($"Starting with batch size {Parameters.BatchSize}");

        // your logic here

        Status.AddCount("Items processed", processedCount);
    }
}

`Status` is a `JobStatusBuilder` — a simple fluent builder that handles Optimizely's 2048-character limit on the status message field gracefully (it appends a truncation notice rather than silently cutting off). Before `ExecuteInternal()` runs, the base class pre-seeds `Status` with a compact summary of the current parameter values, so every run in the history log shows exactly what configuration was active.

Setup

services.AddJobMonitor(options =>
{
    options.DisplayTimeZoneId = "Europe/Stockholm"; // or any TimeZoneInfo.GetSystemTimeZones() Id
    options.ShowDetailedErrors = true; // set false in production
});

Create a page in the CMS tree using the included `ScheduledJobsAdminPage` content type (or adapt it to your own base page class). The page just needs a controller that renders the Blazor `JobMonitorShell` component.

That is it.

Source code

The full source is on GitHub: Nergard.ScheduledJobAdmin

The source contains a readme with more details.

As mentioned above — this has not been fully tested in a production environment. If you try it and hit something broken, or have ideas for improvements, issues and pull requests are very welcome.

Searchable settings page

Mon, 06 Apr 2026 17:24:09 GMT

In my current project which has been actively developed for quite some time we have a big classic settings page. Unfortunately the placement and naming of properties have not always been the best so I tend to end up searching for a property with ctrl+f in the browser when I know it should be there somewhere but i cant find it.

So today I thought of why not add an actual view to the page with a simple search so I atleast can figure out on what tab the property is on. I guess everyone has been using settings pages for ages but atleast I have nerver actually created a view for it.

It's a simple searchbox that filters on the property name and localized caption and descripton values. And the default listing view is just a long list grouped by tab.

It looks like below (a bit of a crappy image but I couldnt display that much of the properties) and you can find it over at my Gist.

Missing Properties tool for Optimizely CMS

Tue, 10 Mar 2026 21:18:57 GMT

If you have been working with Optimizely CMS for a while you have probably accumulated some technical debt in your property definitions. When you refactor your models removing properties, renaming content types, or cleaning up after a migration the old property definitions often stick around in the database. They are harmless for the most part, but they add noise and can be confusing when inspecting content types.

I actually built a tool for this like 10 years ago and I recently had a need to revisit it during a large migration project where we ended up with quite a few orphaned properties that
needed cleaning up.

What it does

The tool scans all your code-defined content types (PageTypes and BlockTypes) and looks for property definitions in the database that no longer have a corresponding attribute in code. Manually created content types are intentionally skipped it only checks types backed by a C# model.

The results are grouped by content type so you can see exactly what is affected. From there you have a few options:

- Select individual properties and delete them
- Select all properties for a specific content type
- Delete everything at once

Both deletion paths require a confirmation dialog because this operation is permanent and cannot be undone.

There is also a Rescan button if you want to re-check after deploying model changes.

Installation

Configure blazor and decide on how you want to render the component. I just created a content type specific for the tool. Example layout included on github.

Add the tool to your project and register it in Startup.cs:

services.AddMissingProperties();

The source code is on https://github.com/pernergard/NergardToolsAndUtilities

Resource Editor - A localization management tool for Optimizely CMS

Mon, 23 Feb 2026 06:58:46 GMT

If you have worked with Optimizely CMS for any amount of time you know that managing localization through XML files can be tedious. Content type names, property captions, tab names, editor hints - they all need translations, and keeping those XML files organized across multiple languages is not fun.

I am a firm believer that translations should be owned by the partner and managed in source control. That said, I fully understand the need to fix localization quickly in a DXP environment without having to deploy code. The Resource Editor was built to handle both scenarios - edit and save to XML files during development, and apply runtime overrides via DDS (Dynamic Data Store) when you need a quick fix in production.

This tool started as a smaller idea but grew quite a bit as I kept adding features. It is built with Blazor Server and MudBlazor, packaged as a Razor Class Library that you can reference in your Optimizely project.

TL;DR: The Resource Editor is a Blazor-based admin tool for Optimizely CMS that replaces manual XML editing for localization. It provides visual editors for content type names, properties, tabs, display channels, editor hints, and frontend translations — all with multi-language support. Features include a completeness dashboard, runtime overrides via DDS (no deploy needed), DeepL-powered automated translation at field/item/bulk level, CSV import/export, and a guided migration from legacy XML formats.

Getting started

The Resource Editor is distributed as a Razor Class Library. Add a project reference and register the services in your `Startup.cs`:

public void ConfigureServices(IServiceCollection services)
{
    services.AddServerSideBlazor();
    services.AddMudServices();

    // Optional: Add DeepL translation (must be registered before AddResourceEditor)
    services.AddDeepLTranslation(_configuration);

    // Register Resource Editor services
    services.AddResourceEditor(_configuration);
}

Configuration is done through `appsettings.json`:

{
  "ResourceEditor": {
    "TranslationFolder": "Resources/Translations",
    "EnableFileSaving": true,
    "EnableOverrides": true,
    "ShowOverridesUI": true,
    "EnableAutomatedTranslation": true,
    "DeepL": {
      "ApiKey": "your-api-key",
      "UseFreeApi": true
    }
  }
}

Depending on how you want to render the tool you also need a CSHTML page to host the Blazor component. The tool runs as a full-page Blazor application without the standard Optimizely layout:

@using Nergard.ResourceEditor.Components
@using Microsoft.AspNetCore.Components.Web
@model PageViewModel<BlazorToolResourceEditor>

@{ Layout = null; }

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1" />
    <base href="~/" />
    <title>Resource Editor</title>
    <link href="https://fonts.googleapis.com/css?family=Roboto:300,400,500,700&display=swap"
          rel="stylesheet" />
    <link href="_content/MudBlazor/MudBlazor.min.css" rel="stylesheet" />
    <component type="typeof(HeadOutlet)" render-mode="Server" />
</head>
<body>
    @Html.AntiForgeryToken()

    <component type="typeof(ResourceEditorHost)"
               render-mode="Server"
               param-IsDarkMode="false" />

    <script src="_framework/blazor.server.js"></script>
    <script src="_content/MudBlazor/MudBlazor.min.js"></script>
</body>
</html>

Create a page type in Optimizely, set up a controller and view, and you are good to go.

Dashboard

When you open the Resource Editor you land on the dashboard. It gives you an overview of translation completeness across all your configured languages. Each language card shows progress for content types, properties and tabs so you can quickly see where translations are missing.

The dashboard also shows your view/frontend translation files with their own completion status.

Clicking a language card takes you directly to the Language Overview for that language. More on that further down in the post.

Content type editor

This is where you probably will spend most of your time. The editor lets you manage translations for all your content types, organized in three sections: Pages, Blocks and Media.

For each content type you can edit the name and description across all languages. Expand a content type and you get access to all its properties where you can edit both the caption (label) and help text.

The editor detects shared properties - properties that exist on multiple content types - and highlights them. This is useful because shared properties in Optimizely use a fallback mechanism through `icontentdata`, so changing a shared property translation can affect multiple content types. The base type in the saved xml-files will be icontentdata since I believe that same named properties should be consistent throughout the solution.

You can filter by language if you only want to focus on one language at a time. The tool has support for automatic translations but not for the master language which must be managed manually.

Tab editor

The Tab Editor handles localization of property group names (tabs). These are the tab labels editors see in the content editing UI.

It works the same way as the content type editor - select a tab, edit the name across all configured languages, save.

Display Channels and Editor Hints

Two smaller editors handle display channel names and editor hint names. Same pattern - select an item, edit translations, save. These are less commonly needed but nice to have covered.

View / Frontend Translations

The Resource Editor also handles view translation files.

These files use a multi-language format where all languages are in a single XML file. The editor presents them as a navigable tree structure where you can edit values per language, add new sections and add new keys.

The file pattern is configurable via the `ViewFilePattern` option (defaults to `views_*.xml`).

Language overview

The Language Overview gives you a focused view of a single language. It shows all content types and their properties with translation status indicators so you can work through missing translations systematically.

This is also where the bulk translate button lives - translate all incomplete fields for a language in one click.

Note! The automatic translations are only for the non master languages. So put in the effort for good localization texts for the master language you can reap the benefits for the other languages.

Overrides

This is the feature that makes the Resource Editor work well in DXP environments. Overrides are stored in the Dynamic Data Store and take precedence over XML translations at runtime - no deployment needed.

The override system works through a custom `LocalizationProvider` that is automatically registered at position 0 in the provider chain. When Optimizely resolves a localization key, the override provider checks DDS first. If no override exists, it falls through to the standard XML-based providers.

**Known issue:** There is currently a known issue where overridden content type captions (names) may not be picked up correctly by Optimizely, while help text overrides work as expected. I have an ongoing support ticket with Optimizely for investigation.

Inline overrides

When `ShowOverridesUI` is enabled, every text field in the editors gets a small override button. Click it and you can create an override for that specific field and language. The override is stored in DDS and takes effect immediately.

Override manager

- View all active overrides with language and value

- Filter by language and search by property name

- Add, edit and delete individual overrides

- **Export to CSV** for documentation or backup

- **Import from CSV** for bulk operations

- **Save to XML** to migrate an override into a permanent translation file

- Clear all overrides

Automated translations with DeepL

If you enable automated translation and register the DeepL service, the Resource Editor gives you translation assistance at three levels:

1. **Field level** - Each text field gets a translate button that translates from the default language

2. **Item level** - A "Translate Missing" button in each editor header translates all empty fields for the current item

3. **Bulk level** - In the Language Overview, translate all incomplete fields for an entire language

The translations populate the fields but are not saved automatically - you review and save when you are happy with the results.

To enable it, signup for the free tier of DeepL and then register the DeepL service before the Resource Editor:

services.AddDeepLTranslation(_configuration);
services.AddResourceEditor(_configuration);

The translation service is pluggable. If you want to use a different provider than DeepL, implement `ITranslationService` and register it before calling `AddResourceEditor()`.

XML Migration

If you have an existing site with translations in the classic Alloy XML format (separate files like `ContentTypeNames.xml`, `PropertyNames.xml`, `GroupNames.xml`), the Resource Editor detects this automatically and offers a guided migration to its own format. The migration runs step by step with progress tracking and error reporting.

Configuration options

Here is a quick overview of all the configuration options:

| Option | Default | Description |
|--------|---------|-------------|
| `TranslationFolder` | `Resources/Translations` | Path to translation XML files |
| `EnableFileSaving` | `true` | Allow saving to XML files. Set to `false` on DXP |
| `EnableOverrides` | `true` | Enable DDS-based runtime overrides |
| `ShowOverridesUI` | `true` | Show inline override buttons in editors |
| `EnableAutomatedTranslation` | `false` | Enable automated translation features |
| `ViewFilePattern` | `views_*.xml` | Glob pattern for view translation files |

A typical DXP configuration would look like this:

{
  "ResourceEditor": {
    "EnableFileSaving": false,
    "EnableOverrides": true,
    "ShowOverridesUI": true
  }
}

Source code and license

The full source code is available on GitHub: Resource Editor GitHub

This tool grew organically and while I have been testing it using a Alloy demo template, I would still recommend using it with some care - especially the save operations. Back up your XML files before making large changes. I am happy to receive feedback, bug reports and pull requests.

Scheduled job for deleting content types and all related content

Fri, 30 Jan 2026 13:09:03 GMT

In my previous blog post which was about getting an overview of your sites content https://world.optimizely.com/blogs/Per-Nergard/Dates/2026/1/scheduledjob-for-getting-overview-of-site-content-usage/.

I actually found a couple of content types that was related to decomission functionality that actually hade quite a lot of created content. So what to do? ContentTypeObliteratorScheduledJob to the rescue.

It's very simple:

Get the contenttype ids you want to remove all content for and deleting the actual content type as well.
Take a database backup
Add the contenttype ids into a comma separated list
Run the job and enjoy less code and a less bloated content tree.

I have only done a test run on one content type but for that it worked.

Link to my Gist: ContentTypeObliteratorScheduledJob.

ScheduledJob for getting overview of site content usage

Tue, 27 Jan 2026 22:47:29 GMT

In one of my current project which we are going to upgrade from Optimizely 11 I needed to get an overview of the content and which content types we have, are some unused etc.

In order to do that I did a scheduled job that will go through the sites content types, check for usage and if a content type id is specified render links to edit mode for all content instances for that type.

Everything is wrapped up into a CSV file that are easily imported into excell for easy filtering and send that as an attached file via SMTP.

In the code you can change sender, recipients and after an initial run and you also want to get the links to the content instances for one or more content types that can be set as well.

The collumns you get is the following:

I expected some content types with zero content instances but to my suprise the number was bigger than I expected.

Nothing advanced but a simple way to identify content types that could be removed or find all instances of a content type that you might be able to remove after you actually check the content.

You can find the content over at my gist. ScheduledJob content usage Gist

ScheduledJob overview Blazor component

Thu, 15 Jan 2026 15:21:39 GMT

I have always felt that the admin UI for scheduled jobs in Optimizely is harder to use than it needs to be. To check a job you have to go into admin, filter to find the right job, click to see the history, and then click again to view status messages. When you are troubleshooting, this quickly becomes frustrating.

Back in 2017 I tried to improve this by creating a small plugin for viewing scheduled job run history. I wrote about it here:
https://world.optimizely.com/blogs/Per-Nergard/Dates/2017/9/plugin-for-viewing-scheduled-job-run-history/

During the Christmas break I decided to revisit the idea. The result is a Blazor component that gives a better overview of scheduled jobs and their status messages, with fewer clicks and faster access to the information you usually care about. I am using MudBlazor for UI components. It's a Razor Class Library so you need to configure Blazor in you CMS solution and see that the MudBlazor css and js are loaded.

The component includes:

Separate tabs for custom jobs and built-in jobs, since custom jobs are often the ones causing issues
Filtering on job names
Direct access to the latest run and status message when selecting a job
A list view of up to 1000 status message excerpts with keyword filtering
Drill-down into a specific status message with additional filtering

Image 1: Overview of the component.

Image 2: A selected job showing all status messages.

Image 3: Drill-down view of a single status message with filtering.

The full source code is available in a public GitHub repository:

https://github.com/PNergard/ScheduledJob-overview-Blazor-component

PageCriteriaQueryService builder with Blazor and MudBlazor

Mon, 10 Feb 2025 09:59:23 GMT

This might be a stupid idea but my new years resolution was to do / test more stuff so here goes. This razor component allows users to build and execute queries against your CMS site, providing a semi user-friendly interface for searching for pages based on content type, properties.

You do need to have knowledge about your content types and the data but the thought is that when the need arises to identify what pages / how many pages you have with a certain combination of data you should be able to find those without any coding. If the results are not that many maybe manually editing them and adjusting what is needed is enough. If the number is to high or more complex changes needs to be performed a action-button can be added to do the work instead of possible doing a scheduled job or something.

You can find the code over at my Gist.

Criteria:
So you can create criteria parameters based on content type , propertes and condition and make them required or not. Required parameters will be shown in green.

Search:
When youre happy with your criterias you select a startnode (Root or any of the defined sites) and hit search. If you are not happy with the results you can delete individual parameters or all.

Results:
Simple list with a link to edit mode for each content that opens in a new tab.

Actions:
I actually haven't implemented any actions. But the idea is that it's easy to add any action need to perform actions on the search result.

Looks like this:

Content statistics Blazor component

Tue, 28 Jan 2025 13:54:43 GMT

Another week and another MudBlazor component to explore. I wanted to test the charts components so I created a small Blazor component that displays som charts based on information we can get from the pages of a site.

How many pages are created / updated on a monthly basis
Whats the most used content type
When are pages created during the day
When are pages being updated during the day
Who is the most productive content creator

Not life changing stuff but could be a bit fun to get an overview. Code over at my Gist.

Looks like this in a Alloy solution:

Find and delete non used media and blocks

Tue, 21 Jan 2025 07:43:26 GMT

On my new quest to play around with Blazor and MudBlazor I'm going back memory lane and porting some previously plugins. So this time up is my plugin for finding non used images in the global assets folder and you can read the old blog post from 2017 over here.

I decided I wanted to update it a bit so it could look for blocks as well. It's not that much to tell about it but you can choose if you want to look for media and / or blocks and look for orphans and then optionally delete selected or all.

You can grab the code over at my Gist.

I have in my tests used the component in a page type I have setup for Blazor testing but if you want to have it as a plugin have a look at Ove Lartelius excellent post about how to run you components in different areas of the Optimizely UI here.

And it looks like this

Order tabs with drag and drop - Blazor

Tue, 14 Jan 2025 12:56:20 GMT

I have started to play around a little with Blazor and the best way to learn is to reimplement some old stuff for CMS12.

So I took a look at my old blog posts and decided to redo my plugin for drag and drop sorting of tabs since I still don't like that using the [GroupDefinition] attribute forces you do manage the index order in code. Old blog post here.

My thought with this Blazor component is to have a tools content type with it's own layout which is only for tools and stuff done with Blazor. If feels easier than doing menuproviders or plugins in admin mode.

It's very simple, just a list of the tabs which you can reorder with drang and drop and then save or reset (only currently unsaved order). In the example it's wrapped into another component for a header and navigation but it's not included in the component.

You can find the code and a small readme over at my Gist.

ImageFile alt-description validation attribute

Tue, 07 Jan 2025 14:13:03 GMT

A customer wanted to improve their quality of having meta descriptive texts on all their published images but it was ok that it could take some time to get it into place (they are forced to review and republish pages on a regular basis) so thought that a validation attribute would do the trick.

I vaguely remebered that I did something like this a long time a go which I had (nov 2015) but that didn't handle images added in Xhtml-properties which was needed in this case. I found a solution that had solved a similiar problem but did handle it on actual rendering which used HtmlAgilitypack to handle the check for xthml-editors.

So I updated my validation attribute and I have published it as a Gist. ImageValidatorGist.

The validation attribute checks contentreference, ContentArea and XhtmlEditor properties for images and check if they have a description property with value and if not returns an error. Since a image-file added to a XhtmlEditor gets the filename name as alt-text we need to compare the alt-text to the file-name and if equal we interpret that as not set even if the image file it self might have a descripton set.

Developer meetup i Göteborg

Fri, 14 Feb 2020 14:14:42 GMT

Knowit och Episervers meetup i Malmö var en succé så nu kör vi den även i Göteborg den 3e mars. Så om man är intresserad av att höra mer om vad som är på gång inom .Net core eller lära sig mer om Episervers nya referens arkitektur "Foundation" ska man genast klicka sig vidare till meetup sidan och anmäla sig. Kan ni inte gå just detta tillfälle passa på att gå med i gruppen så att ni inte missar kommande events!

https://www.meetup.com/EPiServer-utvecklare-Goteborg/events/268705786/

Developer meetup in Malmö

Mon, 27 Jan 2020 12:45:35 GMT

After a long slumber in the Episerver Developers Öresund group Knowit and Episerver is kicking off 2020 with a developer meetup in Malmö february 6.

Episerver .Net Core and the new reference project Episerver Foundation is the topics of the evening.

So if you are in the Öresund area come and join us.

See below link to sign up!

https://www.meetup.com/EPiServer-utvecklare-Oresund/events/267933749/

Use a page type as a scheduledjob

Tue, 21 Jan 2020 09:55:36 GMT

Scheduledjobs have evolved a bit over the years but they still lack a nice way to have input parameters. If you don't hard code everything I see the following alternatives.

Appsettings
Works but can only be done by a developer with access to the server environment. Causes a restart of the website.
Properties on a page
I really like using a builtuin way to get a nice editorial experience when setting parameters. But having to view logs / status in admin mode and change settings in edit mode feels a bit disconnected. And I think that admin-mode access for non developers should be kept to an absolute minimum.
Extending the builtin views in admin mode
Mathias Kunto did a nice implemantation where you can extend the builtin views with the help of control adapters. You can read his blog post here.

So hardcoding and using appsettings is out of questions but I really like using builtin editorial features for a smooth experience but mixing edit and admin mode together makes is hard to understand. Mathias way is for sure the most "integrated" way of doing it, but is in admin mode which is still in webforms and for some jobs I would like a more granular control over who can handle specific jobs without giving access to everything in admin mode.

So here is a proof of concept of the solution I came up with: A page type that after initial publish it automatically sets it self for scheduled publishing according to the preffered interval and all work is done during the publishing event.

To get everything up and running we need a specific page type which have all the settings we want and the model will contain all code that do the actual scheduledwork and handling logging. We also need an initalizationmodule hooking up to the PublishingContent and PublishedContent events. And of course the schedulejob handling future publishing of content must be up and running.

The page type is lika any normal page type but it contains one method that will perform all work and log a status message to a IList property:

public void DoTheMagic()
{
  if (this.HistoryLog == null) this.HistoryLog = new List<Log>();

     var message = new Log
     {
       Date = DateTime.Now.ToString(),
       Message = "We did som magic!",
       ExecutedBy = "The logged in user"
      };

      this.HistoryLog.Add(message);
}

In the initaliziationmodule PublishingContent event if the content is of the correct type we call the DoTheMagic method. We need to do it in the publishing event because we are creating a log message and adds it to the logging IList property and we need to have the object in a writable state.

private void ToolPageInitializationModule1_PublishingContent(object sender, EPiServer.ContentEventArgs e)
{
    var page = e.Content as ToolPage;

    if (page != null)
    {
        page.DoTheMagic();
    }
}

To hande setting the new scheduled publish date we need to to it in the PublishedContent event. Trying to change the date in the same event as the DoTheMagic don't work.

private void ToolPageInitializationModule1_PublishedContent(object sender, ContentEventArgs e)
{
    var page = e.Content as ToolPage;
    var writable = page.CreateWritableClone() as ToolPage;

    if (page != null)
    {
        if (page.Interval == "Minute")
        {
            var date = writable.StartTime = page.StartTime.AddMinutes(page.IntervalValue);
            writable.StartPublish = date;

            ServiceLocator.Current.GetInstance<IContentRepository>().Save(writable, SaveAction.CheckIn | SaveAction.Schedule, EPiServer.Security.AccessLevel.NoAccess);
        }

    }
}

So in the editorial interface it looks like this:

So this is only a simple proof of concept but it does what I set up to do so at this stage Im happy :)

Find and delete content based on type

Mon, 17 Jun 2019 15:47:46 GMT

Another blog post and another admin mode plugin..

From time to time I have had the need to delete content for specific types. It could be a cleanup case before using a dev database as UAT or maybe we wan't to discard some content type.

In general content of a specific types tend to be all over the place especially with images and blocks so this can be a tedious process. So I whipped together a small admin mode plugin that lets you select a type and get a list of all content-instances and lets you delete all or selected instances of that type. Nothing fancy but it does it't job.

You can find the code over at my Gist and it looks lite this.