Merge branch 'v14/dev' into contrib

Author: nul800sebastiaan

src/Umbraco.Cms.Api.Management/Controllers/Document/GetAuditLogDocumentController.cs

@@ -39,7 +39,7 @@ public async Task<IActionResult> GetAuditLog(CancellationToken cancellationToken
     {
         AuthorizationResult authorizationResult = await _authorizationService.AuthorizeResourceAsync(
             User,
-            ContentPermissionResource.WithKeys(ActionProtect.ActionLetter, id),
+            ContentPermissionResource.WithKeys(ActionBrowse.ActionLetter, id),
             AuthorizationPolicies.ContentPermissionByResource);
 
         if (!authorizationResult.Succeeded)

src/Umbraco.Cms.Api.Management/Controllers/Document/UpdateDomainsController.cs

@@ -66,6 +66,10 @@ public async Task<IActionResult> Update(
                     .WithDetail("One or more of the specified domain names were conflicting with domain assignments to other content items.")
                     .WithExtension("conflictingDomainNames", _domainPresentationFactory.CreateDomainAssignmentModels(result.Result.ConflictingDomains.EmptyNull()))
                     .Build()),
+                DomainOperationStatus.InvalidDomainName => BadRequest(problemDetailsBuilder
+                    .WithTitle("Invalid domain name detected")
+                    .WithDetail("One or more of the specified domain names were invalid.")
+                    .Build()),
                 _ => StatusCode(StatusCodes.Status500InternalServerError, problemDetailsBuilder
                     .WithTitle("Unknown domain update operation status.")
                     .Build()),

src/Umbraco.Cms.Api.Management/Controllers/DocumentType/DocumentTypeControllerBase.cs

@@ -98,6 +98,18 @@ status is ContentTypeOperationStatus.Success
                     .WithTitle("Name was too long")
                     .WithDetail("Name cannot be more than 255 characters in length.")
                     .Build()),
+                ContentTypeOperationStatus.InvalidElementFlagDocumentHasContent => new BadRequestObjectResult(problemDetailsBuilder
+                    .WithTitle("Invalid IsElement flag")
+                    .WithDetail("Cannot change to element type because content has already been created with this document type.")
+                    .Build()),
+                ContentTypeOperationStatus.InvalidElementFlagElementIsUsedInPropertyEditorConfiguration => new BadRequestObjectResult(problemDetailsBuilder
+                    .WithTitle("Invalid IsElement flag")
+                    .WithDetail("Cannot change to document type because this element type is used in the configuration of a data type.")
+                    .Build()),
+                ContentTypeOperationStatus.InvalidElementFlagComparedToParent => new BadRequestObjectResult(problemDetailsBuilder
+                    .WithTitle("Invalid IsElement flag")
+                    .WithDetail("Can not create a documentType with inheritance composition where the parent and the new type's IsElement flag are different.")
+                    .Build()),
                 _ => new ObjectResult("Unknown content type operation status") { StatusCode = StatusCodes.Status500InternalServerError },
             });
 

src/Umbraco.Cms.Api.Management/OpenApi.json

@@ -45275,4 +45275,4 @@
       }
     }
   }
-}
+}

src/Umbraco.Core/DependencyInjection/UmbracoBuilder.cs

@@ -398,11 +398,14 @@ private void AddCoreServices()
 
             // Segments
             Services.AddUnique<ISegmentService, NoopSegmentService>();
-            
+
             // definition Import/export
             Services.AddUnique<ITemporaryFileToXmlImportService, TemporaryFileToXmlImportService>();
             Services.AddUnique<IContentTypeImportService, ContentTypeImportService>();
             Services.AddUnique<IMediaTypeImportService, MediaTypeImportService>();
+
+            // add validation services
+            Services.AddUnique<IElementSwitchValidator, ElementSwitchValidator>();
         }
     }
 }

src/Umbraco.Core/Extensions/ObjectExtensions.cs

@@ -219,6 +219,24 @@ public static Attempt<T> TryConvertTo<T>(this object? input)
                 }
             }
 
