Code gen generate service collection extension (#809)

* GenerateServiceCollectionExtension

* Fix mergeerror

* fix warning

Author: FrankBakkerNl

src/HassModel/NetDaemon.HassModel.CodeGenerator/CodeGeneration/EntitiesGenerator.cs

@@ -54,7 +54,7 @@ private static TypeDeclarationSyntax GenerateRootEntitiesClass(IEnumerable<Entit
                 .ToPublic();
         }).ToArray();
 
-        return ClassWithInjected<IHaContext>("Entities")
+        return ClassWithInjected<IHaContext>(EntitiesClassName)
             .ToPublic()
             .AddModifiers(Token(SyntaxKind.PartialKeyword))
             .WithBase((string)"IEntities")

src/HassModel/NetDaemon.HassModel.CodeGenerator/CodeGeneration/Generator.cs

@@ -1,4 +1,5 @@
 using Microsoft.CodeAnalysis.CSharp;
+using NetDaemon.HassModel.CodeGenerator.CodeGeneration;
 using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;
 
 namespace NetDaemon.HassModel.CodeGenerator;
@@ -11,11 +12,12 @@ public static IEnumerable<MemberDeclarationSyntax> GenerateTypes(
     {
         var orderedServiceDomains = services.OrderBy(x => x.Domain).ToArray();
 
+        var helpers = HelpersGenerator.Generate(domains, orderedServiceDomains);
         var entityClasses = EntitiesGenerator.Generate(domains);
         var serviceClasses = ServicesGenerator.Generate(orderedServiceDomains);
         var extensionMethodClasses = ExtensionMethodsGenerator.Generate(orderedServiceDomains, domains);
 
-        return new[] { entityClasses, serviceClasses, extensionMethodClasses }.SelectMany(x => x).ToList();
+        return new[] {helpers, entityClasses, serviceClasses, extensionMethodClasses }.SelectMany(x => x).ToArray();
     }
 
     public static CompilationUnitSyntax BuildCompilationUnit(string namespaceName, params MemberDeclarationSyntax[] generatedTypes)

src/HassModel/NetDaemon.HassModel.CodeGenerator/CodeGeneration/HelpersGenerator.cs

@@ -0,0 +1,71 @@
+using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;
+using static Microsoft.CodeAnalysis.CSharp.SyntaxKind;
+
+namespace NetDaemon.HassModel.CodeGenerator.CodeGeneration;
+
+internal static class HelpersGenerator
+{
+    public static IEnumerable<MemberDeclarationSyntax> Generate(IReadOnlyCollection<EntityDomainMetadata> domains, IEnumerable<HassServiceDomain> orderedServiceDomains)
+    {
+        var extensionClass = GenerateServiceCollectionExtension(domains, orderedServiceDomains);
+        return new[] { extensionClass };
+    }
+
+    /// <summary>
+    /// Generates the ServiceCollectionExtensions class
+    /// </summary>
+    /// public static class GeneratedExtensions
+    /// {
+    ///    ...
+    /// }
+    private static ClassDeclarationSyntax GenerateServiceCollectionExtension(IReadOnlyCollection<EntityDomainMetadata> domains, IEnumerable<HassServiceDomain> orderedServiceDomains)
+    {
+        return
+            ClassDeclaration("GeneratedExtensions").WithModifiers(TokenList(Token(PublicKeyword), Token(StaticKeyword)))
+                .WithMembers(new SyntaxList<MemberDeclarationSyntax>(new[]
+                    {
+                        BuildAddHomeAssistantGenerated(domains, orderedServiceDomains)
+                    }
+                ));
+    }
+
+    /// <summary>
+    /// Generates the AddHomeAssistantGenerated method
+    /// </summary>
+    //
+    //     public static IServiceCollection AddGeneratedCode(this IServiceCollection serviceCollection)
+    //     {
+    //         serviceCollection.AddTransient<Entities>();
+    //         serviceCollection.AddTransient<AutomationEntities>();
+    //         serviceCollection.AddTransient<BinarySensorEntities>();
+    //         serviceCollection.AddTransient<Services>();
+    //         serviceCollection.AddTransient<AlarmControlPanelServices>();
+    //         return serviceCollection;
+    //    }
+    private static MethodDeclarationSyntax BuildAddHomeAssistantGenerated(IEnumerable<EntityDomainMetadata> domains, IEnumerable<HassServiceDomain> orderedServiceDomains)
+    {
+
+        var injectableTypes = GetInjectableTypes(domains, orderedServiceDomains);
+
+        var statements = injectableTypes.Select(name =>
+            ExpressionStatement(InvocationExpression(
+                MemberAccessExpression(SimpleMemberAccessExpression, IdentifierName("serviceCollection"),
+                    GenericName(Identifier("AddTransient"))
+                        .WithTypeArgumentList(TypeArgumentList(SingletonSeparatedList<TypeSyntax>(IdentifierName(name))))))));
+
+        return MethodDeclaration(IdentifierName("IServiceCollection"), Identifier("AddHomeAssistantGenerated"))
+            .WithModifiers(TokenList(Token(PublicKeyword), Token(StaticKeyword)))
+            .WithParameterList(ParameterList(SingletonSeparatedList(Parameter(Identifier("serviceCollection"))
+                .WithModifiers(TokenList(Token(ThisKeyword))).WithType(IdentifierName("IServiceCollection")))))
+            .WithBody(Block(
+                statements
+                    .Append<StatementSyntax>(ReturnStatement(IdentifierName("serviceCollection")))))
+            .WithSummaryComment("Registers all injectable generated types in the serviceCollection");
+    }
+
+    private static IEnumerable<string> GetInjectableTypes(IEnumerable<EntityDomainMetadata> domains, IEnumerable<HassServiceDomain> orderedServiceDomains) =>
+        domains.Select(d => d.EntitiesForDomainClassName)
+            .Prepend(EntitiesClassName)
+            .Append(ServicesClassName)
+            .Union(orderedServiceDomains.Select(d => GetServicesTypeName(d.Domain)));
+}

src/HassModel/NetDaemon.HassModel.CodeGenerator/CodeGeneration/ServicesGenerator.cs

@@ -43,7 +43,7 @@ private static TypeDeclarationSyntax GenerateRootServicesType(IEnumerable<string
             return ParseProperty(propertyCode).ToPublic();
         }).ToArray();
 
-        return ClassWithInjected<IHaContext>("Services").WithBase((string)"IServices").AddMembers(properties).ToPublic();
+        return ClassWithInjected<IHaContext>(ServicesClassName).WithBase((string)"IServices").AddMembers(properties).ToPublic();
     }
 
     private static TypeDeclarationSyntax GenerateRootServicesInterface(IEnumerable<string> domains)

src/HassModel/NetDaemon.HassModel.CodeGenerator/Helpers/NamingHelper.cs

@@ -5,6 +5,9 @@ namespace NetDaemon.HassModel.CodeGenerator.Helpers;
 
 internal static class NamingHelper
 {
+    public const string EntitiesClassName =  "Entities";
+    public const string ServicesClassName =  "Services";
+
     public static string GetEntitiesForDomainClassName(string prefix)
     {
         var normalizedDomain = prefix.ToNormalizedPascalCase();
@@ -72,6 +75,7 @@ public static string SimplifyTypeName(Type type)
     {
         "System",
         "System.Collections.Generic",
+        "Microsoft.Extensions.DependencyInjection",
         typeof(JsonPropertyNameAttribute).Namespace!,
         typeof(IHaContext).Namespace!,
         typeof(Entity).Namespace!,