Add support for file upload property editor within the block list and grid

src/Umbraco.Infrastructure/DependencyInjection/UmbracoBuilder.CoreServices.cs

@@ -52,6 +52,7 @@
 using Umbraco.Cms.Infrastructure.Migrations.Install;
 using Umbraco.Cms.Infrastructure.Persistence;
 using Umbraco.Cms.Infrastructure.Persistence.Mappers;
+using Umbraco.Cms.Infrastructure.PropertyEditors.NotificationHandlers;
 using Umbraco.Cms.Infrastructure.Routing;
 using Umbraco.Cms.Infrastructure.Runtime;
 using Umbraco.Cms.Infrastructure.Runtime.RuntimeModeValidators;
@@ -352,11 +353,11 @@ public static IUmbracoBuilder AddCoreNotifications(this IUmbracoBuilder builder)
             .AddNotificationHandler<ContentSavingNotification, BlockGridPropertyNotificationHandler>()
             .AddNotificationHandler<ContentCopyingNotification, BlockGridPropertyNotificationHandler>()
             .AddNotificationHandler<ContentScaffoldedNotification, BlockGridPropertyNotificationHandler>()
-            .AddNotificationHandler<ContentCopiedNotification, FileUploadPropertyEditor>()
-            .AddNotificationHandler<ContentDeletedNotification, FileUploadPropertyEditor>()
-            .AddNotificationHandler<MediaDeletedNotification, FileUploadPropertyEditor>()
-            .AddNotificationHandler<MediaSavingNotification, FileUploadPropertyEditor>()
-            .AddNotificationHandler<MemberDeletedNotification, FileUploadPropertyEditor>()
+            .AddNotificationHandler<ContentCopiedNotification, FileUploadContentCopiedNotificationHandler>()
+            .AddNotificationHandler<ContentDeletedNotification, FileUploadContentDeletedNotificationHandler>()
+            .AddNotificationHandler<MediaDeletedNotification, FileUploadMediaDeletedNotificationHandler>()
+            .AddNotificationHandler<MediaSavingNotification, FileUploadMediaSavingNotificationHandler>()
+            .AddNotificationHandler<MemberDeletedNotification, FileUploadMemberDeletedNotificationHandler>()
             .AddNotificationHandler<ContentCopiedNotification, ImageCropperPropertyEditor>()
             .AddNotificationHandler<ContentDeletedNotification, ImageCropperPropertyEditor>()
             .AddNotificationHandler<MediaDeletedNotification, ImageCropperPropertyEditor>()

src/Umbraco.Infrastructure/Extensions/RichTextEditorValueExtensions.cs

@@ -0,0 +1,38 @@
+using Umbraco.Cms.Core;
+using Umbraco.Cms.Core.Cache.PropertyEditors;
+using Umbraco.Cms.Core.Models;
+using Umbraco.Cms.Core.Models.Blocks;
+
+namespace Umbraco.Cms.Infrastructure.Extensions;
+
+/// <summary>
+/// Defines extensions on <see cref="RichTextEditorValue"/>.
+/// </summary>
+internal static class RichTextEditorValueExtensions
+{
+    /// <summary>
+    /// Ensures that the property type property is populated on all blocks.
+    /// </summary>
+    /// <param name="richTextEditorValue">The <see cref="RichTextEditorValue"/> providing the blocks.</param>
+    /// <param name="elementTypeCache">Cache for element types.</param>
+    public static void EnsurePropertyTypePopulatedOnBlocks(this RichTextEditorValue richTextEditorValue, IBlockEditorElementTypeCache elementTypeCache)
+    {
+        Guid[] elementTypeKeys = (richTextEditorValue.Blocks?.ContentData ?? [])
+            .Select(x => x.ContentTypeKey)
+            .Union((richTextEditorValue.Blocks?.SettingsData ?? [])
+                .Select(x => x.ContentTypeKey))
+            .Distinct()
+            .ToArray();
+
+        IEnumerable<IContentType> elementTypes = elementTypeCache.GetMany(elementTypeKeys);
+
+        foreach (BlockItemData dataItem in (richTextEditorValue.Blocks?.ContentData ?? [])
+            .Union(richTextEditorValue.Blocks?.SettingsData ?? []))
+        {
+            foreach (BlockPropertyValue item in dataItem.Values)
+            {
+                item.PropertyType = elementTypes.FirstOrDefault(x => x.Key == dataItem.ContentTypeKey)?.PropertyTypes.FirstOrDefault(pt => pt.Alias == item.Alias);
+            }
+        }
+    }
+}

