KennyG
OMVPPaaS CMS Developer Certification
Jun 2, 2025
visibility 2063
star star star star star
(0 votes)

Follow-Up: Fixing JSON Casing in Optimizely CMS Export Data

*Note: This issue seems to be resolved with EPiServer.CMS Version 12.33.1.

A Targeted Action Filter to Enforce CamelCase

In my previous blog post, I discussed an issue we were having with JSON formatting in Optimizely CMS exports after updating NuGet packages. Specifically, the /EPiServer/EPiServer.Cms.UI.Admin/ExportData/GetExportStatus endpoint returned PascalCase JSON property names, breaking other parts of our site where the frontend expected camelCase.

That led to UI failures—most notably, a never-ending loading spinner. To address this without affecting global JSON settings, I implemented an action filter that ensures camelCase formatting for this specific route. Here’s how it works.

Recap: Why JSON Formatting Matters

Many JavaScript frameworks (like React and Angular) expect JSON property names in camelCase. When a response unexpectedly comes in PascalCase, bindings can break, leading to missing data or even complete UI failures.

Instead of globally modifying JSON settings—which might have unintended consequences across the CMS—the best approach is a targeted fix that applies only to the problematic endpoint.

The Solution: CamelCase JSON for Export Status

This ASP.NET Core action filter ensures JSON responses from /EPiServer/EPiServer.Cms.UI.Admin/ExportData/GetExportStatus are always camelCase:

using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.Filters;
using Microsoft.AspNetCore.Mvc.Formatters;
using System.Text.Json;
using System.Linq;
using System.Text.Json.Serialization.Metadata;

namespace Website.API.Filters
{
    /// <summary>
    /// Action filter to enforce camelCase JSON for /EPiServer/EPiServer.Cms.UI.Admin/ExportData/GetExportStatus responses.
    /// </summary>
    public class CamelCaseJsonForExportStatusFilter : IActionFilter
    {
        public void OnActionExecuting(ActionExecutingContext context)
        {
            // No action needed before execution
        }

        public void OnActionExecuted(ActionExecutedContext context)
        {
            // Only apply to the specific route
            var path = context.HttpContext.Request.Path.Value;
            if (!string.Equals(path, "/EPiServer/EPiServer.Cms.UI.Admin/ExportData/GetExportStatus",
                    StringComparison.OrdinalIgnoreCase))
                return;

            if (context.Result is ObjectResult objectResult)
            {
                // Find the SystemTextJsonOutputFormatter and update its options
                var jsonFormatter = objectResult.Formatters
                    .OfType<SystemTextJsonOutputFormatter>()
                    .FirstOrDefault();

                if (jsonFormatter != null)
                {
                    // Update the naming policy to camelCase
                    jsonFormatter.SerializerOptions.PropertyNamingPolicy = JsonNamingPolicy.CamelCase;
                }
                else
                {
                    objectResult.Formatters.Add(new SystemTextJsonOutputFormatter(
                        new JsonSerializerOptions
                        {
                            PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
                            WriteIndented = false,
                            TypeInfoResolver = new DefaultJsonTypeInfoResolver()
                        }
                    ));
                }
            }
        }
    }
}

How to Plug It In

Add the following to Startup.cs to register the filter globally (since it self-filters by route):

services.AddControllersWithViews(options =>
{
    options.Filters.Add<CamelCaseJsonForExportStatusFilter>();
});

The filter only runs logic when the request is for /ExportData/GetExportStatus, so it’s safe to register app-wide.

How It Works

  1. Intercepting the Response
    • The filter implements IActionFilter, modifying responses after an action executes.
    • OnActionExecuting remains empty since no changes are needed before execution.
    • OnActionExecuted checks if the request path matches the export status endpoint.
  2. Applying JSON Formatting
  • If the response is an ObjectResult, it searches for an existing SystemTextJsonOutputFormatter.
  • If found, it updates its SerializerOptions.PropertyNamingPolicy to JsonNamingPolicy.CamelCase.
  • If no formatter exists, it adds a new one with the correct settings.

Why This Approach?

  • Scoped Fix – Only affects /ExportData/GetExportStatus, leaving other JSON responses untouched.
  • Minimal Overhead – Modifies existing formatters when possible, optimizing performance.
  • Future-Proofing – Ensures a formatter exists even if Optimizely CMS updates its behavior later.

Conclusion

This targeted action filter prevents unexpected JSON formatting issues in Optimizely CMS. By enforcing camelCase only for the export status response, it eliminates UI failures while avoiding unnecessary changes to global settings.

Let me know if you have alternative approaches or thoughts—drop them in the comments. 

Jun 02, 2025

Comments

error Please login to comment.
Latest blogs
No name

Jagmeet Kaur | Nov 19, 2026 |

What the CMS 13 MCP Server Actually Does When You Write Properties

This post covers the setup gotchas, what each

Adnan Zameer | Nov 19, 2026 |

Pick images from Optimizely DAM straight into rich text

Rich text editors in Optimizely CMS (SaaS), and in CMS 13.7.0 on sites that use the Content Manager, have a new image button. It puts images from t...

Stuart Greig | Nov 18, 2026

Setting up the TinyMCE image picker, and DAM images in Graph and the CMS REST API

The new TinyMCE image and video pickers put images and video from the CMS and from Optimizely DAM straight into rich text, in Optimizely CMS (SaaS)...

Stuart Greig | Nov 18, 2026