Fix code generation that has been broken in previous simplification refactoring

Author: C0nquistadore

src/Dibix.Sdk.CodeGeneration/Lookup/UserDefinedTypeSchemaTypeResolver.cs

@@ -24,6 +24,7 @@ public override TypeReference ResolveType(string input, string relativeNamespace
             if (!_schemaAccessor.Value.TryGetValue(input, out UserDefinedTypeSchema schema)) 
                 return null;
 
+            schema.ReferenceCount++;
             SchemaTypeReference schemaTypeReference = new SchemaTypeReference(schema.FullName, isNullable: false, isEnumerable: false, location);
             return schemaTypeReference;
         }

src/Dibix.Sdk.CodeGeneration/Model/SchemaDefinition.cs

@@ -10,6 +10,7 @@ public abstract class SchemaDefinition
         public SourceLocation Location { get; }
         public ExternalSchemaInfo ExternalSchemaInfo { get; set; }
         public string FullName => $"{Namespace}.{DefinitionName}";
+        public int ReferenceCount { get; set; }
 
         protected SchemaDefinition(string @namespace, string definitionName, SchemaDefinitionSource source, SourceLocation location)
         {

src/Dibix.Sdk.CodeGeneration/Model/SchemaExtensions.cs

@@ -1,4 +1,6 @@
-using System.Linq;
+using System;
+using System.Collections.Generic;
+using System.Linq;
 using Dibix.Sdk.Abstractions;
 
 namespace Dibix.Sdk.CodeGeneration
@@ -27,5 +29,26 @@ public static EnumSchemaMember GetEnumMember(this EnumMemberStringReference refe
             logger.LogError($"Enum '{schema.FullName}' does not define a member named '{reference.Value}'", reference.Location.Source, reference.Location.Line, reference.Location.Column);
             return null;
         }
+
+        public static IEnumerable<SchemaDefinition> GetSchemas(this CodeGenerationModel model, CodeGenerationOutputFilter filter)
+        {
+            bool MatchesOutputFilter(SchemaDefinition schema)
+            {
+                switch (filter)
+                {
+                    case CodeGenerationOutputFilter.Local:
+                        return SchemaDefinitionSource.Local.HasFlag(schema.Source);
+
+                    case CodeGenerationOutputFilter.Referenced:
+                        return (SchemaDefinitionSource.Local | SchemaDefinitionSource.Foreign).HasFlag(schema.Source) && schema.ReferenceCount > 0;
+
+                    default:
+                        throw new ArgumentOutOfRangeException(nameof(filter), filter, null);
+                }
+            }
+
+            IEnumerable<SchemaDefinition> schemas = model.Schemas.Where(MatchesOutputFilter);
+            return schemas;
+        }
     }
 }

src/Dibix.Sdk.CodeGeneration/Output/ApiClientImplementationWriter.cs

@@ -51,13 +51,14 @@ protected override void WriteController(CodeGenerationContext context, CSharpSta
 
             @class.AddSeparator();
 
-            for (int i = 0; i < controller.Actions.Count; i++)
+            IList<ActionDefinition> actions = controller.Actions.OrderBy(x => operationIdMap[x]).ToArray();
+            for (int i = 0; i < actions.Count; i++)
             {
-                ActionDefinition action = controller.Actions[i];
-                string body = this.GenerateMethodBody(controller, action, context, securitySchemeMap);
+                ActionDefinition action = actions[i];
+                string body = GenerateMethodBody(controller, action, context, securitySchemeMap);
                 base.AddMethod(action, context, operationIdMap, (methodName, returnType) => @class.AddMethod(methodName, returnType, body, modifiers: CSharpModifiers.Public | CSharpModifiers.Async));
 
-                if (i + 1 < controller.Actions.Count)
+                if (i + 1 < actions.Count)
                     @class.AddSeparator();
             }
         }