+            if (target == typeof(DateTime) && input is DateTimeOffset dateTimeOffset)
+            {
+                // IMPORTANT: for compatability with various editors, we must discard any Offset information and assume UTC time here
+                return Attempt.Succeed((object?)new DateTime(
+                    new DateOnly(dateTimeOffset.Year, dateTimeOffset.Month, dateTimeOffset.Day),
+                    new TimeOnly(dateTimeOffset.Hour, dateTimeOffset.Minute, dateTimeOffset.Second, dateTimeOffset.Millisecond, dateTimeOffset.Microsecond),
+                    DateTimeKind.Utc));
+            }
+
+            if (target == typeof(DateTimeOffset) && input is DateTime dateTime)
+            {
+                // IMPORTANT: for compatability with various editors, we must discard any DateTimeKind information and assume UTC time here
+                return Attempt.Succeed((object?)new DateTimeOffset(
+                    new DateOnly(dateTime.Year, dateTime.Month, dateTime.Day),
+                    new TimeOnly(dateTime.Hour, dateTime.Minute, dateTime.Second, dateTime.Millisecond, dateTime.Microsecond),
+                    TimeSpan.Zero));
+            }
+
             TypeConverter? inputConverter = GetCachedSourceTypeConverter(inputType, target);
             if (inputConverter != null)
             {

src/Umbraco.Core/Handlers/WarnDocumentTypeElementSwitchNotificationHandler.cs

@@ -0,0 +1,104 @@
+using Umbraco.Cms.Core.Events;
+using Umbraco.Cms.Core.Extensions;
+using Umbraco.Cms.Core.Models;
+using Umbraco.Cms.Core.Notifications;
+using Umbraco.Cms.Core.Services;
+using Umbraco.Cms.Core.Services.ContentTypeEditing;
+
+namespace Umbraco.Cms.Core.Handlers;
+
+public class WarnDocumentTypeElementSwitchNotificationHandler :
+    INotificationAsyncHandler<ContentTypeSavingNotification>,
+    INotificationAsyncHandler<ContentTypeSavedNotification>
+{
+    private const string NotificationStateKey =
+        "Umbraco.Cms.Core.Handlers.WarnDocumentTypeElementSwitchNotificationHandler";
+
+    private readonly IEventMessagesFactory _eventMessagesFactory;
+    private readonly IContentTypeService _contentTypeService;
+    private readonly IElementSwitchValidator _elementSwitchValidator;
+
+    public WarnDocumentTypeElementSwitchNotificationHandler(
+        IEventMessagesFactory eventMessagesFactory,
+        IContentTypeService contentTypeService,
+        IElementSwitchValidator elementSwitchValidator)
+    {
+        _eventMessagesFactory = eventMessagesFactory;
+        _contentTypeService = contentTypeService;
+        _elementSwitchValidator = elementSwitchValidator;
+    }
+
+    // To figure out whether a warning should be generated, we need both the state before and after saving
+    public async Task HandleAsync(ContentTypeSavingNotification notification, CancellationToken cancellationToken)
+    {
+        IEnumerable<Guid> updatedKeys = notification.SavedEntities
+            .Where(e => e.HasIdentity)
+            .Select(e => e.Key);
+
+        IEnumerable<IContentType> persistedItems = _contentTypeService.GetAll(updatedKeys);
+
+        var stateInformation = persistedItems
+            .ToDictionary(
+                contentType => contentType.Key,
+                contentType => new DocumentTypeElementSwitchInformation { WasElement = contentType.IsElement });
+        notification.State[NotificationStateKey] = stateInformation;
+    }
+
+    public async Task HandleAsync(ContentTypeSavedNotification notification, CancellationToken cancellationToken)
+    {
+        if (notification.State[NotificationStateKey] is not Dictionary<Guid, DocumentTypeElementSwitchInformation>
+            stateInformation)
+        {
+            return;
+        }
+
+        EventMessages eventMessages = _eventMessagesFactory.Get();
+
+        foreach (IContentType savedDocumentType in notification.SavedEntities)
+        {
+            if (stateInformation.ContainsKey(savedDocumentType.Key) is false)
+            {
+                continue;
+            }
+
+            DocumentTypeElementSwitchInformation state = stateInformation[savedDocumentType.Key];
+            if (state.WasElement == savedDocumentType.IsElement)
+            {
+                // no change
+                continue;
+            }
+
+            await WarnIfAncestorsAreMisaligned(savedDocumentType, eventMessages);
+            await WarnIfDescendantsAreMisaligned(savedDocumentType, eventMessages);
+        }
+    }
+
+    private async Task WarnIfAncestorsAreMisaligned(IContentType contentType, EventMessages eventMessages)
+    {
+        if (await _elementSwitchValidator.AncestorsAreAlignedAsync(contentType) == false)
+        {
+            // todo update this message when the format has been agreed upon on with the client
+            eventMessages.Add(new EventMessage(
+                "DocumentType saved",
+                "One or more ancestors have a mismatching element flag",
+                EventMessageType.Warning));
+        }
+    }
+
+    private async Task WarnIfDescendantsAreMisaligned(IContentType contentType, EventMessages eventMessages)
+    {
+        if (await _elementSwitchValidator.DescendantsAreAlignedAsync(contentType) == false)
+        {
+            // todo update this message when the format has been agreed upon on with the client
+            eventMessages.Add(new EventMessage(
+                "DocumentType saved",
+                "One or more descendants have a mismatching element flag",
+                EventMessageType.Warning));
+        }
+    }
+
+    private class DocumentTypeElementSwitchInformation
+    {
+        public bool WasElement { get; set; }
+    }
+}

src/Umbraco.Core/Models/IDataValueEditor.cs

@@ -27,7 +27,6 @@ public interface IDataValueEditor
     /// </summary>
     bool SupportsReadOnly => false;
 
-
     /// <summary>
     ///     Gets the validators to use to validate the edited value.
     /// </summary>
@@ -75,4 +74,6 @@ public interface IDataValueEditor
     XNode ConvertDbToXml(IPropertyType propertyType, object value);
 
     string ConvertDbToString(IPropertyType propertyType, object? value);
+
+    IEnumerable<Guid> ConfiguredElementTypeKeys() => Enumerable.Empty<Guid>();
 }

src/Umbraco.Core/PropertyEditors/BlockListConfiguration.cs

@@ -9,7 +9,7 @@ namespace Umbraco.Cms.Core.PropertyEditors;
 public class BlockListConfiguration
 {
     [ConfigurationField("blocks")]
-    public BlockConfiguration[] Blocks { get; set; } = null!;
+    public BlockConfiguration[] Blocks { get; set; } = Array.Empty<BlockConfiguration>();
 
     [ConfigurationField("validationLimit")]
     public NumberRange ValidationLimit { get; set; } = new();

src/Umbraco.Core/PropertyEditors/DataEditor.cs

@@ -75,6 +75,10 @@ public DataEditor(IDataValueEditorFactory dataValueEditorFactory)
     [DataMember(Name = "supportsReadOnly", IsRequired = true)]
     public bool SupportsReadOnly { get; set; }
 
+    // Adding a virtual method that wraps the default implementation allows derived classes
+    // to override the default implementation without having to explicitly inherit the interface.
+    public virtual bool SupportsConfigurableElements => false;
+
     /// <inheritdoc />
     [IgnoreDataMember]
     public bool IsDeprecated { get; }