Global Elements - take one

src/Umbraco.Cms.Api.Management/Controllers/DataType/DataTypeControllerBase.cs

@@ -11,7 +11,7 @@ namespace Umbraco.Cms.Api.Management.Controllers.DataType;
 
 [VersionedApiBackOfficeRoute(Constants.UdiEntityType.DataType)]
 [ApiExplorerSettings(GroupName = "Data Type")]
-[Authorize(Policy = AuthorizationPolicies.TreeAccessDocumentsOrMediaOrMembersOrContentTypes)]
+[Authorize(Policy = AuthorizationPolicies.TreeAccessDocumentsOrElementsOrMediaOrMembersOrContentTypes)]
 public abstract class DataTypeControllerBase : ManagementApiControllerBase
 {
     protected IActionResult DataTypeOperationStatusResult(DataTypeOperationStatus status) =>

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

@@ -30,6 +30,7 @@ protected IActionResult DocumentEditingOperationStatusResult<TContentModelBase>(
         where TContentModelBase : ContentModelBase<DocumentValueModel, DocumentVariantRequestModel>
         => ContentEditingOperationStatusResult<TContentModelBase, DocumentValueModel, DocumentVariantRequestModel>(status, requestModel, validationResult);
 
+    // TODO ELEMENTS: move this to ContentControllerBase
     protected IActionResult DocumentPublishingOperationStatusResult(
         ContentPublishingOperationStatus status,
         IEnumerable<string>? invalidPropertyAliases = null,

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

@@ -11,7 +11,7 @@ namespace Umbraco.Cms.Api.Management.Controllers.DocumentType;
 
 [VersionedApiBackOfficeRoute(Constants.UdiEntityType.DocumentType)]
 [ApiExplorerSettings(GroupName = "Document Type")]
-[Authorize(Policy = AuthorizationPolicies.TreeAccessDocumentsOrDocumentTypes)]
+[Authorize(Policy = AuthorizationPolicies.TreeAccessDocumentsOrElementsOrDocumentTypes)]
 public abstract class DocumentTypeControllerBase : ManagementApiControllerBase
 {
     protected IActionResult OperationStatusResult(ContentTypeOperationStatus status)

src/Umbraco.Cms.Api.Management/Controllers/DocumentVersion/AllDocumentVersionController.cs

@@ -41,14 +41,17 @@ public async Task<IActionResult> All(
         Attempt<PagedModel<ContentVersionMeta>?, ContentVersionOperationStatus> attempt =
             await _contentVersionService.GetPagedContentVersionsAsync(documentId, culture, skip, take);
 
+        if (attempt.Success is false)
+        {
+            return MapFailure(attempt.Status);
+        }
+
         var pagedViewModel = new PagedViewModel<DocumentVersionItemResponseModel>
         {
             Total = attempt.Result!.Total,
             Items = await _documentVersionPresentationFactory.CreateMultipleAsync(attempt.Result!.Items),
         };
 
-        return attempt.Success
-            ? Ok(pagedViewModel)
-            : MapFailure(attempt.Status);
+        return Ok(pagedViewModel);
     }
 }

src/Umbraco.Cms.Api.Management/Controllers/DocumentVersion/DocumentVersionControllerBase.cs

@@ -13,25 +13,26 @@ namespace Umbraco.Cms.Api.Management.Controllers.DocumentVersion;
 [Authorize(Policy = AuthorizationPolicies.TreeAccessDocuments)]
 public abstract class DocumentVersionControllerBase : ManagementApiControllerBase
 {
-    protected IActionResult MapFailure(ContentVersionOperationStatus status)
+    internal static IActionResult MapFailure(ContentVersionOperationStatus status)
         => OperationStatusResult(status, problemDetailsBuilder => status switch
         {
-            ContentVersionOperationStatus.NotFound => NotFound(problemDetailsBuilder
+            ContentVersionOperationStatus.NotFound => new NotFoundObjectResult(problemDetailsBuilder
                 .WithTitle("The requested version could not be found")
                 .Build()),
-            ContentVersionOperationStatus.ContentNotFound => NotFound(problemDetailsBuilder
+            ContentVersionOperationStatus.ContentNotFound => new NotFoundObjectResult(problemDetailsBuilder
                 .WithTitle("The requested document could not be found")
                 .Build()),
             ContentVersionOperationStatus.InvalidSkipTake => SkipTakeToPagingProblem(),
-            ContentVersionOperationStatus.RollBackFailed => BadRequest(problemDetailsBuilder
+            ContentVersionOperationStatus.RollBackFailed => new BadRequestObjectResult(problemDetailsBuilder
                 .WithTitle("Rollback failed")
-                .WithDetail("An unspecified error occurred while rolling back the requested version. Please check the logs for additional information.")),
-            ContentVersionOperationStatus.RollBackCanceled => BadRequest(problemDetailsBuilder
+                .WithDetail(
+                    "An unspecified error occurred while rolling back the requested version. Please check the logs for additional information.")),
+            ContentVersionOperationStatus.RollBackCanceled => new BadRequestObjectResult(problemDetailsBuilder
                 .WithTitle("Request cancelled by notification")
                 .WithDetail("The request to roll back was cancelled by a notification handler.")
                 .Build()),
-            _ => StatusCode(StatusCodes.Status500InternalServerError, problemDetailsBuilder
+            _ => new ObjectResult(problemDetailsBuilder
                 .WithTitle("Unknown content version operation status.")
-                .Build()),
+                .Build()) { StatusCode = StatusCodes.Status500InternalServerError },
         });
 }

src/Umbraco.Cms.Api.Management/Controllers/Element/ByKeyElementController.cs

@@ -0,0 +1,61 @@
+using Asp.Versioning;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Umbraco.Cms.Api.Management.Factories;
+using Umbraco.Cms.Api.Management.ViewModels.Element;
+using Umbraco.Cms.Core.Actions;
+using Umbraco.Cms.Core.Models;
+using Umbraco.Cms.Core.Security.Authorization;
+using Umbraco.Cms.Core.Services;
+using Umbraco.Cms.Core.Services.OperationStatus;
+using Umbraco.Cms.Web.Common.Authorization;
+using Umbraco.Extensions;
+
+namespace Umbraco.Cms.Api.Management.Controllers.Element;
+
+[ApiVersion("1.0")]
+public class ByKeyElementController : ElementControllerBase
+{
+    private readonly IAuthorizationService _authorizationService;
+    private readonly IElementService _elementService;
+    private readonly IElementPresentationFactory _elementPresentationFactory;
+
+    public ByKeyElementController(
+        IAuthorizationService authorizationService,
+        IElementService elementService,
+        IElementPresentationFactory elementPresentationFactory)
+    {
+        _authorizationService = authorizationService;
+        _elementService = elementService;
+        _elementPresentationFactory = elementPresentationFactory;
+    }
+
+    [HttpGet("{id:guid}")]
+    [MapToApiVersion("1.0")]
+    [ProducesResponseType(typeof(ElementResponseModel), StatusCodes.Status200OK)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status404NotFound)]
+    public async Task<IActionResult> ByKey(CancellationToken cancellationToken, Guid id)
+    {
+        AuthorizationResult authorizationResult = await _authorizationService.AuthorizeResourceAsync(
+            User,
+            ElementPermissionResource.WithKeys(ActionElementBrowse.ActionLetter, id),
+            AuthorizationPolicies.ElementPermissionByResource);
+
+        if (!authorizationResult.Succeeded)
+        {
+            return Forbidden();
+        }
+
+        IElement? element = _elementService.GetById(id);
+        if (element is null)
+        {
+            return ContentEditingOperationStatusResult(ContentEditingOperationStatus.NotFound);
+        }
+
+        ContentScheduleCollection contentScheduleCollection = _elementService.GetContentScheduleByContentId(id);
+
+        ElementResponseModel model = _elementPresentationFactory.CreateResponseModel(element, contentScheduleCollection);
+        return Ok(model);
+    }
+}

src/Umbraco.Cms.Api.Management/Controllers/Element/ConfigurationElementController.cs

@@ -0,0 +1,25 @@
+using Asp.Versioning;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Umbraco.Cms.Api.Management.Factories;
+using Umbraco.Cms.Api.Management.ViewModels.Element;
+
+namespace Umbraco.Cms.Api.Management.Controllers.Element;
+
+[ApiVersion("1.0")]
+public class ConfigurationElementController : ElementControllerBase
+{
+    private readonly IConfigurationPresentationFactory _configurationPresentationFactory;
+
+    public ConfigurationElementController(IConfigurationPresentationFactory configurationPresentationFactory)
+        => _configurationPresentationFactory = configurationPresentationFactory;
+
+    [HttpGet("configuration")]
+    [MapToApiVersion("1.0")]
+    [ProducesResponseType(typeof(ElementConfigurationResponseModel), StatusCodes.Status200OK)]
+    public Task<IActionResult> Configuration(CancellationToken cancellationToken)
+    {
+        ElementConfigurationResponseModel responseModel = _configurationPresentationFactory.CreateElementConfigurationResponseModel();
+        return Task.FromResult<IActionResult>(Ok(responseModel));
+    }
+}

src/Umbraco.Cms.Api.Management/Controllers/Element/CopyElementController.cs

@@ -0,0 +1,72 @@
+using Asp.Versioning;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Umbraco.Cms.Api.Management.ViewModels.Element;
+using Umbraco.Cms.Core;
+using Umbraco.Cms.Core.Actions;
+using Umbraco.Cms.Core.Models;
+using Umbraco.Cms.Core.Security;
+using Umbraco.Cms.Core.Security.Authorization;
+using Umbraco.Cms.Core.Services;
+using Umbraco.Cms.Core.Services.OperationStatus;
+using Umbraco.Cms.Web.Common.Authorization;
+using Umbraco.Extensions;
+
+namespace Umbraco.Cms.Api.Management.Controllers.Element;
+
+[ApiVersion("1.0")]
+public class CopyElementController : ElementControllerBase
+{
+    private readonly IAuthorizationService _authorizationService;
+    private readonly IElementEditingService _elementEditingService;
+    private readonly IBackOfficeSecurityAccessor _backOfficeSecurityAccessor;
+
+    public CopyElementController(
+        IAuthorizationService authorizationService,
+        IElementEditingService elementEditingService,
+        IBackOfficeSecurityAccessor backOfficeSecurityAccessor)
+    {
+        _authorizationService = authorizationService;
+        _elementEditingService = elementEditingService;
+        _backOfficeSecurityAccessor = backOfficeSecurityAccessor;
+    }
+
+    [HttpPost("{id:guid}/copy")]
+    [MapToApiVersion("1.0")]
+    [ProducesResponseType(StatusCodes.Status201Created)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status404NotFound)]
+    public async Task<IActionResult> Copy(CancellationToken cancellationToken, Guid id, CopyElementRequestModel copyElementRequestModel)
+    {
+        // Check Copy permission on source element
+        AuthorizationResult sourceAuthorizationResult = await _authorizationService.AuthorizeResourceAsync(
+            User,
+            ElementPermissionResource.WithKeys(ActionElementCopy.ActionLetter, id),
+            AuthorizationPolicies.ElementPermissionByResource);
+
+        if (!sourceAuthorizationResult.Succeeded)
+        {
+            return Forbidden();
+        }
+
+        // Check Create permission on target (where we're copying to)
+        AuthorizationResult targetAuthorizationResult = await _authorizationService.AuthorizeResourceAsync(
+            User,
+            ElementPermissionResource.WithKeys(ActionElementNew.ActionLetter, copyElementRequestModel.Target?.Id),
+            AuthorizationPolicies.ElementPermissionByResource);
+
+        if (!targetAuthorizationResult.Succeeded)
+        {
+            return Forbidden();
+        }
+
+        Attempt<IElement?, ContentEditingOperationStatus> result = await _elementEditingService.CopyAsync(
+            id,
+            copyElementRequestModel.Target?.Id,
+            CurrentUserKey(_backOfficeSecurityAccessor));
+
+        return result.Success
+            ? CreatedAtId<ByKeyElementController>(controller => nameof(controller.ByKey), result.Result!.Key)
+            : ContentEditingOperationStatusResult(result.Status);
+    }
+}

src/Umbraco.Cms.Api.Management/Controllers/Element/CreateElementController.cs

@@ -0,0 +1,50 @@
+using Asp.Versioning;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Umbraco.Cms.Api.Management.Factories;
+using Umbraco.Cms.Api.Management.ViewModels.Element;
+using Umbraco.Cms.Core;
+using Umbraco.Cms.Core.Models.ContentEditing;
+using Umbraco.Cms.Core.Security;
+using Umbraco.Cms.Core.Services;
+using Umbraco.Cms.Core.Services.OperationStatus;
+
+namespace Umbraco.Cms.Api.Management.Controllers.Element;
+
+[ApiVersion("1.0")]
+public class CreateElementController : CreateElementControllerBase
+{
+    private readonly IElementEditingPresentationFactory _elementEditingPresentationFactory;
+    private readonly IElementEditingService _elementEditingService;
+    private readonly IBackOfficeSecurityAccessor _backOfficeSecurityAccessor;
+
+    public CreateElementController(
+        IAuthorizationService authorizationService,
+        IElementEditingPresentationFactory elementEditingPresentationFactory,
+        IElementEditingService elementEditingService,
+        IBackOfficeSecurityAccessor backOfficeSecurityAccessor)
+        : base(authorizationService)
+    {
+        _elementEditingPresentationFactory = elementEditingPresentationFactory;
+        _elementEditingService = elementEditingService;
+        _backOfficeSecurityAccessor = backOfficeSecurityAccessor;
+    }
+
+    [HttpPost]
+    [MapToApiVersion("1.0")]
+    [ProducesResponseType(StatusCodes.Status201Created)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status400BadRequest)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status404NotFound)]
+    public async Task<IActionResult> Create(CancellationToken cancellationToken, CreateElementRequestModel requestModel)
+        => await HandleRequest(requestModel, async () =>
+        {
+            ElementCreateModel model = _elementEditingPresentationFactory.MapCreateModel(requestModel);
+            Attempt<ElementCreateResult, ContentEditingOperationStatus> result =
+                await _elementEditingService.CreateAsync(model, CurrentUserKey(_backOfficeSecurityAccessor));
+
+            return result.Success
+                ? CreatedAtId<ByKeyElementController>(controller => nameof(controller.ByKey), result.Result.Content!.Key)
+                : ContentEditingOperationStatusResult(result.Status);
+        });
+}

src/Umbraco.Cms.Api.Management/Controllers/Element/CreateElementControllerBase.cs

@@ -0,0 +1,32 @@
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using Umbraco.Cms.Api.Management.ViewModels.Element;
+using Umbraco.Cms.Core.Actions;
+using Umbraco.Cms.Core.Security.Authorization;
+using Umbraco.Cms.Web.Common.Authorization;
+using Umbraco.Extensions;
+
+namespace Umbraco.Cms.Api.Management.Controllers.Element;
+
+public abstract class CreateElementControllerBase : ElementControllerBase
+{
+    private readonly IAuthorizationService _authorizationService;
+
+    protected CreateElementControllerBase(IAuthorizationService authorizationService)
+        => _authorizationService = authorizationService;
+
+    protected async Task<IActionResult> HandleRequest(CreateElementRequestModel requestModel, Func<Task<IActionResult>> authorizedHandler)
+    {
+        AuthorizationResult authorizationResult = await _authorizationService.AuthorizeResourceAsync(
+            User,
+            ElementPermissionResource.WithKeys(ActionElementNew.ActionLetter, requestModel.Parent?.Id),
+            AuthorizationPolicies.ElementPermissionByResource);
+
+        if (authorizationResult.Succeeded is false)
+        {
+            return Forbidden();
+        }
+
+        return await authorizedHandler();
+    }
+}

src/Umbraco.Cms.Api.Management/Controllers/Element/DeleteElementController.cs

@@ -0,0 +1,57 @@
+using Asp.Versioning;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Umbraco.Cms.Core;
+using Umbraco.Cms.Core.Actions;
+using Umbraco.Cms.Core.Models;
+using Umbraco.Cms.Core.Security;
+using Umbraco.Cms.Core.Security.Authorization;
+using Umbraco.Cms.Core.Services;
+using Umbraco.Cms.Core.Services.OperationStatus;
+using Umbraco.Cms.Web.Common.Authorization;
+using Umbraco.Extensions;
+
+namespace Umbraco.Cms.Api.Management.Controllers.Element;
+
+[ApiVersion("1.0")]
+public class DeleteElementController : ElementControllerBase
+{
+    private readonly IAuthorizationService _authorizationService;
+    private readonly IElementEditingService _elementEditingService;
+    private readonly IBackOfficeSecurityAccessor _backOfficeSecurityAccessor;
+
+    public DeleteElementController(
+        IAuthorizationService authorizationService,
+        IElementEditingService elementEditingService,
+        IBackOfficeSecurityAccessor backOfficeSecurityAccessor)
+    {
+        _authorizationService = authorizationService;
+        _elementEditingService = elementEditingService;
+        _backOfficeSecurityAccessor = backOfficeSecurityAccessor;
+    }
+
+    [HttpDelete("{id:guid}")]
+    [MapToApiVersion("1.0")]
+    [ProducesResponseType(StatusCodes.Status200OK)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status400BadRequest)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status404NotFound)]
+    public async Task<IActionResult> Delete(CancellationToken cancellationToken, Guid id)
+    {
+        AuthorizationResult authorizationResult = await _authorizationService.AuthorizeResourceAsync(
+            User,
+            ElementPermissionResource.WithKeys(ActionElementDelete.ActionLetter, id),
+            AuthorizationPolicies.ElementPermissionByResource);
+
+        if (!authorizationResult.Succeeded)
+        {
+            return Forbidden();
+        }
+
+        Attempt<IElement?, ContentEditingOperationStatus> result = await _elementEditingService.DeleteAsync(id, CurrentUserKey(_backOfficeSecurityAccessor));
+
+        return result.Success
+            ? Ok()
+            : ContentEditingOperationStatusResult(result.Status);
+    }
+}