@@ -66,16 +67,16 @@ protected override void WriteController(CodeGenerationContext context, CSharpSta
         #region Private Methods
         private static void AddPrimaryCtor(CSharpClass @class, bool requiresAuthorization)
         {
-            StringBuilder ctorBodySb = new StringBuilder("this._httpClientFactory = httpClientFactory;");
+            StringBuilder ctorBodySb = new StringBuilder("_httpClientFactory = httpClientFactory;");
 
             if (requiresAuthorization)
             {
                 ctorBodySb.AppendLine()
-                          .Append("this._httpAuthorizationProvider = httpAuthorizationProvider;");
+                          .Append("_httpAuthorizationProvider = httpAuthorizationProvider;");
             }
 
             ctorBodySb.AppendLine()
-                      .Append("this._httpClientName = httpClientName;");
+                      .Append("_httpClientName = httpClientName;");
 
             string ctorBody = ctorBodySb.ToString();
             CSharpConstructor ctor = @class.AddConstructor(ctorBody)
@@ -111,7 +112,7 @@ private string GenerateMethodBody(ControllerDefinition controller, ActionDefinit
                                                                     .ToArray();
 
             StringWriter writer = new StringWriter();
-            writer.WriteLine($"using ({nameof(HttpClient)} client = this._httpClientFactory.CreateClient(this._httpClientName, BaseAddress))")
+            writer.WriteLine($"using ({nameof(HttpClient)} client = _httpClientFactory.CreateClient(_httpClientName, BaseAddress))")
                   .WriteLine("{")
                   .PushIndent();
 
@@ -147,7 +148,7 @@ private string GenerateMethodBody(ControllerDefinition controller, ActionDefinit
             foreach (SecuritySchemeRequirement securitySchemeRequirement in action.SecuritySchemes.Requirements.Where(x => x.Scheme != SecuritySchemes.Anonymous))
             {
                 string securitySchemeName = securitySchemeRequirement.Scheme.Name;
-                string getAuthorizationValueCall = $"this._httpAuthorizationProvider.GetValue(\"{securitySchemeName}\")";
+                string getAuthorizationValueCall = $"_httpAuthorizationProvider.GetValue(\"{securitySchemeName}\")";
                 if (oneOf)
                 {
                     writer.WriteLine($"if ({getAuthorizationValueCall} != null)")

src/Dibix.Sdk.CodeGeneration/Output/ApiClientInterfaceWriter.cs

@@ -1,4 +1,5 @@
 using System.Collections.Generic;
+using System.Linq;
 using Dibix.Sdk.CodeGeneration.CSharp;
 
 namespace Dibix.Sdk.CodeGeneration
@@ -16,9 +17,9 @@ protected override void WriteController(CodeGenerationContext context, CSharpSta
             CSharpInterface @interface = output.AddInterface(interfaceName, CSharpModifiers.Public)
                                                .Implements("IHttpService");
 
-            foreach (ActionDefinition action in controller.Actions)
+            foreach (ActionDefinition action in controller.Actions.OrderBy(x => operationIdMap[x]))
             {
-                base.AddMethod(action, context, operationIdMap, (methodName, returnType) => @interface.AddMethod(methodName, returnType));
+                base.AddMethod(action, context, operationIdMap, @interface.AddMethod);
             }
         }
         #endregion

src/Dibix.Sdk.CodeGeneration/Output/ApiClientWriter.cs

@@ -26,6 +26,7 @@ public override void Write(CodeGenerationContext context)
             IList<ControllerDefinition> controllers = context.Model
                                                              .Controllers
                                                              .Where(x => x.Actions.Any())
+                                                             .OrderBy(x => x.Name)
                                                              .ToArray();
 
             IDictionary<ActionDefinition, string> operationIdMap = controllers.SelectMany(x => x.Actions)
@@ -46,7 +47,7 @@ public override void Write(CodeGenerationContext context)
             {
                 ControllerDefinition controller = controllers[i];
                 string serviceName = $"{controller.Name}Service";
-                this.WriteController(context, output, controller, serviceName, operationIdMap, securitySchemeMap);
+                WriteController(context, output, controller, serviceName, operationIdMap, securitySchemeMap);
 
                 if (i + 1 < controllers.Count)
                     output.AddSeparator();

src/Dibix.Sdk.CodeGeneration/Output/ClientContractClassWriter.cs

@@ -5,7 +5,7 @@ namespace Dibix.Sdk.CodeGeneration
 {
     internal sealed class ClientContractClassWriter : ContractClassWriter
     {
-        public ClientContractClassWriter(CodeGenerationModel model) : base(model, schemaFilter: SchemaDefinitionSource.Local | SchemaDefinitionSource.Foreign) { }
+        public ClientContractClassWriter(CodeGenerationModel model) : base(model, outputFilter: CodeGenerationOutputFilter.Referenced) { }
 
         protected override bool ProcessProperty(ObjectSchema schema, ObjectSchemaProperty property, ICollection<CSharpAnnotation> propertyAnnotations, CodeGenerationContext context)
         {

src/Dibix.Sdk.CodeGeneration/Output/CodeGenerationOutputFilter.cs

@@ -0,0 +1,9 @@
+namespace Dibix.Sdk.CodeGeneration
+{
+    internal enum CodeGenerationOutputFilter
+    {
+        None,
+        Local,
+        Referenced
+    }
+}

src/Dibix.Sdk.CodeGeneration/Output/ContractClassWriter.cs

@@ -21,26 +21,27 @@ internal abstract class ContractClassWriter : ArtifactWriterBase
         #endregion
 
         #region Constructor
-        protected ContractClassWriter(CodeGenerationModel model, SchemaDefinitionSource schemaFilter)
+        protected ContractClassWriter(CodeGenerationModel model, CodeGenerationOutputFilter outputFilter)
         {
-            this._schemas = model.Schemas.Where(x => IsValidSchema(x, schemaFilter)).ToArray();
+            _schemas = model.GetSchemas(outputFilter)
+                            .Where(x => x.GetType() == typeof(ObjectSchema) // Equal is important here, since we don't want UserDefinedTypeSchema which inherits from ObjectSchema
+                                     || x is EnumSchema)
+                            .ToArray();
         }
         #endregion
 
         #region Overrides
-        public override bool HasContent(CodeGenerationModel model) => this._schemas.Any();
+        public override bool HasContent(CodeGenerationModel model) => _schemas.Any();
 
         public override void Write(CodeGenerationContext context)
         {
-            var namespaceGroups = this._schemas
-                                      .GroupBy(x => x.Namespace)
-                                      .ToArray();
+            var namespaceGroups = _schemas.GroupBy(x => x.Namespace).OrderBy(x => x.Key).ToArray();
 
             for (int i = 0; i < namespaceGroups.Length; i++)
             {
                 IGrouping<string, SchemaDefinition> namespaceGroup = namespaceGroups[i];
                 CSharpStatementScope scope = /*namespaceGroup.Key != null ? */context.CreateOutputScope(namespaceGroup.Key)/* : context.Output*/;
-                IList<SchemaDefinition> schemas = namespaceGroup.ToArray();
+                IList<SchemaDefinition> schemas = namespaceGroup.OrderBy(x => x.DefinitionName).ToArray();
                 for (int j = 0; j < schemas.Count; j++)
                 {
                     SchemaDefinition schema = schemas[j];
@@ -83,14 +84,14 @@ protected static void AddJsonReference(CodeGenerationContext context)
         private void ProcessObjectSchema(CodeGenerationContext context, CSharpStatementScope scope, ObjectSchema schema)
         {
             ICollection<CSharpAnnotation> classAnnotations = new Collection<CSharpAnnotation>();
-            this.BeginProcessClass(schema, classAnnotations, context);
+            BeginProcessClass(schema, classAnnotations, context);
 
             CSharpClass @class = scope.AddClass(schema.DefinitionName, CSharpModifiers.Public | CSharpModifiers.Sealed, classAnnotations);
             ICollection<string> ctorAssignments = new Collection<string>();
             foreach (ObjectSchemaProperty property in schema.Properties)
             {
                 ICollection<CSharpAnnotation> propertyAnnotations = new Collection<CSharpAnnotation>();
-                if (!this.ProcessProperty(schema, property, propertyAnnotations, context))
+                if (!ProcessProperty(schema, property, propertyAnnotations, context))
                     continue;
 
                 CSharpValue defaultValue = null;
@@ -109,7 +110,7 @@ private void ProcessObjectSchema(CodeGenerationContext context, CSharpStatementS
                       .Initializer(defaultValue);
 
                 if (propertyType.IsEnumerable)
-                    ctorAssignments.Add($"this.{property.Name.Value} = new {nameof(Collection<object>)}<{clrTypeName}>();");
+                    ctorAssignments.Add($"{property.Name.Value} = new {nameof(Collection<object>)}<{clrTypeName}>();");
             }
 
             if (ctorAssignments.Any())
@@ -121,7 +122,7 @@ private void ProcessObjectSchema(CodeGenerationContext context, CSharpStatementS
                       .AddConstructor(String.Join(Environment.NewLine, ctorAssignments));
             }
 
-            this.EndProcessClass(schema, @class, context);
+            EndProcessClass(schema, @class, context);
         }
 
         private static void ProcessEnumSchema(CodeGenerationContext context, CSharpStatementScope scope, EnumSchema schema)
@@ -140,17 +141,6 @@ private static void ProcessEnumSchema(CodeGenerationContext context, CSharpState
                      .Inherits("int");
             }
         }
-
-        private static bool IsValidSchema(SchemaDefinition schema, SchemaDefinitionSource schemaFilter)
-        {
-            if (!schemaFilter.HasFlag(schema.Source))
-                return false;
-
-            if (schema.GetType() == typeof(ObjectSchema) || schema is EnumSchema)
-                return true;
-
-            return false;
-        }
         #endregion
     }
 }

src/Dibix.Sdk.CodeGeneration/Output/DaoContractClassWriter.cs

@@ -8,7 +8,7 @@ namespace Dibix.Sdk.CodeGeneration
 {
     internal sealed class DaoContractClassWriter : ContractClassWriter
     {
-        public DaoContractClassWriter(CodeGenerationModel model, SchemaDefinitionSource schemaFilter) : base(model, schemaFilter) { }
+        public DaoContractClassWriter(CodeGenerationModel model, CodeGenerationOutputFilter outputFilter) : base(model, outputFilter) { }
 
         protected override void BeginProcessClass(ObjectSchema schema, ICollection<CSharpAnnotation> classAnnotations, CodeGenerationContext context)
         {