Templating: Creating a doctype with template now yields a strongly typed template (closes #20443)

src/Umbraco.Cms.Api.Management/Controllers/Template/CreateTemplateForDocumentTypeController.cs

@@ -0,0 +1,41 @@
+using Asp.Versioning;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Umbraco.Cms.Api.Management.ViewModels.Template;
+using Umbraco.Cms.Core;
+using Umbraco.Cms.Core.Models;
+using Umbraco.Cms.Core.Security;
+using Umbraco.Cms.Core.Services;
+using Umbraco.Cms.Core.Services.OperationStatus;
+
+namespace Umbraco.Cms.Api.Management.Controllers.Template;
+
+[ApiVersion("1.0")]
+public class CreateTemplateForDocumentTypeController : TemplateControllerBase
+{
+    private readonly ITemplateService _templateService;
+    private readonly IBackOfficeSecurityAccessor _backOfficeSecurityAccessor;
+
+    public CreateTemplateForDocumentTypeController(
+        ITemplateService templateService,
+        IBackOfficeSecurityAccessor backOfficeSecurityAccessor)
+    {
+        _templateService = templateService;
+        _backOfficeSecurityAccessor = backOfficeSecurityAccessor;
+    }
+
+    [HttpPost("for-document-type")]
+    [MapToApiVersion("1.0")]
+    [ProducesResponseType(StatusCodes.Status201Created)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status400BadRequest)]
+    public async Task<IActionResult> CreateForDocumentType(CancellationToken cancellationToken, CreateTemplateForDocumentTypeRequestModel requestModel)
+    {
+        Attempt<ITemplate?, TemplateOperationStatus> result = await _templateService.CreateForContentTypeAsync(
+            requestModel.DocumentType.Id,
+            CurrentUserKey(_backOfficeSecurityAccessor));
+
+        return result.Success
+            ? CreatedAtId<ByKeyTemplateController>(controller => nameof(controller.ByKey), result.Result!.Key)
+            : TemplateOperationStatusResult(result.Status);
+    }
+}

src/Umbraco.Cms.Api.Management/Controllers/Template/TemplateControllerBase.cs

@@ -42,6 +42,10 @@ protected IActionResult TemplateOperationStatusResult(TemplateOperationStatus st
                 .WithTitle("Master template cannot be deleted")
                 .WithDetail("The master templates cannot be deleted. Please ensure the template is not a master template before you delete.")
                 .Build()),
+            TemplateOperationStatus.ContentTypeNotFound => BadRequest(problemDetailsBuilder
+                .WithTitle("Content type not found")
+                .WithDetail("The provided content type was not found.")
+                .Build()),
             _ => StatusCode(StatusCodes.Status500InternalServerError, problemDetailsBuilder
                 .WithTitle("Unknown template operation status.")
                 .Build()),

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

@@ -28944,6 +28944,126 @@
         ]
       }
     },
