Property editors: Add configuration and validation of allowed types for element picker, document picker, media picker

src/Umbraco.Core/EmbeddedResources/Lang/en.xml

@@ -402,6 +402,7 @@
     <key alias="invalidMediaType">The chosen media type is invalid.</key>
     <key alias="invalidContentType">The chosen content is of invalid type.</key>
     <key alias="missingContent">The chosen content does not exist.</key>
+    <key alias="missingMedia">The chosen media does not exist.</key>
     <key alias="multipleMediaNotAllowed">Multiple selected media is not allowed.</key>
     <key alias="notOneOfOptions">The value '%0%' is not one of the available options.</key>
     <key alias="multipleNotOneOfOptions">The values '%0%' are not found in the the available options.</key>

src/Umbraco.Core/PropertyEditors/AllowedContentTypeKeysParser.cs

@@ -0,0 +1,34 @@
+using Umbraco.Extensions;
+
+namespace Umbraco.Cms.Core.PropertyEditors;
+
+/// <summary>
+/// Parses the comma-separated content type keys stored in a picker's "allowed content types" configuration value
+/// (e.g. <see cref="ContentPickerConfiguration.AllowedContentTypeIds"/> or <see cref="ElementPickerConfiguration.AllowedContentTypeIds"/>).
+/// </summary>
+internal static class AllowedContentTypeKeysParser
+{
+    /// <summary>
+    /// Parses the configured value into the set of allowed content type keys.
+    /// </summary>
+    /// <param name="configValue">The comma-separated configuration value. Non-GUID entries are ignored.</param>
+    /// <returns>The set of allowed content type keys, or an empty set when nothing is configured.</returns>
+    public static HashSet<Guid> Parse(string? configValue)
+    {
+        if (configValue.IsNullOrWhiteSpace())
+        {
+            return [];
+        }
+
+        var result = new HashSet<Guid>();
+        foreach (var entry in configValue.Split(Constants.CharArrays.Comma, StringSplitOptions.RemoveEmptyEntries))
+        {
+            if (Guid.TryParse(entry, out Guid guid))
+            {
+                result.Add(guid);
+            }
+        }
+
+        return result;
+    }
+}

src/Umbraco.Core/PropertyEditors/ContentPickerConfiguration.cs

@@ -8,4 +8,10 @@ public class ContentPickerConfiguration : IIgnoreUserStartNodesConfig
     /// <inheritdoc />
     [ConfigurationField(Constants.DataTypes.ReservedPreValueKeys.IgnoreUserStartNodes)]
     public bool IgnoreUserStartNodes { get; set; }
+
+    /// <summary>
+    /// Gets or sets the content type filter for allowed selections.
+    /// </summary>
+    [ConfigurationField("allowedContentTypes")]
+    public string? AllowedContentTypeIds { get; set; }
 }

src/Umbraco.Core/PropertyEditors/ContentPickerPropertyEditor.cs

@@ -1,12 +1,16 @@
 // Copyright (c) Umbraco.
 // See LICENSE for more details.
 
+using System.ComponentModel.DataAnnotations;
 using System.Text.Json.Nodes;
 using Microsoft.Extensions.DependencyInjection;
 using Umbraco.Cms.Core.DependencyInjection;
 using Umbraco.Cms.Core.IO;
 using Umbraco.Cms.Core.Models;
 using Umbraco.Cms.Core.Models.Editors;
+using Umbraco.Cms.Core.Models.Validation;
+using Umbraco.Cms.Core.PropertyEditors.Validation;
+using Umbraco.Cms.Core.Scoping;
 using Umbraco.Cms.Core.Serialization;
 using Umbraco.Cms.Core.Services;
 using Umbraco.Cms.Core.Strings;
@@ -70,13 +74,21 @@
         /// <param name="jsonSerializer">The JSON serializer.</param>
         /// <param name="ioHelper">The IO helper.</param>
         /// <param name="attribute">The data editor attribute.</param>
