Feature/90 known types

src/Kontent.Ai.ModelGenerator.Core/CodeGeneratorBase.cs

@@ -11,14 +11,12 @@ namespace Kontent.Ai.ModelGenerator.Core;
 
 public abstract class CodeGeneratorBase
 {
-    private string ProjectId => Options.ManagementApi ? Options.ManagementOptions.ProjectId : Options.DeliveryOptions.ProjectId;
-
     protected readonly CodeGeneratorOptions Options;
     protected readonly IOutputProvider OutputProvider;
 
     protected string FilenameSuffix => string.IsNullOrEmpty(Options.FileNameSuffix) ? "" : $".{Options.FileNameSuffix}";
     protected string NoContentTypeAvailableMessage =>
-        $@"No content type available for the project ({ProjectId}). Please make sure you have the Delivery API enabled at https://app.kontent.ai/.";
+        $@"No content type available for the project ({Options.GetProjectId()}). Please make sure you have the Delivery API enabled at https://app.kontent.ai/.";
 
     protected CodeGeneratorBase(IOptions<CodeGeneratorOptions> options, IOutputProvider outputProvider)
     {
@@ -125,7 +123,7 @@ private async Task GenerateBaseClass()
             return;
         }
 
-        var baseClassCodeGenerator = new BaseClassCodeGenerator(Options.BaseClass, Options.Namespace);
+        var baseClassCodeGenerator = new BaseClassCodeGenerator(Options);
 
         foreach (var codeGenerator in classCodeGenerators)
         {

src/Kontent.Ai.ModelGenerator.Core/Common/ClassCodeGeneratorFactory.cs

@@ -28,8 +28,13 @@ public static ClassCodeGenerator CreateClassCodeGenerator(CodeGeneratorOptions o
             return new PartialClassCodeGenerator(classDefinition, classFilename, options.Namespace);
         }
 
-        return options.ManagementApi
-            ? new ManagementClassCodeGenerator(classDefinition, classFilename, options.Namespace)
+        if (options.ManagementApi())
+        {
+            return new ManagementClassCodeGenerator(classDefinition, classFilename, options.Namespace);
+        }
+
+        return options.ExtendedDeliveryModels()
+            ? new ExtendedDeliveryClassCodeGenerator(classDefinition, classFilename, options.IsStructuredModelModularContent(), options.Namespace)
             : new DeliveryClassCodeGenerator(classDefinition, classFilename, options.Namespace);
     }
 }

src/Kontent.Ai.ModelGenerator.Core/Common/ClassDefinition.cs

@@ -47,6 +47,19 @@ public void AddSystemProperty()
         AddProperty(new Property("system", nameof(IContentItemSystemAttributes)));
     }
 
