Content Type inheritance

src/Umbraco.Cms.Api.Management/Factories/ContentTypeEditingPresentationFactory.cs

@@ -1,4 +1,5 @@
-using Umbraco.Cms.Core.Models;
+using Umbraco.Cms.Api.Management.ViewModels;
+using Umbraco.Cms.Core.Models;
 using Umbraco.Cms.Core.Services;
 using Umbraco.Extensions;
 using ContentTypeEditingModels = Umbraco.Cms.Core.Models.ContentTypeEditing;
@@ -38,12 +39,27 @@ protected TContentTypeEditingModel MapContentTypeEditingModel<
             VariesByCulture = viewModel.VariesByCulture,
             VariesBySegment = viewModel.VariesBySegment,
             Containers = MapContainers<TPropertyTypeContainerEditingModel>(viewModel.Containers),
-            Properties = MapProperties<TPropertyTypeEditingModel>(viewModel.Properties)
+            Properties = MapProperties<TPropertyTypeEditingModel>(viewModel.Properties),
         };
 
         return editingModel;
     }
 
+    protected Guid? CalculateCreateContainerKey(ReferenceByIdModel? parent, IDictionary<Guid, ContentTypeViewModels.CompositionType> compositions)
+    {
+        // special case:
+        // the API is somewhat confusing when it comes to inheritance. the parent denotes a container (folder), but it
+        // is easily confused with the parent for inheritance.
+        // if the request model contains the same key for container and "inheritance composition", we'll be lenient and
+        // allow it - just remove the container, inheritance takes precedence as intent.
+        Guid? parentId = parent?.Id;
+        return parentId.HasValue
+               && compositions.TryGetValue(parentId.Value, out ContentTypeViewModels.CompositionType compositionType)
+               && compositionType is ContentTypeViewModels.CompositionType.Inheritance
+            ? null
+            : parentId;
+    }
+
     protected T MapCompositionModel<T>(ContentTypeAvailableCompositionsResult compositionResult)
         where T : ContentTypeViewModels.AvailableContentTypeCompositionResponseModelBase, new()
     {

src/Umbraco.Cms.Api.Management/Factories/DocumentTypeEditingPresentationFactory.cs

@@ -25,12 +25,14 @@ public ContentTypeCreateModel MapCreateModel(CreateDocumentTypeRequestModel requ
         MapCleanup(createModel, requestModel.Cleanup);
 
         createModel.Key = requestModel.Id;
-        createModel.ContainerKey = requestModel.Parent?.Id;
         createModel.AllowedTemplateKeys = requestModel.AllowedTemplates.Select(reference => reference.Id).ToArray();
         createModel.DefaultTemplateKey = requestModel.DefaultTemplate?.Id;
         createModel.ListView = requestModel.Collection?.Id;
         createModel.AllowedContentTypes = MapAllowedContentTypes(requestModel.AllowedDocumentTypes);
-        createModel.Compositions = MapCompositions(requestModel.Compositions);
+
+        IDictionary<Guid, ViewModels.ContentType.CompositionType> compositionTypesByKey = CompositionTypesByKey(requestModel.Compositions);
+        createModel.Compositions = MapCompositions(compositionTypesByKey);
+        createModel.ContainerKey = CalculateCreateContainerKey(requestModel.Parent, compositionTypesByKey);
 
         return createModel;
     }
@@ -51,7 +53,7 @@ public ContentTypeUpdateModel MapUpdateModel(UpdateDocumentTypeRequestModel requ
         updateModel.DefaultTemplateKey = requestModel.DefaultTemplate?.Id;
         updateModel.ListView = requestModel.Collection?.Id;
         updateModel.AllowedContentTypes = MapAllowedContentTypes(requestModel.AllowedDocumentTypes);
-        updateModel.Compositions = MapCompositions(requestModel.Compositions);
+        updateModel.Compositions = MapCompositions(CompositionTypesByKey(requestModel.Compositions));
 
         return updateModel;
     }
@@ -72,8 +74,8 @@ private IEnumerable<ContentTypeSort> MapAllowedContentTypes(IEnumerable<Document
             .DistinctBy(t => t.DocumentType.Id)
             .ToDictionary(t => t.DocumentType.Id, t => t.SortOrder));
 
-    private IEnumerable<Composition> MapCompositions(IEnumerable<DocumentTypeComposition> documentTypeCompositions)
-        => MapCompositions(documentTypeCompositions
+    private IDictionary<Guid, ViewModels.ContentType.CompositionType> CompositionTypesByKey(IEnumerable<DocumentTypeComposition> documentTypeCompositions)
+        => documentTypeCompositions
             .DistinctBy(c => c.DocumentType.Id)
-            .ToDictionary(c => c.DocumentType.Id, c => c.CompositionType));
+            .ToDictionary(c => c.DocumentType.Id, c => c.CompositionType);
 }

src/Umbraco.Cms.Api.Management/Factories/MediaTypeEditingPresentationFactory.cs