+        /// <param name="coreScopeProvider">The core scope provider.</param>
+        /// <param name="contentService">The content service.</param>
+        /// <param name="localizedTextService">The localized text service.</param>
         public ContentPickerPropertyValueEditor(
             IShortStringHelper shortStringHelper,
             IJsonSerializer jsonSerializer,
             IIOHelper ioHelper,
-            DataEditorAttribute attribute)
+            DataEditorAttribute attribute,
+            ICoreScopeProvider coreScopeProvider,
+            IContentService contentService,
+            ILocalizedTextService localizedTextService)
             : base(shortStringHelper, jsonSerializer, ioHelper, attribute)
         {
+            Validators.Add(new TypedValidatorRunner<string, ContentPickerConfiguration>(
+                new AllowedTypeValidator(localizedTextService, contentService, coreScopeProvider)));
         }
 
         /// <inheritdoc />
@@ -134,4 +146,61 @@
             return guidUdi.Guid;
         }
     }
+
+    /// <summary>
+    ///    Validates that the selected content matches the allowed content types configured for the property editor.
+    /// </summary>
+    /// <param name="localizedTextService">The localized text service.</param>
+    /// <param name="contentService">The content service.</param>
+    /// <param name="coreScopeProvider">The core scope provider.</param>
+    internal sealed class AllowedTypeValidator(ILocalizedTextService localizedTextService, IContentService contentService, ICoreScopeProvider coreScopeProvider)
+        : ITypedValidator<string, ContentPickerConfiguration>
+    {
+        /// <inheritdoc/>
+        public IEnumerable<ValidationResult> Validate(
+            string? value,
+            ContentPickerConfiguration? configuration,
+            string? valueType,
+            PropertyValidationContext validationContext)
+        {
+            if (string.IsNullOrEmpty(value) ||
+                configuration is null ||
+                Guid.TryParse(value, out Guid id) is false)
+            {
+                return [];
+            }
+
+            HashSet<Guid> allowedContentTypeKeys = AllowedContentTypeKeysParser.Parse(configuration.AllowedContentTypeIds);
+
+            // No filter configured — all content types are allowed.
+            if (allowedContentTypeKeys.Count == 0)
+            {
+                return [];
+            }
+
+            using ICoreScope scope = coreScopeProvider.CreateCoreScope();
+            Guid? key = contentService.GetById(id)?.ContentType?.Key;
+            scope.Complete();
+
+            if (key is null)
+            {
+                return [new ValidationResult(
+                            localizedTextService.Localize(
+                                "validation",
+                                "missingContent"),
+                            ["value"])];
+            }
+
+            if (allowedContentTypeKeys.Contains(key.Value) is false)
+            {
+                return [new ValidationResult(
+                            localizedTextService.Localize(
+                                "validation",
+                                "invalidObjectType"),
+                            ["value"])];
+            }
+
+            return [];
+        }
+    }
 }

src/Umbraco.Core/PropertyEditors/ElementPickerConfiguration.cs

@@ -8,4 +8,32 @@ public class ElementPickerConfiguration : IIgnoreUserStartNodesConfig
     /// <inheritdoc />
     [ConfigurationField(Constants.DataTypes.ReservedPreValueKeys.IgnoreUserStartNodes)]
     public bool IgnoreUserStartNodes { get; set; }
+
+    /// <summary>
+    /// Gets or sets the validation limits for the number of elements allowed.
+    /// </summary>
+    [ConfigurationField("validationLimit")]
+    public NumberRange? ValidationLimit { get; set; }
+
+    /// <summary>
+    /// Gets or sets the content type filter for allowed selections.
+    /// </summary>
+    [ConfigurationField("allowedContentTypes")]
+    public string? AllowedContentTypeIds { get; set; }
+
+    /// <summary>
+    /// Represents a numeric range with optional minimum and maximum values.
+    /// </summary>
+    public class NumberRange
+    {
+        /// <summary>
+        /// Gets or sets the minimum value of the range.
+        /// </summary>
+        public int? Min { get; set; }
+
+        /// <summary>
+        /// Gets or sets the maximum value of the range.
+        /// </summary>
+        public int? Max { get; set; }
+    }
 }