Merge branch 'v7' into master

kai-melchior · kai-melchior · commit 09a17de31c75 · 2021-12-12T10:18:03.000+01:00
diff --git a/Angular/Writers/AngularServiceWriter.cs b/Angular/Writers/AngularServiceWriter.cs
@@ -108,8 +108,18 @@ public virtual void Write(AngularWriteConfiguration configuration)
                     TypeTransferObject returnModelType = isEnumerable ? action.ReturnType.Generics.First().Type : action.ReturnType;
                     ModelTransferObject returnModel = returnModelType as ModelTransferObject ?? this.transferObjects.OfType<ModelTransferObject>().FirstOrDefault(x => x.Equals(returnModelType));
                     this.AddUsing(action.ReturnType, classTemplate, controllerOptions, relativeModelPath);
+                    TypeTemplate aliasType = null;
+                    if (returnType.Name == "unknown")
+                    {
+                        aliasType = Code.Type("TDefault");
+                        returnType = aliasType;
+                    }
                     MethodTemplate methodTemplate = classTemplate.AddMethod(action.Name, Code.Generic("Observable", returnType))
                                                                  .FormatName(controllerOptions);
+                    if (aliasType != null)
+                    {
+                        methodTemplate.WithGeneric(aliasType.Name, Code.Type("unknown"));
+                    }
                     TypeTemplate subjectType = Code.Generic("Subject", returnType);
                     methodTemplate.WithCode(Code.Declare(subjectType, subjectName, Code.New(subjectType)));
                     foreach (HttpServiceActionParameterTransferObject parameter in action.Parameters)
diff --git a/Common/Languages/BaseLanguage.cs b/Common/Languages/BaseLanguage.cs
@@ -60,6 +60,7 @@ protected BaseLanguage(IDependencyResolver resolver)
             this.AddWriter<LocalVariableTemplate, LocalVariableWriter>();
             this.AddWriter<MethodTemplate, MethodWriter>();
             this.AddWriter<ExtensionMethodTemplate, MethodWriter>();
+            this.AddWriter<MethodGenericTemplate, MethodGenericWriter>();
             this.AddWriter<MultilineCodeFragment, MultilineCodeFragmentWriter>();
             this.AddWriter<NamespaceTemplate, NamespaceWriter>();
             this.AddWriter<NewTemplate, NewWriter>();
diff --git a/Common/Templates/Extensions/MethodTemplateExtension.cs b/Common/Templates/Extensions/MethodTemplateExtension.cs
@@ -35,6 +35,12 @@ public static MethodTemplate Override(this MethodTemplate methodTemplate, bool v
             return methodTemplate;
         }
 
+        public static MethodTemplate WithGeneric(this MethodTemplate methodTemplate, string alias, TypeTemplate defaultType = null)
+        {
+            methodTemplate.Generics.Add(new MethodGenericTemplate(alias, defaultType));
+            return methodTemplate;
+        }
+
         public static ParameterTemplate AddParameter(this MethodTemplate methodTemplate, TypeTemplate type, string name, ICodeFragment defaultValue = null)
         {
             var parameter = new ParameterTemplate(type, name, defaultValue);
diff --git a/Common/Templates/Structural/MethodGenericTemplate.cs b/Common/Templates/Structural/MethodGenericTemplate.cs
@@ -0,0 +1,14 @@
+namespace KY.Generator.Templates
+{
+    public class MethodGenericTemplate : ICodeFragment
+    {
+        public string Alias { get; set; }
+        public TypeTemplate DefaultType { get; set; }
+
+        public MethodGenericTemplate(string alias, TypeTemplate defaultType = null)
+        {
+            this.Alias = alias;
+            this.DefaultType = defaultType;
+        }
+    }
+}
diff --git a/Common/Templates/Structural/MethodTemplate.cs b/Common/Templates/Structural/MethodTemplate.cs
@@ -16,6 +16,7 @@ public class MethodTemplate : AttributeableTempalte
         public MultilineCodeFragment Code { get; }
         public ClassTemplate Class { get; }
         public CommentTemplate Comment { get; set; }
+        public List<MethodGenericTemplate> Generics { get; set; }
 
         public MethodTemplate(ClassTemplate classTemplate, string name, TypeTemplate type)
         {
@@ -25,6 +26,7 @@ public MethodTemplate(ClassTemplate classTemplate, string name, TypeTemplate typ
             this.Visibility = Visibility.Public;
             this.Parameters = new List<ParameterTemplate>();
             this.Code = new MultilineCodeFragment();
+            this.Generics = new List<MethodGenericTemplate>();
         }
     }
-}
+}
diff --git a/Common/Writers/MethodGenericWriter.cs b/Common/Writers/MethodGenericWriter.cs
@@ -0,0 +1,15 @@
+using KY.Generator.Output;
+using KY.Generator.Templates;
+
+namespace KY.Generator.Writers
+{
+    public class MethodGenericWriter : ITemplateWriter
+    {
+        public void Write(ICodeFragment fragment, IOutputCache output)
+        {
+            MethodGenericTemplate template = (MethodGenericTemplate)fragment;
+            output.Add(template.Alias)
+                  .If(template.DefaultType != null).Add(" = ").Add(template.DefaultType).EndIf();
+        }
+    }
+}
diff --git a/Common/Writers/MethodWriter.cs b/Common/Writers/MethodWriter.cs
@@ -1,4 +1,5 @@
-﻿using System.Linq;
+﻿using System;
+using System.Linq;
 using KY.Generator.Output;
 using KY.Generator.Templates;
 