+    "/umbraco/management/api/v1/template/for-document-type": {
+      "post": {
+        "tags": [
+          "Template"
+        ],
+        "operationId": "PostTemplateForDocumentType",
+        "requestBody": {
+          "content": {
+            "application/json": {
+              "schema": {
+                "oneOf": [
+                  {
+                    "$ref": "#/components/schemas/CreateTemplateForDocumentTypeRequestModel"
+                  }
+                ]
+              }
+            },
+            "text/json": {
+              "schema": {
+                "oneOf": [
+                  {
+                    "$ref": "#/components/schemas/CreateTemplateForDocumentTypeRequestModel"
+                  }
+                ]
+              }
+            },
+            "application/*+json": {
+              "schema": {
+                "oneOf": [
+                  {
+                    "$ref": "#/components/schemas/CreateTemplateForDocumentTypeRequestModel"
+                  }
+                ]
+              }
+            }
+          }
+        },
+        "responses": {
+          "201": {
+            "description": "Created",
+            "headers": {
+              "Umb-Generated-Resource": {
+                "description": "Identifier of the newly created resource",
+                "schema": {
+                  "type": "string",
+                  "description": "Identifier of the newly created resource"
+                }
+              },
+              "Location": {
+                "description": "Location of the newly created resource",
+                "schema": {
+                  "type": "string",
+                  "description": "Location of the newly created resource",
+                  "format": "uri"
+                }
+              },
+              "Umb-Notifications": {
+                "description": "The list of notifications produced during the request.",
+                "schema": {
+                  "type": "array",
+                  "items": {
+                    "$ref": "#/components/schemas/NotificationHeaderModel"
+                  },
+                  "nullable": true
+                }
+              }
+            }
+          },
+          "400": {
+            "description": "Bad Request",
+            "headers": {
+              "Umb-Notifications": {
+                "description": "The list of notifications produced during the request.",
+                "schema": {
+                  "type": "array",
+                  "items": {
+                    "$ref": "#/components/schemas/NotificationHeaderModel"
+                  },
+                  "nullable": true
+                }
+              }
+            },
+            "content": {
+              "application/json": {
+                "schema": {
+                  "oneOf": [
+                    {
+                      "$ref": "#/components/schemas/ProblemDetails"
+                    }
+                  ]
+                }
+              }
+            }
+          },
+          "401": {
+            "description": "The resource is protected and requires an authentication token"
+          },
+          "403": {
+            "description": "The authenticated user does not have access to this resource",
+            "headers": {
+              "Umb-Notifications": {
+                "description": "The list of notifications produced during the request.",
+                "schema": {
+                  "type": "array",
+                  "items": {
+                    "$ref": "#/components/schemas/NotificationHeaderModel"
+                  },
+                  "nullable": true
+                }
+              }
+            }
+          }
+        },
+        "security": [
+          {
+            "Backoffice-User": [ ]
+          }
+        ]
+      }
+    },
     "/umbraco/management/api/v1/template/query/execute": {
       "post": {
         "tags": [
@@ -37175,6 +37295,22 @@
         },
         "additionalProperties": false
       },
+      "CreateTemplateForDocumentTypeRequestModel": {
+        "required": [
+          "documentType"
+        ],
+        "type": "object",
+        "properties": {
+          "documentType": {
+            "oneOf": [
+              {
+                "$ref": "#/components/schemas/ReferenceByIdModel"
+              }
+            ]
+          }
+        },
+        "additionalProperties": false
+      },
       "CreateTemplateRequestModel": {
         "required": [
           "alias",
@@ -38444,7 +38580,8 @@
             "type": "boolean"
           },
           "allowNonExistingSegmentsCreation": {
-            "type": "boolean"
+            "type": "boolean",
+            "deprecated": true
           }
         },
         "additionalProperties": false

src/Umbraco.Cms.Api.Management/ViewModels/Template/CreateTemplateForDocumentTypeRequestModel.cs

@@ -0,0 +1,9 @@
+using System.ComponentModel.DataAnnotations;
+
+namespace Umbraco.Cms.Api.Management.ViewModels.Template;
+
+public class CreateTemplateForDocumentTypeRequestModel
+{
+    [Required]
+    public required ReferenceByIdModel DocumentType { get; set; }
+}

src/Umbraco.Core/Services/ITemplateService.cs

@@ -73,6 +73,18 @@ Task<Attempt<ITemplate, TemplateOperationStatus>> CreateForContentTypeAsync(
         string? contentTypeName,
         Guid userKey);
 
+    /// <summary>
+    ///     Creates a template for a content type.
+    /// </summary>
+    /// <param name="contentTypeKey">The content type key.</param>
+    /// <param name="userKey">The key of the performing user.</param>
+    /// <returns>
+    ///     An attempt with the created template.
+    /// </returns>
+    Task<Attempt<ITemplate?, TemplateOperationStatus>> CreateForContentTypeAsync(
+        Guid contentTypeKey,
+        Guid userKey) => throw new NotImplementedException();
+
     /// <summary>
     ///     Creates a new template
     /// </summary>

src/Umbraco.Core/Services/OperationStatus/TemplateOperationStatus.cs

@@ -10,4 +10,5 @@ public enum TemplateOperationStatus
     MasterTemplateNotFound,
     CircularMasterTemplateReference,
     MasterTemplateCannotBeDeleted,
+    ContentTypeNotFound,
 }

src/Umbraco.Core/Services/TemplateService.cs

@@ -1,11 +1,14 @@
+using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
+using Umbraco.Cms.Core.DependencyInjection;
 using Umbraco.Cms.Core.Events;
 using Umbraco.Cms.Core.IO;
 using Umbraco.Cms.Core.Models;
 using Umbraco.Cms.Core.Notifications;
 using Umbraco.Cms.Core.Persistence.Querying;
 using Umbraco.Cms.Core.Persistence.Repositories;
 using Umbraco.Cms.Core.Scoping;
+using Umbraco.Cms.Core.Services.ContentTypeEditing;
 using Umbraco.Cms.Core.Services.OperationStatus;
 using Umbraco.Cms.Core.Strings;
 using Umbraco.Extensions;
