Merge branch 'v15/dev' into contrib

Author: nielslyngsoe

src/Umbraco.Cms.Api.Management/Controllers/Tree/UserStartNodeTreeControllerBase.cs

@@ -42,11 +42,21 @@ protected override IEntitySlim[] GetPagedRootEntities(int skip, int take, out lo
 
     protected override IEntitySlim[] GetPagedChildEntities(Guid parentKey, int skip, int take, out long totalItems)
     {
-        IEntitySlim[] children = base.GetPagedChildEntities(parentKey, skip, take, out totalItems);
-        return UserHasRootAccess() || IgnoreUserStartNodes()
-            ? children
-            // Keeping the correct totalItems amount from GetPagedChildEntities
-            : CalculateAccessMap(() => _userStartNodeEntitiesService.ChildUserAccessEntities(children, UserStartNodePaths), out _);
+        if (UserHasRootAccess() || IgnoreUserStartNodes())
+        {
+            return base.GetPagedChildEntities(parentKey, skip, take, out totalItems);
+        }
+
+        IEnumerable<UserAccessEntity> userAccessEntities = _userStartNodeEntitiesService.ChildUserAccessEntities(
+            ItemObjectType,
+            UserStartNodePaths,
+            parentKey,
+            skip,
+            take,
+            ItemOrdering,
+            out totalItems);
+
+        return CalculateAccessMap(() => userAccessEntities, out _);
     }
 
     protected override TItem[] MapTreeItemViewModels(Guid? parentKey, IEntitySlim[] entities)

src/Umbraco.Cms.Api.Management/Controllers/User/ConfigurationUserController.cs

@@ -1,15 +1,12 @@
-using Asp.Versioning;
-using Microsoft.AspNetCore.Authorization;
+using Asp.Versioning;
 using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Mvc;
 using Umbraco.Cms.Api.Management.Factories;
 using Umbraco.Cms.Api.Management.ViewModels.User;
-using Umbraco.Cms.Web.Common.Authorization;
 
 namespace Umbraco.Cms.Api.Management.Controllers.User;
 
 [ApiVersion("1.0")]
-[Authorize(Policy = AuthorizationPolicies.RequireAdminAccess)]
 public class ConfigurationUserController : UserControllerBase
 {
     private readonly IUserPresentationFactory _userPresentationFactory;

src/Umbraco.Cms.Api.Management/Services/Entities/IUserStartNodeEntitiesService.cs

@@ -16,9 +16,41 @@ public interface IUserStartNodeEntitiesService
     /// <remarks>
     /// The returned entities may include entities that outside of the user start node scope, but are needed to
     /// for browsing to the actual user start nodes. These entities will be marked as "no access" entities.
+    ///
+    /// This method does not support pagination, because it must load all entities explicitly in order to calculate
+    /// the correct result, given that user start nodes can be descendants of root nodes. Consumers need to apply
+    /// pagination to the result if applicable.
     /// </remarks>
     IEnumerable<UserAccessEntity> RootUserAccessEntities(UmbracoObjectTypes umbracoObjectType, int[] userStartNodeIds);
 
+    /// <summary>
+    /// Calculates the applicable child entities for a given object type for users without root access.
+    /// </summary>
+    /// <param name="umbracoObjectType">The object type.</param>
+    /// <param name="userStartNodePaths">The calculated start node paths for the user.</param>
+    /// <param name="parentKey">The key of the parent.</param>
+    /// <param name="skip">The number of applicable children to skip.</param>
+    /// <param name="take">The number of applicable children to take.</param>
+    /// <param name="ordering">The ordering to apply when fetching and paginating the children.</param>
+    /// <param name="totalItems">The total number of applicable children available.</param>
+    /// <returns>A list of child entities applicable for the user.</returns>
+    /// <remarks>
+    /// The returned entities may include entities that outside of the user start node scope, but are needed to
+    /// for browsing to the actual user start nodes. These entities will be marked as "no access" entities.
+    /// </remarks>
+    IEnumerable<UserAccessEntity> ChildUserAccessEntities(
+        UmbracoObjectTypes umbracoObjectType,
+        string[] userStartNodePaths,
+        Guid parentKey,
+        int skip,
+        int take,
+        Ordering ordering,
+        out long totalItems)
+    {
+        totalItems = 0;
+        return [];
+    }
+
     /// <summary>
     /// Calculates the applicable child entities from a list of candidate child entities for users without root access.
     /// </summary>

src/Umbraco.Cms.Api.Management/Services/Entities/UserStartNodeEntitiesService.cs

@@ -1,17 +1,37 @@
-using Umbraco.Cms.Core;
+using Microsoft.Extensions.DependencyInjection;
+using Umbraco.Cms.Core;
 using Umbraco.Cms.Core.Models;
 using Umbraco.Cms.Core.Models.Entities;
 using Umbraco.Cms.Core.Services;
 using Umbraco.Cms.Api.Management.Models.Entities;
+using Umbraco.Cms.Core.DependencyInjection;
+using Umbraco.Cms.Core.Persistence.Querying;
+using Umbraco.Cms.Core.Scoping;
 using Umbraco.Extensions;
 
 namespace Umbraco.Cms.Api.Management.Services.Entities;
 
 public class UserStartNodeEntitiesService : IUserStartNodeEntitiesService
 {
     private readonly IEntityService _entityService;
+    private readonly ICoreScopeProvider _scopeProvider;
+    private readonly IIdKeyMap _idKeyMap;
 
-    public UserStartNodeEntitiesService(IEntityService entityService) => _entityService = entityService;
+    [Obsolete("Please use the non-obsolete constructor. Scheduled for removal in V17.")]
+    public UserStartNodeEntitiesService(IEntityService entityService)
+        : this(
+            entityService,
+            StaticServiceProvider.Instance.GetRequiredService<ICoreScopeProvider>(),
+            StaticServiceProvider.Instance.GetRequiredService<IIdKeyMap>())
+    {
+    }
+
+    public UserStartNodeEntitiesService(IEntityService entityService, ICoreScopeProvider scopeProvider, IIdKeyMap idKeyMap)
+    {
+        _entityService = entityService;
+        _scopeProvider = scopeProvider;
+        _idKeyMap = idKeyMap;
+    }
 
     /// <inheritdoc />
     public IEnumerable<UserAccessEntity> RootUserAccessEntities(UmbracoObjectTypes umbracoObjectType, int[] userStartNodeIds)
@@ -43,6 +63,54 @@ public IEnumerable<UserAccessEntity> RootUserAccessEntities(UmbracoObjectTypes u
             .ToArray();
     }
 
+    public IEnumerable<UserAccessEntity> ChildUserAccessEntities(UmbracoObjectTypes umbracoObjectType, string[] userStartNodePaths, Guid parentKey, int skip, int take, Ordering ordering, out long totalItems)
+    {
+        Attempt<int> parentIdAttempt = _idKeyMap.GetIdForKey(parentKey, umbracoObjectType);
+        if (parentIdAttempt.Success is false)
+        {
+            totalItems = 0;
+            return [];
+        }
+
+        var parentId = parentIdAttempt.Result;
+        IEntitySlim? parent = _entityService.Get(parentId);
+        if (parent is null)
+        {
+            totalItems = 0;
+            return [];
+        }
+
+        IEntitySlim[] children;
+        if (userStartNodePaths.Any(path => $"{parent.Path},".StartsWith($"{path},")))
+        {
+            // the requested parent is one of the user start nodes (or a descendant of one), all children are by definition allowed
+            children = _entityService.GetPagedChildren(parentKey, umbracoObjectType, skip, take, out totalItems, ordering: ordering).ToArray();
+            return ChildUserAccessEntities(children, userStartNodePaths);
+        }
+
+        // if one or more of the user start nodes are descendants of the requested parent, find the "next child IDs" in those user start node paths
+        // - e.g. given the user start node path "-1,2,3,4,5", if the requested parent ID is 3, the "next child ID" is 4.
+        var userStartNodePathIds = userStartNodePaths.Select(path => path.Split(Constants.CharArrays.Comma).Select(int.Parse).ToArray()).ToArray();
+        var allowedChildIds = userStartNodePathIds
+            .Where(ids => ids.Contains(parentId))
+            // given the previous checks, the parent ID can never be the last in the user start node path, so this is safe
+            .Select(ids => ids[ids.IndexOf(parentId) + 1])
+            .Distinct()
+            .ToArray();
+
+        totalItems = allowedChildIds.Length;
+        if (allowedChildIds.Length == 0)
+        {
+            // the requested parent is outside the scope of any user start nodes
+            return [];
+        }
+
+        // even though we know the IDs of the allowed child entities to fetch, we still use a Query to yield correctly sorted children
+        IQuery<IUmbracoEntity> query = _scopeProvider.CreateQuery<IUmbracoEntity>().Where(x => allowedChildIds.Contains(x.Id));
+        children = _entityService.GetPagedChildren(parentKey, umbracoObjectType, skip, take, out totalItems, query, ordering).ToArray();
+        return ChildUserAccessEntities(children, userStartNodePaths);
+    }
+
     /// <inheritdoc />
     public IEnumerable<UserAccessEntity> ChildUserAccessEntities(IEnumerable<IEntitySlim> candidateChildren, string[] userStartNodePaths)
         // child entities for users without root access should include:

src/Umbraco.Core/Models/RelationDirectionFilter.cs

@@ -0,0 +1,12 @@
+namespace Umbraco.Cms.Core.Models;
+
+/// <summary>
+/// Definition of relation directions used as a filter when requesting if a given item has relations.
+/// </summary>
+[Flags]
+public enum RelationDirectionFilter
+{
+    Parent = 1,
+    Child = 2,
+    Any = Parent | Child
+}

src/Umbraco.Core/Services/ContentEditingServiceBase.cs

@@ -1,4 +1,4 @@
-using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
 using Umbraco.Cms.Core.Configuration.Models;
 using Umbraco.Cms.Core.Models;
@@ -198,7 +198,7 @@ private async Task<Attempt<ContentValidationResult, ContentEditingOperationStatu
             return await Task.FromResult(Attempt.FailWithStatus<TContent?, ContentEditingOperationStatus>(status, content));
         }
 
-        if (disabledWhenReferenced && _relationService.IsRelated(content.Id))
+        if (disabledWhenReferenced && _relationService.IsRelated(content.Id, RelationDirectionFilter.Child))
         {
             return Attempt.FailWithStatus<TContent?, ContentEditingOperationStatus>(referenceFailStatus, content);
         }

src/Umbraco.Core/Services/ContentPublishingService.cs

@@ -311,7 +311,7 @@ public async Task<Attempt<ContentPublishingOperationStatus>> UnpublishAsync(Guid
             return Attempt.Fail(ContentPublishingOperationStatus.ContentNotFound);
         }
 
-        if (_contentSettings.DisableUnpublishWhenReferenced && _relationService.IsRelated(content.Id))
+        if (_contentSettings.DisableUnpublishWhenReferenced && _relationService.IsRelated(content.Id, RelationDirectionFilter.Child))
         {
             scope.Complete();
             return Attempt<ContentPublishingOperationStatus>.Fail(ContentPublishingOperationStatus.CannotUnpublishWhenReferenced);

src/Umbraco.Core/Services/ContentService.cs

@@ -2767,7 +2767,7 @@ public OperationResult EmptyRecycleBin(int userId = Constants.Security.SuperUser
             {
                 foreach (IContent content in contents)
                 {
-                    if (_contentSettings.DisableDeleteWhenReferenced && _relationService.IsRelated(content.Id))
+                    if (_contentSettings.DisableDeleteWhenReferenced && _relationService.IsRelated(content.Id, RelationDirectionFilter.Child))
                     {
                         continue;
                     }

src/Umbraco.Core/Services/IRelationService.cs

@@ -297,8 +297,20 @@ public interface IRelationService : IService
     /// </summary>
     /// <param name="id">Id of an object to check relations for</param>
     /// <returns>Returns <c>True</c> if any relations exists with the given Id, otherwise <c>False</c></returns>
+    [Obsolete("Please use the overload taking a RelationDirectionFilter parameter. Scheduled for removal in Umbraco 17.")]
     bool IsRelated(int id);
 
+    /// <summary>
+    ///     Checks whether any relations exists for the passed in Id and direction.
+    /// </summary>
+    /// <param name="id">Id of an object to check relations for</param>
+    /// <param name="directionFilter">Indicates whether to check for relations as parent, child or in either direction.</param>
+    /// <returns>Returns <c>True</c> if any relations exists with the given Id, otherwise <c>False</c></returns>
+    bool IsRelated(int id, RelationDirectionFilter directionFilter)
+#pragma warning disable CS0618 // Type or member is obsolete
+        => IsRelated(id);
+#pragma warning restore CS0618 // Type or member is obsolete
+
     /// <summary>
     ///     Checks whether two items are related
     /// </summary>