@@ -9,13 +10,18 @@ public class MethodWriter : ITemplateWriter
         public virtual void Write(ICodeFragment fragment, IOutputCache output)
         {
             MethodTemplate template = (MethodTemplate)fragment;
+            if (template.Generics != null && template.Generics.Any(x => x.DefaultType != null))
+            {
+                throw new InvalidOperationException($"This language does not support default types for generic methods. {template.Class.Name}.{template.Name}");
+            }
             output.Add(template.Comment)
                   .Add(template.Attributes)
                   .Add(template.Visibility.ToString().ToLower()).Add(" ")
                   .If(template.IsStatic).Add("static ").EndIf()
                   .If(template.IsOverride).Add("override ").EndIf()
                   .If(template.Type != null).Add(template.Type).Add(" ").EndIf()
                   .Add(template.Name)
+                  .If(template.Generics != null && template.Generics.Count > 0).Add("<").Add(template.Generics, ", ").Add(">").EndIf()
                   .Add("(")
                   .If(template is ExtensionMethodTemplate).Add("this ").EndIf()
                   .Add(template.Parameters.OrderBy(x => x.DefaultValue == null ? 0 : 1), ", ")
@@ -29,4 +35,4 @@ public virtual void Write(ICodeFragment fragment, IOutputCache output)
         protected virtual void BeforeBlock(ICodeFragment fragment, IOutputCache output)
         { }
     }
-}
+}
diff --git a/EntityFramework/KY.Generator.EntityFramework.csproj b/EntityFramework/KY.Generator.EntityFramework.csproj
@@ -5,7 +5,7 @@
     <Authors>KY-Programming</Authors>
     <Company>KY-Programming</Company>
     <Product>KY.Generator</Product>
-    <Version>7.5.0</Version>
+    <Version>7.6.0</Version>
     <Copyright>2021 - KY-Programming</Copyright>
     <Description>EntityFramework Module for KY-Generator
 Download KY.Generator to use this module</Description>
diff --git a/OData/KY.Generator.OData.csproj b/OData/KY.Generator.OData.csproj
@@ -4,7 +4,7 @@
     <TargetFramework>netstandard2.0</TargetFramework>
     <Company>KY-Programming</Company>
     <Authors>KY-Programming</Authors>
-    <Version>7.5.0</Version>
+    <Version>7.6.0</Version>
     <Product>KY.Generator</Product>
     <Description>oData Module for KY-Generator
 Download KY.Generator to use this module</Description>
diff --git a/OpenApi/KY.Generator.OpenApi.csproj b/OpenApi/KY.Generator.OpenApi.csproj
@@ -4,7 +4,7 @@
     <TargetFramework>netstandard2.0</TargetFramework>
     <Company>KY-Programming</Company>
     <Authors>KY-Programming</Authors>
-    <Version>7.5.0</Version>
+    <Version>7.6.0</Version>
     <Product>KY.Generator</Product>
     <Description>OpenApi Module for KY-Generator
 Download KY.Generator to use this module</Description>
diff --git a/Tests/WebApiController/ClientApp/src/app/edge-cases/components/edge-cases.component.html b/Tests/WebApiController/ClientApp/src/app/edge-cases/components/edge-cases.component.html
@@ -13,3 +13,9 @@
   <button (click)="withHeader()">With Header</button>
   <span>{{headerResult}}</span>
 </div>