@@ -20,6 +23,7 @@
     private readonly ITemplateContentParserService _templateContentParserService;
     private readonly IUserIdKeyResolver _userIdKeyResolver;
     private readonly IDefaultViewContentProvider _defaultViewContentProvider;
+    private readonly IContentTypeService _contentTypeService;
 
     public TemplateService(
         ICoreScopeProvider provider,
@@ -30,7 +34,8 @@
         IAuditRepository auditRepository,
         ITemplateContentParserService templateContentParserService,
         IUserIdKeyResolver userIdKeyResolver,
-        IDefaultViewContentProvider defaultViewContentProvider)
+        IDefaultViewContentProvider defaultViewContentProvider,
+        IContentTypeService contentTypeService)
         : base(provider, loggerFactory, eventMessagesFactory)
     {
         _shortStringHelper = shortStringHelper;
@@ -39,13 +44,43 @@
         _templateContentParserService = templateContentParserService;
         _userIdKeyResolver = userIdKeyResolver;
         _defaultViewContentProvider = defaultViewContentProvider;
+        _contentTypeService = contentTypeService;
+    }
+
+    [Obsolete("Use the non-obsolete constructor. Scheduled for removal in v18.")]
+    public TemplateService(
+        ICoreScopeProvider provider,
+        ILoggerFactory loggerFactory,
+        IEventMessagesFactory eventMessagesFactory,
+        IShortStringHelper shortStringHelper,
+        ITemplateRepository templateRepository,
+        IAuditRepository auditRepository,
+        ITemplateContentParserService templateContentParserService,
+        IUserIdKeyResolver userIdKeyResolver,
+        IDefaultViewContentProvider defaultViewContentProvider)
+        : this(
+            provider,
+            loggerFactory,
+            eventMessagesFactory,
+            shortStringHelper,
+            templateRepository,
+            auditRepository,
+            templateContentParserService,
+            userIdKeyResolver,
+            defaultViewContentProvider,
+            StaticServiceProvider.Instance.GetRequiredService<IContentTypeService>())
+    {
     }
 
     /// <inheritdoc />
     public async Task<Attempt<ITemplate, TemplateOperationStatus>> CreateForContentTypeAsync(
-        string contentTypeAlias, string? contentTypeName, Guid userKey)
+        string contentTypeAlias,
+        string? contentTypeName,
+        Guid userKey)
     {
-        ITemplate template = new Template(_shortStringHelper, contentTypeName,
+        ITemplate template = new Template(
+            _shortStringHelper,
+            contentTypeName,
 
             // NOTE: We are NOT passing in the content type alias here, we want to use it's name since we don't
             // want to save template file names as camelCase, the Template ctor will clean the alias as
@@ -71,7 +106,7 @@
         using (ICoreScope scope = ScopeProvider.CreateCoreScope())
         {
             var savingEvent = new TemplateSavingNotification(template, eventMessages, true, contentTypeAlias!);
-            if (scope.Notifications.PublishCancelable(savingEvent))
+            if (await scope.Notifications.PublishCancelableAsync(savingEvent))
             {
                 scope.Complete();
                 return Attempt.FailWithStatus(TemplateOperationStatus.CancelledByNotification, template);
@@ -89,6 +124,23 @@
         return Attempt.SucceedWithStatus(TemplateOperationStatus.Success, template);
     }
 
+    /// <inheritdoc />
+    public async Task<Attempt<ITemplate?, TemplateOperationStatus>> CreateForContentTypeAsync(
+        Guid contentTypeKey,
+        Guid userKey)
+    {
+        IContentType? contentType = await _contentTypeService.GetAsync(contentTypeKey);
+        if (contentType is null)
+        {
+            return Attempt.FailWithStatus(TemplateOperationStatus.ContentTypeNotFound, default(ITemplate));
+        }
+
+        Attempt<ITemplate, TemplateOperationStatus> result = await CreateForContentTypeAsync(contentType.Alias, contentType.Name, userKey);
+        return result.Success
+            ? Attempt.SucceedWithStatus<ITemplate?, TemplateOperationStatus>(result.Status, result.Result)
+            : Attempt.FailWithStatus<ITemplate?, TemplateOperationStatus>(result.Status, result.Result);
+    }
+
     /// <inheritdoc />
     public async Task<Attempt<ITemplate, TemplateOperationStatus>> CreateAsync(
         string name,