Property values not saved when content published only in non-default languages

[KevinLall-MacsAdventure]

Which Umbraco version are you using?

15.4.3 and 16.1.0 (confirmed affected versions)

Bug summary

When content is published ONLY in non-default languages (e.g., only in "de-DE" but not in "en-GB" if en-GB is the default language), Umbraco fails to properly save property values to the database. The content appears published in the back office and shows correct values there, but:

1. The published property values in the database are NULL or contain stale data
2. IPublishedContent.Value() returns empty/null values on the front-end
3. Future content updates don't get reflected until the content is published in the default language

This only seems to affect invariant properties that are shared across cultures.

Specifics

This bug occurs specifically when:

• Content is created and published only in non-default languages
• OR existing content is updated and published only in non-default languages
• The default language is not included in the publish operation

The issue does NOT occur when:

• Content is published in the default language (even if also published in other languages)
• Content that was previously published in the default language is updated

Workaround: Publishing the content in the default language and then immediately unpublishing it resolves the issue and allows future updates to work correctly.

Database inspection shows that the cmsContentNu table (published content cache) contains NULL values for the affected properties when content is only published in non-default languages.

Steps to reproduce

1. Create a new content item with properties shared across cultures
2. Add content values in a non-default language (e.g., de-DE)
3. Publish the content ONLY in the non-default language (do not publish in default language)
4. Check the front-end - property values will be empty/null
5. Check the database cmsContentNu table - published values will be NULL
6. Verify that IPublishedContent.Value() returns null for the properties

Alternative reproduction:

1. Take existing content that is published in multiple languages
2. Make changes to the content
3. Publish ONLY in a non-default language
4. Observe that the changes are not reflected on the front-end

Expected result / actual result

Expected:

• Property values should be correctly saved to the database when content is published in any language
• IPublishedContent.Value() should return the correct values for published content
• Front-end should display the published content values regardless of which languages the content is published in

Actual:

• Property values are not saved to the database (cmsContentNu table shows NULL values)
• IPublishedContent.Value() returns null/empty values
• Front-end displays empty content even though the back office shows the content as published with values
• The only way to fix affected content is to publish it in the default language and then unpublish from the default language

[github-actions]

Hi there @KevinLall-MacsAdventure!

Firstly, a big thank you for raising this issue. Every piece of feedback we receive helps us to make Umbraco better.

We really appreciate your patience while we wait for our team to have a look at this but we wanted to let you know that we see this and share with you the plan for what comes next.

• We'll assess whether this issue relates to something that has already been fixed in a later version of the release that it has been raised for.
• If it's a bug, is it related to a release that we are actively supporting or is it related to a release that's in the end-of-life or security-only phase?
• We'll replicate the issue to ensure that the problem is as described.
• We'll decide whether the behavior is an issue or if the behavior is intended.

We wish we could work with everyone directly and assess your issue immediately but we're in the fortunate position of having lots of contributions to work with and only a few humans who are able to do it. We are making progress though and in the meantime, we will keep you in the loop and let you know when we have any questions.

Thanks, from your friendly Umbraco GitHub bot 🤖 🙂

[KevinLall-MacsAdventure]

This is my workaround until this bug gets fixed, this hooks onto the publish event and detects if the node is only being published in cultures other than the default, and if so publishes the node in the default culture before immediately unpublishing it.

using System;
using System.Linq;
using Microsoft.Extensions.Logging;
using Umbraco.Cms.Core.Composing;
using Umbraco.Cms.Core.DependencyInjection;
using Umbraco.Cms.Core.Events;
using Umbraco.Cms.Core.Models;
using Umbraco.Cms.Core.Notifications;
using Umbraco.Cms.Core.Security;
using Umbraco.Cms.Core.Services;

namespace MacsAdventure.Core.Startup;

/// <summary>
/// WORKAROUND FOR UMBRACO BUG:
/// 
/// When content is published ONLY in non-default languages (e.g., only in "de-DE" but not in "en-GB"),
/// Umbraco fails to properly save the property values to the database. The content appears published
/// and the back office shows the correct values, but:
/// 
/// 1. The published property values in the database are NULL or contain stale data from previous publishes
/// 2. IPublishedContent.Value<T>() returns empty/null values on the front-end
/// 3. Future content updates don't get reflected until the content is published in the default language
/// 
/// This affects only invariant properties and when content is only published in 
/// non-default languages.
/// 
/// KNOWN VERSIONS AFFECTED:
/// 
/// 15.X
/// 16.X
/// 
/// WORKAROUND:
/// This handler detects when content is published only in non-default languages and applies
/// a "publish-then-unpublish" workaround:
/// 
/// 1. Copy mandatory property values to the default language (if missing)
/// 2. Publish the content in the default language (forces Umbraco to save property values correctly)
/// 3. Immediately unpublish from the default language (removes the default language publication)
/// 
/// This ensures property values are properly stored while maintaining the desired publication state.
/// </summary>
public class ContentSaveFixComposer : IComposer
{
    public void Compose(IUmbracoBuilder builder)
    {
        builder.AddNotificationHandler<ContentPublishingNotification, UmbracoMultiLanguageBugFixHandler>();
    }
}