@@ -23,11 +23,13 @@ public MediaTypeCreateModel MapCreateModel(CreateMediaTypeRequestModel requestMo
         >(requestModel);
 
         createModel.Key = requestModel.Id;
-        createModel.ContainerKey = requestModel.Parent?.Id;
         createModel.AllowedContentTypes = MapAllowedContentTypes(requestModel.AllowedMediaTypes);
-        createModel.Compositions = MapCompositions(requestModel.Compositions);
         createModel.ListView = requestModel.Collection?.Id;
 
+        IDictionary<Guid, ViewModels.ContentType.CompositionType> compositionTypesByKey = CompositionTypesByKey(requestModel.Compositions);
+        createModel.Compositions = MapCompositions(compositionTypesByKey);
+        createModel.ContainerKey = CalculateCreateContainerKey(requestModel.Parent, compositionTypesByKey);
+
         return createModel;
     }
 
@@ -42,7 +44,8 @@ public MediaTypeUpdateModel MapUpdateModel(UpdateMediaTypeRequestModel requestMo
         >(requestModel);
 
         updateModel.AllowedContentTypes = MapAllowedContentTypes(requestModel.AllowedMediaTypes);
-        updateModel.Compositions = MapCompositions(requestModel.Compositions);
+        updateModel.Compositions = MapCompositions(CompositionTypesByKey(requestModel.Compositions));
+
         updateModel.ListView = requestModel.Collection?.Id;
 
         return updateModel;
@@ -56,8 +59,8 @@ private IEnumerable<ContentTypeSort> MapAllowedContentTypes(IEnumerable<MediaTyp
             .DistinctBy(t => t.MediaType.Id)
             .ToDictionary(t => t.MediaType.Id, t => t.SortOrder));
 
-    private IEnumerable<Composition> MapCompositions(IEnumerable<MediaTypeComposition> documentTypeCompositions)
-        => MapCompositions(documentTypeCompositions
+    private IDictionary<Guid, ViewModels.ContentType.CompositionType> CompositionTypesByKey(IEnumerable<MediaTypeComposition> documentTypeCompositions)
+        => documentTypeCompositions
             .DistinctBy(c => c.MediaType.Id)
-            .ToDictionary(c => c.MediaType.Id, c => c.CompositionType));
+            .ToDictionary(c => c.MediaType.Id, c => c.CompositionType);
 }

src/Umbraco.Cms.Api.Management/Mapping/ContentType/ContentTypeMapDefinition.cs

@@ -83,24 +83,9 @@ protected static CompositionType CalculateCompositionType(int contentTypeParentI
             ? CompositionType.Inheritance
             : CompositionType.Composition;
 
-    protected static IEnumerable<T> MapNestedCompositions<T>(IEnumerable<IContentTypeComposition> directCompositions, int contentTypeParentId, Func<ReferenceByIdModel, CompositionType, T> contentTypeCompositionFactory)
-    {
-        var allCompositions = new List<T>();
-
-        foreach (var composition in directCompositions)
-        {
-            CompositionType compositionType = CalculateCompositionType(contentTypeParentId, composition);
-            T contentTypeComposition = contentTypeCompositionFactory(new ReferenceByIdModel(composition.Key), compositionType);
-            allCompositions.Add(contentTypeComposition);
-
-            // When we have composition inheritance, we have to find all ancestor compositions recursively
-            if (compositionType == CompositionType.Inheritance && composition.ContentTypeComposition.Any())
-            {
-                var nestedCompositions = MapNestedCompositions(composition.ContentTypeComposition, composition.ParentId, contentTypeCompositionFactory);
-                allCompositions.AddRange(nestedCompositions);
-            }
-        }
-
-        return allCompositions;
-    }
+    protected static IEnumerable<T> MapCompositions<T>(IEnumerable<IContentTypeComposition> directCompositions, int contentTypeParentId, Func<ReferenceByIdModel, CompositionType, T> contentTypeCompositionFactory)
+         => directCompositions
+         .Select(composition => contentTypeCompositionFactory(
+            new ReferenceByIdModel(composition.Key),
+             CalculateCompositionType(contentTypeParentId, composition))).ToArray();
 }

src/Umbraco.Cms.Api.Management/Mapping/DocumentType/DocumentTypeMapDefinition.cs

@@ -41,7 +41,7 @@ private void Map(IContentType source, DocumentTypeResponseModel target, MapperCo
                 new DocumentTypeSort { DocumentType = new ReferenceByIdModel(ct.Key), SortOrder = ct.SortOrder })
             .OrderBy(ct => ct.SortOrder)
             .ToArray() ?? Enumerable.Empty<DocumentTypeSort>();