+    public void TryAddSystemProperty()
+    {
+        try
+        {
+            AddProperty(new Property("system", nameof(IContentItemSystemAttributes)));
+        }
+        catch (InvalidOperationException)
+        {
+            Console.WriteLine(
+                $"Warning: Can't add 'System' property. It's in collision with existing element in Content Type '{ClassName}'.");
+        }
+    }
+
     private bool PropertyIsAlreadyPresent(Property property)
     {
         return Properties.Exists(e => e.Identifier == property.Identifier);

src/Kontent.Ai.ModelGenerator.Core/Common/Property.cs

@@ -1,10 +1,11 @@
 using System;
-using System.Collections;
 using System.Collections.Generic;
+using System.Collections.Immutable;
 using System.Globalization;
 using Kontent.Ai.Delivery.Abstractions;
 using Kontent.Ai.Management.Models.LanguageVariants.Elements;
 using Kontent.Ai.Management.Models.Types.Elements;
+using Kontent.Ai.ModelGenerator.Core.Generators.Class;
 using Kontent.Ai.ModelGenerator.Core.Helpers;
 
 namespace Kontent.Ai.ModelGenerator.Core.Common;
@@ -13,8 +14,12 @@ public class Property
 {
     private const string RichTextElementType = "rich_text";
     private const string DateTimeElementType = "date_time";
+    private const string ModularContentElementType = "modular_content";
+
     public const string StructuredSuffix = "(structured)";
 
+    public static string ObjectType => nameof(Object).ToLower(CultureInfo.InvariantCulture);
+
     public string Identifier => TextHelpers.GetValidPascalCaseIdentifierName(Codename);
 
     public string Codename { get; }
@@ -26,23 +31,41 @@ public class Property
     /// </summary>
     public string TypeName { get; }
 
-    private static readonly Dictionary<string, string> DeliverElementTypesDictionary = new Dictionary<string, string>
+    private static readonly IImmutableDictionary<string, string> DeliverElementTypesDictionary = new Dictionary<string, string>
     {
         { "text", "string" },
         { RichTextElementType, "string" },
         { $"{RichTextElementType}{StructuredSuffix}", nameof(IRichTextContent)},
         { "number", "decimal?" },
-        { "multiple_choice", $"{nameof(IEnumerable)}<{nameof(IMultipleChoiceOption)}>"},
         { DateTimeElementType, "DateTime?" },
         { $"{DateTimeElementType}{StructuredSuffix}", nameof(IDateTimeContent) },
-        { "asset", $"{nameof(IEnumerable)}<{nameof(IAsset)}>" },
-        { "modular_content", $"{nameof(IEnumerable)}<{nameof(Object).ToLower(CultureInfo.InvariantCulture)}>" },
-        { "taxonomy", $"{nameof(IEnumerable)}<{nameof(ITaxonomyTerm)}>" },
+        { "multiple_choice", TextHelpers.GetEnumerableType(nameof(IMultipleChoiceOption))},
+        { "asset", TextHelpers.GetEnumerableType(nameof(IAsset)) },
+        { ModularContentElementType, TextHelpers.GetEnumerableType(ObjectType) },
+        { $"{ModularContentElementType}{StructuredSuffix}", TextHelpers.GetEnumerableType(nameof(IContentItem)) },
+        { "taxonomy", TextHelpers.GetEnumerableType(nameof(ITaxonomyTerm)) },
         { "url_slug", "string" },
         { "custom", "string" }
-    };
+    }.ToImmutableDictionary();
 
-    private static readonly Dictionary<ElementMetadataType, string> ManagementElementTypesDictionary = new Dictionary<ElementMetadataType, string>
+    internal static readonly IImmutableDictionary<string, string> ExtendedDeliverElementTypesDictionary = new Dictionary<string, string>
+    {
+        { ElementMetadataType.Text.ToString(), "string" },
+        { ElementMetadataType.RichText.ToString(), "string" },
+        { $"{ElementMetadataType.RichText}{StructuredSuffix}", nameof(IRichTextContent)},
+        { ElementMetadataType.Number.ToString(), "decimal?" },
+        { ElementMetadataType.MultipleChoice.ToString(), TextHelpers.GetEnumerableType(nameof(IMultipleChoiceOption))},
+        { ElementMetadataType.DateTime.ToString(), "DateTime?" },
+        { $"{ElementMetadataType.DateTime}{StructuredSuffix}", nameof(IDateTimeContent) },
+        { ElementMetadataType.Asset.ToString(), TextHelpers.GetEnumerableType(nameof(IAsset)) },
+        { ElementMetadataType.LinkedItems.ToString(), null },
+        { ElementMetadataType.Subpages.ToString(), null },
+        { ElementMetadataType.Taxonomy.ToString(), TextHelpers.GetEnumerableType(nameof(ITaxonomyTerm)) },
+        { ElementMetadataType.UrlSlug.ToString(), "string" },
+        { ElementMetadataType.Custom.ToString(), "string" }
+    }.ToImmutableDictionary();
+
+    private static readonly IImmutableDictionary<ElementMetadataType, string> ManagementElementTypesDictionary = new Dictionary<ElementMetadataType, string>
     {
         { ElementMetadataType.Text, nameof(TextElement) },
         { ElementMetadataType.RichText, nameof(RichTextElement) },
@@ -55,7 +78,7 @@ public class Property
         { ElementMetadataType.Taxonomy, nameof(TaxonomyElement) },
         { ElementMetadataType.UrlSlug,nameof(UrlSlugElement) },
         { ElementMetadataType.Custom, nameof(CustomElement) }
-    };
+    }.ToImmutableDictionary();
 
     public Property(string codename, string typeName, string id = null)
     {
@@ -68,31 +91,48 @@ public Property(string codename, string typeName, string id = null)
 
     public static bool IsRichTextElementType(string elementType) => elementType == RichTextElementType;
 
-    private static bool IsContentTypeSupported(string elementType)
-    {
-        return DeliverElementTypesDictionary.ContainsKey(elementType);
-    }
+    public static bool IsModularContentElementType(string elementType) => elementType == ModularContentElementType;
 
-    private static bool IsContentTypeSupported(ElementMetadataType elementType)
-    {
-        return ManagementElementTypesDictionary.ContainsKey(elementType);
-    }
+    public static bool IsContentTypeSupported(string elementType, bool extendedDeliveryModels) => extendedDeliveryModels
+        ? ExtendedDeliverElementTypesDictionary.ContainsKey(elementType)
+        : DeliverElementTypesDictionary.ContainsKey(elementType);
+
+    public static bool IsContentTypeSupported(string elementType) => DeliverElementTypesDictionary.ContainsKey(elementType);
+
+    public static bool IsContentTypeSupported(ElementMetadataType elementType) =>
+        ManagementElementTypesDictionary.ContainsKey(elementType);
 
-    public static Property FromContentTypeElement(string codename, string elementType)
+    public static Property FromContentTypeElement(string codename, string elementType) => IsContentTypeSupported(elementType)
+        ? new Property(codename, DeliverElementTypesDictionary[elementType])
+        : throw new ArgumentException($"Unknown Content Type {elementType}", nameof(elementType));
+
+    public static Property FromContentTypeElement(ElementMetadataBase element)
     {
-        if (IsContentTypeSupported(elementType))
+        if (IsContentTypeSupported(element.Type))
         {
-            return new Property(codename, DeliverElementTypesDictionary[elementType]);
+            return new Property(element.Codename, ManagementElementTypesDictionary[element.Type], element.Id.ToString());
+        }
+
+        if (element.Type == ElementMetadataType.Guidelines)
+        {
+            throw new UnsupportedTypeException();
         }
 
-        throw new ArgumentException($"Unknown Content Type {elementType}", nameof(elementType));
+        throw new ArgumentException($"Unknown Content Type {element.Type}", nameof(element));
     }
 
-    public static Property FromContentTypeElement(ElementMetadataBase element)
+    public static Property FromContentTypeElement(ElementMetadataBase element, string elementType) =>
+        FromContentTypeElement(element, elementType, element.Codename);
+
+    public static Property FromContentTypeElement(ElementMetadataBase element, string elementType, string finalPropertyName)
     {
-        if (IsContentTypeSupported(element.Type))
+        if (IsContentTypeSupported(element.Type.ToString(), true))
         {
-            return new Property(element.Codename, ManagementElementTypesDictionary[element.Type], element.Id.ToString());
+            var resultElementType = element.Type is ElementMetadataType.LinkedItems or ElementMetadataType.Subpages
+                ? elementType
+                : ExtendedDeliverElementTypesDictionary[elementType];
+
+            return new Property(finalPropertyName, resultElementType);
         }
 
         if (element.Type == ElementMetadataType.Guidelines)

src/Kontent.Ai.ModelGenerator.Core/Configuration/CodeGeneratorOptions.cs

@@ -8,6 +8,7 @@ namespace Kontent.Ai.ModelGenerator.Core.Configuration;
 public class CodeGeneratorOptions
 {
     private const char StructuredModelSeparator = ',';
+    private const bool DefaultExtendedDeliveryModels = false;
     private const bool DefaultGeneratePartials = true;
     private const bool DefaultWithTypeProvider = true;
     private const bool DefaultManagementApi = false;
@@ -24,6 +25,11 @@ public class CodeGeneratorOptions
     /// </summary>
     public ManagementOptions ManagementOptions { get; set; }
 
+    /// <summary>
+    /// Indicates whether the extended Delivery models should be generated
+    /// </summary>
+    public bool ExtendedDeliveryModels { get; set; } = DefaultExtendedDeliveryModels;
+
     /// <summary>
     /// Namespace name of the generated classes
     /// </summary>

src/Kontent.Ai.ModelGenerator.Core/Configuration/CodeGeneratorOptionsExtensions.cs

@@ -2,9 +2,36 @@
 
 public static class CodeGeneratorOptionsExtensions
 {
+    public static bool ManagementApi(this CodeGeneratorOptions options) =>
+        options.ManagementApi && !options.ExtendedDeliveryModels;
+
+    public static bool ExtendedDeliveryModels(this CodeGeneratorOptions options) =>
+        !options.ManagementApi && options.ExtendedDeliveryModels;
+
+    public static bool DeliveryApi(this CodeGeneratorOptions options) => !options.ManagementApi() && !options.ExtendedDeliveryModels();
+
+    public static DesiredModelsType GetDesiredModelsType(this CodeGeneratorOptions options)
+    {
+        if (options.ManagementApi())
+        {
+            return DesiredModelsType.Management;
+        }
+
+        return options.ExtendedDeliveryModels() ? DesiredModelsType.ExtendedDelivery : DesiredModelsType.Delivery;
+    }
+
+    public static string GetProjectId(this CodeGeneratorOptions options) =>
+        options.ManagementApi || options.ExtendedDeliveryModels
+            ? options.ManagementOptions.ProjectId
+            : options.DeliveryOptions.ProjectId;
+
+    public static bool IsStructuredModelModularContent(this CodeGeneratorOptions options) =>
+        options.StructuredModelFlags.HasFlag(StructuredModelFlags.ModularContent);
+
     public static bool IsStructuredModelEnabled(this CodeGeneratorOptions options) =>
         options.StructuredModelFlags.HasFlag(StructuredModelFlags.RichText) ||
         options.StructuredModelFlags.HasFlag(StructuredModelFlags.True) ||
+        options.StructuredModelFlags.HasFlag(StructuredModelFlags.ModularContent) ||
         options.StructuredModelFlags.HasFlag(StructuredModelFlags.DateTime);
 
     public static bool IsStructuredModelRichText(this CodeGeneratorOptions options) =>

src/Kontent.Ai.ModelGenerator.Core/Configuration/DesiredModelsType.cs

@@ -0,0 +1,8 @@
+namespace Kontent.Ai.ModelGenerator.Core.Configuration;
+
+public enum DesiredModelsType
+{
+    Delivery,
+    Management,
+    ExtendedDelivery
+}

src/Kontent.Ai.ModelGenerator.Core/Configuration/StructuredModelFlags.cs

@@ -9,5 +9,6 @@ public enum StructuredModelFlags
     RichText = 2,
     DateTime = 4,
     ValidationIssue = 8,
-    True = 16
+    True = 16,
+    ModularContent = 32
 }

src/Kontent.Ai.ModelGenerator.Core/DeliveryCodeGenerator.cs

@@ -1,18 +1,16 @@
 using System;
 using System.Collections.Generic;
-using System.Linq;
 using System.Threading.Tasks;
 using Kontent.Ai.Delivery.Abstractions;
 using Kontent.Ai.ModelGenerator.Core.Common;
 using Kontent.Ai.ModelGenerator.Core.Configuration;
-using Kontent.Ai.ModelGenerator.Core.Generators;
 using Kontent.Ai.ModelGenerator.Core.Generators.Class;
 using Kontent.Ai.ModelGenerator.Core.Helpers;
 using Microsoft.Extensions.Options;
 
 namespace Kontent.Ai.ModelGenerator.Core;
 
-public class DeliveryCodeGenerator : CodeGeneratorBase
+public class DeliveryCodeGenerator : DeliveryCodeGeneratorBase
 {
     private readonly IDeliveryClient _deliveryClient;
 
@@ -27,18 +25,6 @@ public DeliveryCodeGenerator(IOptions<CodeGeneratorOptions> options, IOutputProv
         _deliveryClient = deliveryClient;
     }
 
-    public new async Task<int> RunAsync()
-    {
-        await base.RunAsync();
-
-        if (Options.WithTypeProvider)
-        {
-            await GenerateTypeProvider();
-        }
-
-        return 0;
-    }
-
     protected override async Task<ICollection<ClassCodeGenerator>> GetClassCodeGenerators()
     {
         var deliveryTypes = (await _deliveryClient.GetTypesAsync()).Types;
@@ -94,27 +80,6 @@ internal ClassCodeGenerator GetClassCodeGenerator(IContentType contentType)
         return ClassCodeGeneratorFactory.CreateClassCodeGenerator(Options, classDefinition, classFilename);
     }
 
-    private async Task GenerateTypeProvider()
-    {
-        var classCodeGenerators = await GetClassCodeGenerators();
-
-        if (!classCodeGenerators.Any())
-        {
-            Console.WriteLine(NoContentTypeAvailableMessage);
-            return;
-        }
-
-        var typeProviderCodeGenerator = new TypeProviderCodeGenerator(Options.Namespace);
-
-        foreach (var codeGenerator in classCodeGenerators)
-        {
-            typeProviderCodeGenerator.AddContentType(codeGenerator.ClassDefinition.Codename, codeGenerator.ClassDefinition.ClassName);
-        }
-
-        var typeProviderCode = typeProviderCodeGenerator.GenerateCode();
-        WriteToOutputProvider(typeProviderCode, TypeProviderCodeGenerator.ClassName, true);
-    }
-
     private static void TryAddSystemProperty(ClassDefinition classDefinition)
     {
         try

src/Kontent.Ai.ModelGenerator.Core/DeliveryCodeGeneratorBase.cs

@@ -0,0 +1,49 @@
+using Kontent.Ai.ModelGenerator.Core.Configuration;
+using Kontent.Ai.ModelGenerator.Core.Generators.Class;
+using Kontent.Ai.ModelGenerator.Core.Generators;
+using Microsoft.Extensions.Options;
+using System;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace Kontent.Ai.ModelGenerator.Core;
+
+public abstract class DeliveryCodeGeneratorBase : CodeGeneratorBase
+{
+    protected DeliveryCodeGeneratorBase(IOptions<CodeGeneratorOptions> options, IOutputProvider outputProvider) : base(options, outputProvider)
+    {
+    }
+
+    public new async Task<int> RunAsync()
+    {
+        await base.RunAsync();
+
+        if (Options.WithTypeProvider)
+        {
+            await GenerateTypeProvider();
+        }
+
+        return 0;
+    }
+
+    private async Task GenerateTypeProvider()
+    {
+        var classCodeGenerators = await GetClassCodeGenerators();
+
+        if (!classCodeGenerators.Any())
+        {
+            Console.WriteLine(NoContentTypeAvailableMessage);
+            return;
+        }
+
+        var typeProviderCodeGenerator = new TypeProviderCodeGenerator(Options.Namespace);
+
+        foreach (var codeGenerator in classCodeGenerators)
+        {
+            typeProviderCodeGenerator.AddContentType(codeGenerator.ClassDefinition.Codename, codeGenerator.ClassDefinition.ClassName);
+        }
+
+        var typeProviderCode = typeProviderCodeGenerator.GenerateCode();
+        WriteToOutputProvider(typeProviderCode, TypeProviderCodeGenerator.ClassName, true);
+    }
+}