public class UmbracoMultiLanguageBugFixHandler : INotificationHandler<ContentPublishingNotification>
{
    private readonly ILanguageService _languageService;
    private readonly IContentService _contentService;
    private readonly IBackOfficeSecurityAccessor _backOfficeSecurityAccessor;
    private readonly ILogger<UmbracoMultiLanguageBugFixHandler> _logger;

    public UmbracoMultiLanguageBugFixHandler(
        ILanguageService languageService,
        IContentService contentService,
        IBackOfficeSecurityAccessor backOfficeSecurityAccessor,
        ILogger<UmbracoMultiLanguageBugFixHandler> logger)
    {
        _languageService = languageService;
        _contentService = contentService;
        _backOfficeSecurityAccessor = backOfficeSecurityAccessor;
        _logger = logger;
    }

    public void Handle(ContentPublishingNotification notification)
    {
        var defaultLanguage = GetDefaultLanguage();

        foreach (var entity in notification.PublishedEntities)
        {
            // Check which cultures are being published in this specific action
            var publishingCultures = entity.AvailableCultures
                .Where(culture => notification.IsPublishingCulture(entity, culture))
                .ToArray();
            
            // Apply workaround if ONLY non-default languages are being published
            if (publishingCultures.Any() && !publishingCultures.Contains(defaultLanguage))
            {
                // Cancel the original publish operation
                notification.CancelOperation(new Umbraco.Cms.Core.Events.EventMessage("Umbraco Multi-Language Bug Workaround", 
                    "Applying workaround for property value persistence bug", 
                    Umbraco.Cms.Core.Events.EventMessageType.Info));

                _logger.LogInformation($"Applying workaround for content {entity.Id} - publishing only in: {string.Join(", ", publishingCultures)}");
                ApplyWorkaround(entity.Id, entity?.Name ?? string.Empty, publishingCultures, defaultLanguage, notification);
            }
        }
    }