-        target.Compositions = MapNestedCompositions(
+        target.Compositions = MapCompositions(
             source.ContentTypeComposition,
             source.ParentId,
             (referenceByIdModel, compositionType) => new DocumentTypeComposition

src/Umbraco.Cms.Api.Management/Mapping/MediaType/MediaTypeMapDefinition.cs

@@ -40,7 +40,7 @@ private void Map(IMediaType source, MediaTypeResponseModel target, MapperContext
         target.AllowedMediaTypes = source.AllowedContentTypes?.Select(ct =>
                 new MediaTypeSort { MediaType = new ReferenceByIdModel(ct.Key), SortOrder = ct.SortOrder })
             .ToArray() ?? Enumerable.Empty<MediaTypeSort>();
-        target.Compositions = MapNestedCompositions(
+        target.Compositions = MapCompositions(
             source.ContentTypeComposition,
             source.ParentId,
             (referenceByIdModel, compositionType) => new MediaTypeComposition

src/Umbraco.Cms.Api.Management/Mapping/MemberType/MemberTypeMapDefinition.cs

@@ -32,7 +32,7 @@ private void Map(IMemberType source, MemberTypeResponseModel target, MapperConte
         target.IsElement = source.IsElement;
         target.Containers = MapPropertyTypeContainers(source);
         target.Properties = MapPropertyTypes(source);
-        target.Compositions = MapNestedCompositions(
+        target.Compositions = MapCompositions(
             source.ContentTypeComposition,
             source.ParentId,
             (referenceByIdModel, compositionType) => new MemberTypeComposition

src/Umbraco.Core/Services/ContentTypeEditing/ContentTypeEditingServiceBase.cs

@@ -322,6 +322,15 @@ private ContentTypeOperationStatus ValidateCompositions(TContentType? contentTyp
         // get the content type keys we want to use for compositions
         Guid[] compositionKeys = KeysForCompositionTypes(model, CompositionType.Composition);
 
+        // if the content type keys are already set as compositions, don't perform any additional validation
+        // - this covers an edge case where compositions are configured for a content type before child content types are created
+        if (contentType is not null && contentType.ContentTypeComposition
+            .Select(c => c.Key)
+            .ContainsAll(compositionKeys))
+        {
+            return ContentTypeOperationStatus.Success;
+        }
+
         // verify that all compositions keys are allowed
         Guid[] allowedCompositionKeys = _contentTypeService.GetAvailableCompositeContentTypes(contentType, allContentTypeCompositions, isElement: model.IsElement)
             .Results

src/Umbraco.Web.UI.Client/src/packages/content/content-type/structure/content-type-property-structure-helper.class.ts

@@ -9,7 +9,7 @@ import { UmbControllerBase } from '@umbraco-cms/backoffice/class-api';
 import type { UmbControllerHost } from '@umbraco-cms/backoffice/controller-api';
 import { UmbArrayState, mergeObservables } from '@umbraco-cms/backoffice/observable-api';
 
-type UmbPropertyTypeId = UmbPropertyTypeModel['id'];
+type UmbPropertyTypeUnique = UmbPropertyTypeModel['unique'];
 
 /**
  * This class is a helper class for managing the structure of containers in a content type.
@@ -24,7 +24,7 @@ export class UmbContentTypePropertyStructureHelper<T extends UmbContentTypeModel
 	#containerId?: string | null;
 
 	// State which holds all the properties of the current container, this is a composition of all properties from the containers that matches our target [NL]
-	#propertyStructure = new UmbArrayState<UmbPropertyTypeModel>([], (x) => x.id);
+	#propertyStructure = new UmbArrayState<UmbPropertyTypeModel>([], (x) => x.unique);
 	readonly propertyStructure = this.#propertyStructure.asObservable();
 
 	constructor(host: UmbControllerHost) {
@@ -164,18 +164,20 @@ export class UmbContentTypePropertyStructureHelper<T extends UmbContentTypeModel
 		);
 	}
 
-	async isOwnerProperty(propertyId: UmbPropertyTypeId) {
+	async isOwnerProperty(propertyUnique: UmbPropertyTypeUnique) {
 		await this.#init;
 		if (!this.#structure) return;
 
-		return this.#structure.ownerContentTypeObservablePart((x) => x?.properties.some((y) => y.id === propertyId));
+		return this.#structure.ownerContentTypeObservablePart((x) =>
+			x?.properties.some((y) => y.unique === propertyUnique),
+		);
 	}
 
-	async contentTypeOfProperty(propertyId: UmbPropertyTypeId) {
+	async contentTypeOfProperty(propertyUnique: UmbPropertyTypeUnique) {
 		await this.#init;
 		if (!this.#structure) return;
 
-		return this.#structure.contentTypeOfProperty(propertyId);
+		return this.#structure.contentTypeOfProperty(propertyUnique);
 	}
 
 	// TODO: consider moving this to another class, to separate 'viewer' from 'manipulator':
@@ -194,11 +196,11 @@ export class UmbContentTypePropertyStructureHelper<T extends UmbContentTypeModel
 		return true;
 	}
 
-	async removeProperty(propertyId: UmbPropertyTypeId) {
+	async removeProperty(propertyUnique: UmbPropertyTypeUnique) {
 		await this.#init;
 		if (!this.#structure) return false;
 
-		await this.#structure.removeProperty(null, propertyId);
+		await this.#structure.removeProperty(null, propertyUnique);
 		return true;
 	}