src/Umbraco.Infrastructure/PropertyEditors/BlockEditorPropertyValueEditor.cs

@@ -1,10 +1,8 @@
 // Copyright (c) Umbraco.
 // See LICENSE for more details.
 
-using Microsoft.Extensions.DependencyInjection;
-using Microsoft.Extensions.Logging;
+using System.Diagnostics.CodeAnalysis;
 using Umbraco.Cms.Core.Cache;
-using Umbraco.Cms.Core.DependencyInjection;
 using Umbraco.Cms.Core.IO;
 using Umbraco.Cms.Core.Models;
 using Umbraco.Cms.Core.Models.Blocks;
@@ -16,10 +14,16 @@
 
 namespace Umbraco.Cms.Core.PropertyEditors;
 
+/// <summary>
+/// Provides an abstract base class for property value editors based on block editors.
+/// </summary>
 public abstract class BlockEditorPropertyValueEditor<TValue, TLayout> : BlockValuePropertyValueEditorBase<TValue, TLayout>
     where TValue : BlockValue<TLayout>, new()
     where TLayout : class, IBlockLayoutItem, new()
 {
+    /// <summary>
+    /// Initializes a new instance of the <see cref="BlockEditorPropertyValueEditor{TValue, TLayout}"/> class.
+    /// </summary>
     protected BlockEditorPropertyValueEditor(
         PropertyEditorCollection propertyEditors,
         DataValueReferenceFactoryCollection dataValueReferenceFactories,
@@ -62,13 +66,7 @@ public override IEnumerable<ITag> GetTags(object? value, object? dataTypeConfigu
         return BlockEditorValues.DeserializeAndClean(rawJson)?.BlockValue;
     }
 
-    /// <summary>
-    ///     Ensure that sub-editor values are translated through their ToEditor methods
-    /// </summary>
-    /// <param name="property"></param>
-    /// <param name="culture"></param>
-    /// <param name="segment"></param>
-    /// <returns></returns>
+    /// <inheritdoc />
     public override object ToEditor(IProperty property, string? culture = null, string? segment = null)
     {
         var val = property.GetValue(culture, segment);
@@ -95,38 +93,48 @@ public override object ToEditor(IProperty property, string? culture = null, stri
         return blockEditorData.BlockValue;
     }
 
-    /// <summary>
-    ///     Ensure that sub-editor values are translated through their FromEditor methods
-    /// </summary>
-    /// <param name="editorValue"></param>
-    /// <param name="currentValue"></param>
-    /// <returns></returns>
+    /// <inheritdoc />
     public override object? FromEditor(ContentPropertyData editorValue, object? currentValue)
     {
-        if (editorValue.Value == null || string.IsNullOrWhiteSpace(editorValue.Value.ToString()))
+        // Note: we can't early return here if editorValue is null or empty, because these is the following case:
+        // - current value not null (which means doc has at least one element in block list)
+        // - editor value (new value) is null (which means doc has no elements in block list)
+        // If we check editor value for null value and return before MapBlockValueFromEditor, then we will not trigger updates for properties.
+        // For most of the properties this is fine, but for properties which contain other state it might be critical (e.g. file upload field).
+        // So, we must run MapBlockValueFromEditor even if editorValue is null or string.IsNullOrWhiteSpace(editorValue.Value.ToString()) is true.
+
+        BlockEditorData<TValue, TLayout>? currentBlockEditorData = GetBlockEditorData(currentValue);
+        BlockEditorData<TValue, TLayout>? blockEditorData = GetBlockEditorData(editorValue.Value);
+
+        // We can skip MapBlockValueFromEditor if both editorValue and currentValue values are empty.
+        if (IsBlockEditorDataEmpty(currentBlockEditorData) && IsBlockEditorDataEmpty(blockEditorData))
         {
             return null;
         }
 
-        BlockEditorData<TValue, TLayout>? blockEditorData;
-        try
+        MapBlockValueFromEditor(blockEditorData?.BlockValue, currentBlockEditorData?.BlockValue, editorValue.ContentKey);
+
+        if (IsBlockEditorDataEmpty(blockEditorData))
         {
-            blockEditorData = BlockEditorValues.DeserializeAndClean(editorValue.Value);
+            return null;
         }
-        catch
+
+        return JsonSerializer.Serialize(blockEditorData.BlockValue);
+    }
+
+    private BlockEditorData<TValue, TLayout>? GetBlockEditorData(object? value)
+    {
+        try
         {
-            // if this occurs it means the data is invalid, shouldn't happen but has happened if we change the data format.
-            return string.Empty;
+            return BlockEditorValues.DeserializeAndClean(value);
         }
-
-        if (blockEditorData == null || blockEditorData.BlockValue.ContentData.Count == 0)
+        catch
         {
-            return string.Empty;
+            // If this occurs it means the data is invalid. It shouldn't happen could if we change the data format.
+            return null;
         }
-
-        MapBlockValueFromEditor(blockEditorData.BlockValue);
-
-        // return json
-        return JsonSerializer.Serialize(blockEditorData.BlockValue);
     }
+
+    private static bool IsBlockEditorDataEmpty([NotNullWhen(false)] BlockEditorData<TValue, TLayout>? editorData)
+        => editorData is null || editorData.BlockValue.ContentData.Count == 0;
 }

src/Umbraco.Infrastructure/PropertyEditors/BlockEditorValidatorBase.cs

@@ -1,4 +1,4 @@
-using Umbraco.Cms.Core.Cache.PropertyEditors;
+using Umbraco.Cms.Core.Cache.PropertyEditors;
 using Umbraco.Cms.Core.Models;
 using Umbraco.Cms.Core.Models.Blocks;
 using Umbraco.Cms.Core.Models.Validation;
@@ -88,7 +88,13 @@
 
         foreach (var group in itemDataGroups)
         {
-            var allElementTypes = _elementTypeCache.GetMany(group.Items.Select(x => x.ContentTypeKey).ToArray()).ToDictionary(x => x.Key);
+            Guid[] elementTypeKeys = group.Items.Select(x => x.ContentTypeKey).ToArray();
+            if (elementTypeKeys.Length == 0)
+            {
+                continue;
+            }
+
+            var allElementTypes = _elementTypeCache.GetMany(elementTypeKeys).ToDictionary(x => x.Key);
 
             for (var i = 0; i < group.Items.Length; i++)
             {

src/Umbraco.Infrastructure/PropertyEditors/BlockValuePropertyValueEditorBase.cs

@@ -1,4 +1,4 @@
 using Umbraco.Cms.Core.Cache;
 using Umbraco.Cms.Core.IO;
 using Umbraco.Cms.Core.Models;
 using Umbraco.Cms.Core.Models.Blocks;
@@ -129,10 +129,115 @@
         return result;
     }
 
-    protected void MapBlockValueFromEditor(TValue blockValue)
+    [Obsolete("This method is no longer used within Umbraco. Please use the overload taking all parameters. Scheduled for removal in Umbraco 17.")]
+    protected void MapBlockValueFromEditor(TValue blockValue) => MapBlockValueFromEditor(blockValue, null, Guid.Empty);
+
+    protected void MapBlockValueFromEditor(TValue? editedBlockValue, TValue? currentBlockValue, Guid contentKey)
+    {
+        MapBlockItemDataFromEditor(
+            editedBlockValue?.ContentData ?? [],
+            currentBlockValue?.ContentData ?? [],
+            contentKey);
+
+        MapBlockItemDataFromEditor(
+            editedBlockValue?.SettingsData ?? [],
+            currentBlockValue?.SettingsData ?? [],
+            contentKey);
+    }
+
+    private void MapBlockItemDataFromEditor(List<BlockItemData> editedItems, List<BlockItemData> currentItems, Guid contentKey)
+    {
+        // Create mapping between edited and current block items.
+        IEnumerable<BlockStateMapping<BlockItemData>> itemsMapping = GetBlockStatesMapping(editedItems, currentItems, (mapping, current) => mapping.Edited?.Key == current.Key);
+
+        foreach (BlockStateMapping<BlockItemData> itemMapping in itemsMapping)
+        {
+            // Create mapping between edited and current block item values.
+            IEnumerable<BlockStateMapping<BlockPropertyValue>> valuesMapping = GetBlockStatesMapping(itemMapping.Edited?.Values, itemMapping.Current?.Values, (mapping, current) => mapping.Edited?.Alias == current.Alias);
+
+            foreach (BlockStateMapping<BlockPropertyValue> valueMapping in valuesMapping)
+            {
+                BlockPropertyValue? editedValue = valueMapping.Edited;
+                BlockPropertyValue? currentValue = valueMapping.Current;
+
+                IPropertyType propertyType = editedValue?.PropertyType
+                    ?? currentValue?.PropertyType
+                    ?? throw new ArgumentException("One or more block properties did not have a resolved property type. Block editor values must be resolved before attempting to map them from editor.", nameof(editedItems));
+
+                // Lookup the property editor.
+                IDataEditor? propertyEditor = _propertyEditors[propertyType.PropertyEditorAlias];
+                if (propertyEditor is null)
+                {
+                    continue;
+                }
+
+                // Fetch the property types prevalue.
+                var configuration = _dataTypeConfigurationCache.GetConfiguration(propertyType.DataTypeKey);
+
+                // Create a real content property data object.
+                var propertyData = new ContentPropertyData(editedValue?.Value, configuration)
+                {
+                    ContentKey = contentKey,
+                    PropertyTypeKey = propertyType.Key,
+                };
+
+                // Get the property editor to do it's conversion.
+                IDataValueEditor valueEditor = propertyEditor.GetValueEditor();
+                var newValue = valueEditor.FromEditor(propertyData, currentValue?.Value);
+
+                // Update the raw value since this is what will get serialized out.
+                if (editedValue != null)
+                {
+                    editedValue.Value = newValue;
+                }
+            }
+        }
+    }
+
+    private sealed class BlockStateMapping<T>
     {
-        MapBlockItemDataFromEditor(blockValue.ContentData);
-        MapBlockItemDataFromEditor(blockValue.SettingsData);
+        public T? Edited { get; set; }
+
+        public T? Current { get; set; }
+    }
+
+    private static IEnumerable<BlockStateMapping<T>> GetBlockStatesMapping<T>(IList<T>? editedItems, IList<T>? currentItems, Func<BlockStateMapping<T>, T, bool> condition)
+    {
+        // filling with edited items first
+        List<BlockStateMapping<T>> mapping = editedItems?
+            .Select(editedItem => new BlockStateMapping<T>
+            {
+                Current = default,
+                Edited = editedItem,
+            })
+            .ToList()
+            ?? [];
+
+        if (currentItems is null)
+        {
+            return mapping;
+        }
+
+        // then adding current items
+        foreach (T currentItem in currentItems)
+        {
+            BlockStateMapping<T>? mappingItem = mapping.FirstOrDefault(x => condition(x, currentItem));
+
+            if (mappingItem == null) // if there is no edited item, then adding just current
+            {
+                mapping.Add(new BlockStateMapping<T>
+                {
+                    Current = currentItem,
+                    Edited = default,
+                });
+            }
+            else
+            {
+                mappingItem.Current = currentItem;
+            }
+        }
+
+        return mapping;
     }
 
     protected void MapBlockValueToEditor(IProperty property, TValue blockValue, string? culture, string? segment)
@@ -197,40 +302,6 @@
         }
     }
 
-    private void MapBlockItemDataFromEditor(List<BlockItemData> items)
-    {
-        foreach (BlockItemData item in items)
-        {
-            foreach (BlockPropertyValue blockPropertyValue in item.Values)
-            {
-                IPropertyType? propertyType = blockPropertyValue.PropertyType;
-                if (propertyType is null)
-                {
-                    throw new ArgumentException("One or more block properties did not have a resolved property type. Block editor values must be resolved before attempting to map them from editor.", nameof(items));
-                }
-
-                // Lookup the property editor
-                IDataEditor? propertyEditor = _propertyEditors[propertyType.PropertyEditorAlias];
-                if (propertyEditor is null)
-                {
-                    continue;
-                }
-
-                // Fetch the property types prevalue
-                var configuration = _dataTypeConfigurationCache.GetConfiguration(propertyType.DataTypeKey);
-
-                // Create a fake content property data object
-                var propertyData = new ContentPropertyData(blockPropertyValue.Value, configuration);
-
-                // Get the property editor to do it's conversion
-                var newValue = propertyEditor.GetValueEditor().FromEditor(propertyData, blockPropertyValue.Value);
-
-                // update the raw value since this is what will get serialized out
-                blockPropertyValue.Value = newValue;
-            }
-        }
-    }
-
     /// <summary>
     /// Updates the invariant data in the source with the invariant data in the value if allowed
     /// </summary>