    private void ApplyWorkaround(int contentId, string contentName, string[] publishedCultures, string defaultLanguage, ContentPublishingNotification notification)
    {
        _logger.LogInformation($"Applying Umbraco multi-language bug workaround for content {contentId} ({contentName}) - published only in: {string.Join(", ", publishedCultures)}");

        try
        {
            var content = _contentService.GetById(contentId);
            if (content == null) return;

            // Copy mandatory property values to default language to ensure publish will succeed
            CopyMandatoryPropertiesToDefaultLanguage(content, publishedCultures, defaultLanguage);

            // Apply the publish-unpublish workaround
            PublishThenUnpublishWorkaround(content, defaultLanguage, publishedCultures, notification);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, $"Error applying workaround for content {contentId}");
        }
    }

    private void CopyMandatoryPropertiesToDefaultLanguage(IContent content, string[] publishingCultures, string defaultLanguage)
    {
        var hasChanges = false;
        
        // Copy ALL mandatory properties that are missing in default language (not just culture-variant)
        foreach (var property in content.Properties.Where(p => p.PropertyType.Mandatory))
        {
            var defaultValue = property.GetValue(defaultLanguage);
            if (IsEmptyValue(defaultValue))
            {
                var sourceValue = GetValueFromPublishedCultures(property, publishingCultures);
                if (sourceValue != null)
                {
                    if (property.PropertyType.VariesByCulture())
                    {
                        content.SetValue(property.Alias, sourceValue, defaultLanguage);
                    }
                    else
                    {
                        // For invariant properties, set without culture
                        content.SetValue(property.Alias, sourceValue);
                    }
                    _logger.LogDebug($"Copied mandatory property {property.Alias} to {defaultLanguage}");
                    hasChanges = true;
                }
            }
        }

        // Copy content name if missing in default language
        var defaultName = content.GetCultureName(defaultLanguage);
        if (string.IsNullOrWhiteSpace(defaultName))
        {
            var sourceName = GetNameFromPublishedCultures(content, publishingCultures);
            if (!string.IsNullOrWhiteSpace(sourceName))
            {
                content.SetCultureName(sourceName, defaultLanguage);
                _logger.LogDebug($"Copied content name to {defaultLanguage}");
                hasChanges = true;
            }
        }
        
        // Save changes before attempting to publish
        if (hasChanges)
        {
            var saveResult = _contentService.Save(content);
            if (saveResult.Success)
            {
                _logger.LogDebug($"Saved mandatory property changes for content {content.Id}");
            }
            else
            {
                _logger.LogError($"Failed to save mandatory property changes for content {content.Id}");
            }
        }
    }

    private void PublishThenUnpublishWorkaround(IContent content, string defaultLanguage, string[] publishingCultures, ContentPublishingNotification notification)
    {
        var currentUserId = GetCurrentUserId();

        var publishingCulturesList = publishingCultures.ToList();
        publishingCulturesList.Add(defaultLanguage);
        publishingCultures = publishingCulturesList.ToArray();

        //We need to store original publish state of default culture
        var isPublishedInDefaultLanguage = content.IsCulturePublished(defaultLanguage);
        
        // Step 1: Publish in default language (forces Umbraco to save property values correctly)
        var publishResult = _contentService.Publish(content, publishingCultures, currentUserId);
        if (!publishResult.Success)
        {
            _logger.LogError($"Failed to publish content {content.Id} in default language during workaround");
            return;
        }

        // Step 2: Immediately unpublish from default language if it wasn't already published (preserves property values but removes publication)
        var success = isPublishedInDefaultLanguage;
        if (!isPublishedInDefaultLanguage)
        {
            var unpublishResult = _contentService.Unpublish(content, defaultLanguage, currentUserId);
            if (unpublishResult.Success)
            {
                success = true;
                _logger.LogInformation($"Successfully applied workaround for content {content.Id} - property values preserved");
            }
            else
            {
                _logger.LogError($"Failed to unpublish content {content.Id} from default language");
            }
        }

        if (success)
        {
            //Display a success message to the user
            notification.CancelOperation(new Umbraco.Cms.Core.Events.EventMessage("Umbraco Multi-Language Bug Workaround", 
                "Your content has been published with multi-language compatibility fixes applied.\n\nNote: A workaround was automatically applied to resolve an Umbraco property value persistence issue when publishing content only in non-default languages.\n\nThe event cancelled error message can be safely ignored.", 
                Umbraco.Cms.Core.Events.EventMessageType.Success));
        }
    }

    private int GetCurrentUserId()
    {
        var currentUser = _backOfficeSecurityAccessor.BackOfficeSecurity?.CurrentUser;
        return currentUser?.Id ?? -1; // -1 is system/unknown user in Umbraco
    }

    private string GetDefaultLanguage()
    {
        var languages = _languageService.GetAllAsync().GetAwaiter().GetResult();
        return languages?.FirstOrDefault(x => x.IsDefault)?.IsoCode ?? "en-GB";
    }

    private object? GetValueFromPublishedCultures(IProperty property, string[] publishedCultures)
    {
        foreach (var culture in publishedCultures)
        {
            var value = property.GetValue(culture);
            if (!IsEmptyValue(value))
            {
                return value;
            }
        }
        return null;
    }

    private string? GetNameFromPublishedCultures(IContent content, string[] publishedCultures)
    {
        foreach (var culture in publishedCultures)
        {
            var name = content.GetCultureName(culture);
            if (!string.IsNullOrWhiteSpace(name))
            {
                return name;
            }
        }
        return content.Name;
    }

    private bool IsEmptyValue(object? value)
    {
        return value == null || string.IsNullOrWhiteSpace(value?.ToString());
    }
} 

[AndyButland]

Thanks for reporting @KevinLall-MacsAdventure. I'll be honest in saying I'm not 100% sure on the history of this, but based on #12386, it looks like this is expected behaviour.

So you should set the configuration key Umbraco:CMS:Content:AllowEditInvariantFromNonDefault to true to get the behaviour you are looking for.

We document this here: https://docs.umbraco.com/umbraco-cms/reference/configuration/contentsettings#allow-edit-invariant-from-non-default - but it's not super-clear and there are some errors in the copy such as the default value, so I'll get that sorted out in the docs.

I'll close this issue though as having tested locally I've verified I can replicate the problem but it's resolved by using this setting.

[AndyButland]

Proposed documentation update is here: umbraco/UmbracoDocs#7278