+
+<div>
+  <input [(ngModel)]="unknownValue">
+  <button (click)="getUnknown()">Get Unknown</button>
+  <span>{{unknownResult}}</span>
+</div>
diff --git a/Tests/WebApiController/ClientApp/src/app/edge-cases/components/edge-cases.component.ts b/Tests/WebApiController/ClientApp/src/app/edge-cases/components/edge-cases.component.ts
@@ -11,6 +11,8 @@ export class EdgeCasesComponent implements OnInit {
   public guid: string;
   public headerValue: string;
   public headerResult: string;
+  public unknownValue: string;
+  public unknownResult: unknown;
 
   constructor(
     private readonly service: EdgeCasesService
@@ -35,4 +37,9 @@ export class EdgeCasesComponent implements OnInit {
     const httpOptions = { headers: { 'headerValue': this.headerValue || '' } };
     this.service.fromHeader(value, httpOptions).subscribe(result => this.headerResult = result, error => this.headerResult = error.message);
   }
+
+  public getUnknown(): void {
+    this.unknownResult = 'Loading...';
+    this.service.unknownResult(this.unknownValue).subscribe(result => this.unknownResult = (result as {value: string}).value);
+  }
 }
diff --git a/Tests/WebApiController/Controllers/EdgeCasesController.cs b/Tests/WebApiController/Controllers/EdgeCasesController.cs
@@ -111,8 +111,24 @@ public string GetWithAbsoluteRouteAndParameter(int id)
         {
             return "works " + id;
         }
+
+        [HttpGet("[action]")]
+        public object UnknownResult(string value)
+        {
+            return new UnknownResult(value);
+        }
     }
 
     public class ExclusiveGenericComplexResult
     { }
+
+    class UnknownResult
+    {
+        public string Value { get; }
+
+        public UnknownResult(string value)
+        {
+            this.Value = value;
+        }
+    }
 }
diff --git a/TypeScript/Writers/TypeScriptMethodWriter.cs b/TypeScript/Writers/TypeScriptMethodWriter.cs
@@ -17,6 +17,7 @@ public virtual void Write(ICodeFragment fragment, IOutputCache output)
                   .If(template.IsStatic).Add("static ").EndIf()
                   .If(template.IsOverride).Add("override ").EndIf()
                   .Add(template.Name)
+                  .If(template.Generics != null && template.Generics.Count > 0).Add("<").Add(template.Generics, ", ").Add(">").EndIf()
                   .Add("(")
                   .Add(template.Parameters.OrderBy(x => x.DefaultValue == null ? 0 : 1), ", ")
                   .Add(")")
@@ -26,4 +27,4 @@ public virtual void Write(ICodeFragment fragment, IOutputCache output)
                   .EndBlock();
         }
     }
-}
+}

Original file line number	Diff line number	Diff line change
`@@ -35,6 +35,12 @@ public static MethodTemplate Override(this MethodTemplate methodTemplate, bool v`
`35`	`35`	`return methodTemplate;`
`36`	`36`	`}`
`37`	`37`
	`38`	`+ public static MethodTemplate WithGeneric(this MethodTemplate methodTemplate, string alias, TypeTemplate defaultType = null)`
	`39`	`+ {`
	`40`	`+ methodTemplate.Generics.Add(new MethodGenericTemplate(alias, defaultType));`
	`41`	`+ return methodTemplate;`
	`42`	`+ }`
	`43`	`+`
`38`	`44`	`public static ParameterTemplate AddParameter(this MethodTemplate methodTemplate, TypeTemplate type, string name, ICodeFragment defaultValue = null)`
`39`	`45`	`{`
`40`	`46`	`var parameter = new ParameterTemplate(type, name, defaultValue);`
Original file line number	Diff line number	Diff line change
`@@ -16,6 +16,7 @@ public class MethodTemplate : AttributeableTempalte`
`16`	`16`	`public MultilineCodeFragment Code { get; }`
`17`	`17`	`public ClassTemplate Class { get; }`
`18`	`18`	`public CommentTemplate Comment { get; set; }`
	`19`	`+ public List<MethodGenericTemplate> Generics { get; set; }`
`19`	`20`
`20`	`21`	`public MethodTemplate(ClassTemplate classTemplate, string name, TypeTemplate type)`
`21`	`22`	`{`
`@@ -25,6 +26,7 @@ public MethodTemplate(ClassTemplate classTemplate, string name, TypeTemplate typ`
`25`	`26`	`this.Visibility = Visibility.Public;`
`26`	`27`	`this.Parameters = new List<ParameterTemplate>();`
`27`	`28`	`this.Code = new MultilineCodeFragment();`
	`29`	`+ this.Generics = new List<MethodGenericTemplate>();`
`28`	`30`	`}`
`29`	`31`	`}`
`30`		`-}`
	`32`	`+}`