Support limited language access at block level

src/Umbraco.Core/Services/ContentEditingService.cs

@@ -1,6 +1,6 @@
-using Microsoft.Extensions.DependencyInjection;
-using Microsoft.Extensions.Logging;
-using Umbraco.Cms.Core.DependencyInjection;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
+using Umbraco.Cms.Core.Configuration.Models;
 using Umbraco.Cms.Core.Models;
 using Umbraco.Cms.Core.Models.ContentEditing;
 using Umbraco.Cms.Core.Models.Membership;
@@ -14,42 +14,13 @@
 internal sealed class ContentEditingService
     : ContentEditingServiceWithSortingBase<IContent, IContentType, IContentService, IContentTypeService>, IContentEditingService
 {
+    private readonly PropertyEditorCollection _propertyEditorCollection;
     private readonly ITemplateService _templateService;
     private readonly ILogger<ContentEditingService> _logger;
     private readonly IUserService _userService;
     private readonly ILocalizationService _localizationService;
     private readonly ILanguageService _languageService;
-
-    [Obsolete("Use non-obsolete constructor. This will be removed in Umbraco 16.")]
-    public ContentEditingService(
-        IContentService contentService,
-        IContentTypeService contentTypeService,
-        PropertyEditorCollection propertyEditorCollection,
-        IDataTypeService dataTypeService,
-        ITemplateService templateService,
-        ILogger<ContentEditingService> logger,
-        ICoreScopeProvider scopeProvider,
-        IUserIdKeyResolver userIdKeyResolver,
-        ITreeEntitySortingService treeEntitySortingService,
-        IContentValidationService contentValidationService)
-        : this(
-            contentService,
-            contentTypeService,
-            propertyEditorCollection,
-            dataTypeService,
-            templateService,
-            logger,
-            scopeProvider,
-            userIdKeyResolver,
-            treeEntitySortingService,
-            contentValidationService,
-            StaticServiceProvider.Instance.GetRequiredService<IUserService>(),
-            StaticServiceProvider.Instance.GetRequiredService<ILocalizationService>(),
-            StaticServiceProvider.Instance.GetRequiredService<ILanguageService>()
-            )
-    {
-
-    }
+    private readonly ContentSettings _contentSettings;
 
     public ContentEditingService(
         IContentService contentService,
@@ -64,14 +35,17 @@
         IContentValidationService contentValidationService,
         IUserService userService,
         ILocalizationService localizationService,
-        ILanguageService languageService)
+        ILanguageService languageService,
+        IOptions<ContentSettings> contentSettings)
         : base(contentService, contentTypeService, propertyEditorCollection, dataTypeService, logger, scopeProvider, userIdKeyResolver, contentValidationService, treeEntitySortingService)
     {
+        _propertyEditorCollection = propertyEditorCollection;
         _templateService = templateService;
         _logger = logger;
         _userService = userService;
         _localizationService = localizationService;
         _languageService = languageService;
+        _contentSettings = contentSettings.Value;
     }
 
     public async Task<IContent?> GetAsync(Guid key)
@@ -154,28 +128,53 @@
 
         var allowedCultures = (await _languageService.GetIsoCodesByIdsAsync(allowedLanguageIds)).ToHashSet();
 
+        ILanguage? defaultLanguage = await _languageService.GetDefaultLanguageAsync();
+
         foreach (var culture in contentWithPotentialUnallowedChanges.EditedCultures ?? contentWithPotentialUnallowedChanges.PublishedCultures)
         {
             if (allowedCultures.Contains(culture))
             {
                 continue;
             }
 
-
             // else override the updates values with the original values.
             foreach (IProperty property in contentWithPotentialUnallowedChanges.Properties)
             {
-                if (property.PropertyType.VariesByCulture() is false)
+                // if the property varies by culture, simply overwrite the edited property value with the current property value
+                if (property.PropertyType.VariesByCulture())
                 {
+                    var currentValue = existingContent?.Properties.First(x => x.Alias == property.Alias).GetValue(culture, null, false);
+                    property.SetValue(currentValue, culture, null);
                     continue;
                 }
 
-                var value = existingContent?.Properties.First(x=>x.Alias == property.Alias).GetValue(culture, null, false);
-                property.SetValue(value, culture, null);
+                // if the property does not vary by culture and the data editor supports variance within invariant property values,
+                // we need perform a merge between the edited property value and the current property value
+                if (_propertyEditorCollection.TryGet(property.PropertyType.PropertyEditorAlias, out IDataEditor? dataEditor) && dataEditor.CanMergePartialPropertyValues(property.PropertyType))
+                {
+                    var currentValue = existingContent?.Properties.First(x => x.Alias == property.Alias).GetValue(null, null, false);
+                    var editedValue = contentWithPotentialUnallowedChanges.Properties.First(x => x.Alias == property.Alias).GetValue(null, null, false);
+                    var mergedValue = dataEditor.MergePartialPropertyValueForCulture(currentValue, editedValue, culture);
+
+                    // If we are not allowed to edit invariant properties, overwrite the edited property value with the current property value.
+                    if (_contentSettings.AllowEditInvariantFromNonDefault is false && culture == defaultLanguage?.IsoCode)
+                    {
+                        mergedValue = dataEditor.MergePartialPropertyValueForCulture(currentValue, mergedValue, null);
+                    }
+
+                    property.SetValue(mergedValue, null, null);
+                }
+
+                // If property does not support merging, we still need to overwrite if we are not allowed to edit invariant properties.
+                else if (_contentSettings.AllowEditInvariantFromNonDefault is false && culture == defaultLanguage?.IsoCode)
+                {
+                    var currentValue = existingContent?.Properties.First(x => x.Alias == property.Alias).GetValue(null, null, false);
+                    property.SetValue(currentValue, null, null);
+                }
             }
         }
 
-       return contentWithPotentialUnallowedChanges;
+        return contentWithPotentialUnallowedChanges;
     }
 
     public async Task<Attempt<ContentUpdateResult, ContentEditingOperationStatus>> UpdateAsync(Guid key, ContentUpdateModel updateModel, Guid userKey)

tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/PropertyEditors/BlockEditorElementVariationTestBase.cs

@@ -37,6 +37,8 @@ public abstract class BlockEditorElementVariationTestBase : UmbracoIntegrationTe
 
     protected PropertyEditorCollection PropertyEditorCollection => GetRequiredService<PropertyEditorCollection>();
 
+    protected IContentEditingService ContentEditingService => GetRequiredService<IContentEditingService>();
+
     private IUmbracoContextAccessor UmbracoContextAccessor => GetRequiredService<IUmbracoContextAccessor>();
 
     private IUmbracoContextFactory UmbracoContextFactory => GetRequiredService<IUmbracoContextFactory>();