ASP.NET/Angular

ky-one · ky-one · commit dc2eceb86179 · 2021-12-12T09:38:54.000+01:00
- handling of unknown results (e.g. object) improved

Common
 - generic method support added
diff --git a/Angular/Writers/AngularServiceWriter.cs b/Angular/Writers/AngularServiceWriter.cs
@@ -103,8 +103,18 @@ public virtual void Write(AngularWriteConfiguration configuration, List<ITransfe
                     TypeTransferObject returnModelType = isEnumerable ? action.ReturnType.Generics.First().Type : action.ReturnType;
                     ModelTransferObject returnModel = returnModelType as ModelTransferObject ?? transferObjects.OfType<ModelTransferObject>().FirstOrDefault(x => x.Equals(returnModelType));
                     this.AddUsing(action.ReturnType, classTemplate, configuration, 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(configuration);
+                    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)
@@ -269,7 +279,6 @@ public virtual void Write(AngularWriteConfiguration configuration, List<ITransfe
                     {
                         parameters.Add(Code.Local(action.Parameters.Single(x => x.FromBody).Name));
                     }
-                    parameters.AddRange(inlineParameters.Concat(urlDirectParameters).Concat(urlParameters).Select(parameter => Code.Local(parameter.Name)));
                     if (actionTypeOptions[action.Type]?.HasHttpOptions ?? false)
                     {
                         parameters.Add(Code.Local("httpOptions"));
diff --git a/Core/Languages/BaseLanguage.cs b/Core/Languages/BaseLanguage.cs
@@ -70,6 +70,7 @@ protected BaseLanguage()
             this.TemplateWriters.Add(typeof(LocalVariableTemplate), new LocalVariableWriter());
             this.TemplateWriters.Add(typeof(MethodTemplate), new MethodWriter());
             this.TemplateWriters.Add(typeof(ExtensionMethodTemplate), new MethodWriter());
+            this.TemplateWriters.Add(typeof(MethodGenericTemplate), new MethodGenericWriter());
             this.TemplateWriters.Add(typeof(MultilineCodeFragment), new MultilineCodeFragmentWriter(this));
             this.TemplateWriters.Add(typeof(NamespaceTemplate), new NamespaceWriter(this));
             this.TemplateWriters.Add(typeof(NewTemplate), new NewWriter());
diff --git a/Core/Templates/Extensions/MethodTemplateExtension.cs b/Core/Templates/Extensions/MethodTemplateExtension.cs
@@ -38,6 +38,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);
@@ -87,4 +93,4 @@ public static MethodTemplate FormatName(this MethodTemplate methodTemplate, ILan
             return methodTemplate;
         }
     }
-}
+}
diff --git a/Core/Templates/Structural/MethodGenericTemplate.cs b/Core/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/Core/Templates/Structural/MethodTemplate.cs b/Core/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/Core/Writers/MethodGenericWriter.cs b/Core/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/Core/Writers/MethodWriter.cs b/Core/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/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/ClientApp/src/app/edge-cases/services/edge-cases.service.ts b/Tests/WebApiController/ClientApp/src/app/edge-cases/services/edge-cases.service.ts
@@ -130,6 +130,15 @@ export class EdgeCasesService {
         return subject;
     }
 
+    public unknownResult<TDefault = unknown>(value: string, httpOptions?: {}): Observable<TDefault> {
+        let subject = new Subject<TDefault>();
+        this.http.get<TDefault>(this.serviceUrl + "/edgecases/unknownresult" + "?value=" + this.convertAny(value), httpOptions).subscribe((result) => {
+            subject.next(result);
+            subject.complete();
+        }, (error) => subject.error(error));
+        return subject;
+    }
+
     public convertAny(value: any): string {
         return value === null || value === undefined ? "" : value.toString();
     }
diff --git a/Tests/WebApiController/Controllers/EdgeCasesController.cs b/Tests/WebApiController/Controllers/EdgeCasesController.cs
@@ -76,8 +76,24 @@ public GenericResult<ExclusiveGenericComplexResult> GenericComplexResult()
         {
             return new GenericResult<ExclusiveGenericComplexResult>(new List<ExclusiveGenericComplexResult> { new ExclusiveGenericComplexResult() });
         }
+
+        [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
`@@ -38,6 +38,12 @@ public static MethodTemplate Override(this MethodTemplate methodTemplate, bool v`
`38`	`38`	`return methodTemplate;`
`39`	`39`	`}`
`40`	`40`
	`41`	`+ public static MethodTemplate WithGeneric(this MethodTemplate methodTemplate, string alias, TypeTemplate defaultType = null)`
	`42`	`+ {`
	`43`	`+ methodTemplate.Generics.Add(new MethodGenericTemplate(alias, defaultType));`
	`44`	`+ return methodTemplate;`
	`45`	`+ }`
	`46`	`+`
`41`	`47`	`public static ParameterTemplate AddParameter(this MethodTemplate methodTemplate, TypeTemplate type, string name, ICodeFragment defaultValue = null)`
`42`	`48`	`{`
`43`	`49`	`var parameter = new ParameterTemplate(type, name, defaultValue);`
`@@ -87,4 +93,4 @@ public static MethodTemplate FormatName(this MethodTemplate methodTemplate, ILan`
`87`	`93`	`return methodTemplate;`
`88`	`94`	`}`
`89`	`95`	`}`
`90`		`-}`
	`96`	`+}`
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`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -76,8 +76,24 @@ public GenericResult<ExclusiveGenericComplexResult> GenericComplexResult()`
`76`	`76`	`{`
`77`	`77`	`return new GenericResult<ExclusiveGenericComplexResult>(new List<ExclusiveGenericComplexResult> { new ExclusiveGenericComplexResult() });`
`78`	`78`	`}`
	`79`	`+`
	`80`	`+ [HttpGet("[action]")]`
	`81`	`+ public object UnknownResult(string value)`
	`82`	`+ {`
	`83`	`+ return new UnknownResult(value);`
	`84`	`+ }`
`79`	`85`	`}`
`80`	`86`
`81`	`87`	`public class ExclusiveGenericComplexResult`
`82`	`88`	`{ }`
	`89`	`+`
	`90`	`+ class UnknownResult`
	`91`	`+ {`
	`92`	`+ public string Value { get; }`
	`93`	`+`
	`94`	`+ public UnknownResult(string value)`
	`95`	`+ {`
	`96`	`+ this.Value = value;`
	`97`	`+ }`
	`98`	`+ }`
`83`	`99`	`}`
Original file line number	Diff line number	Diff line change
`@@ -17,6 +17,7 @@ public virtual void Write(ICodeFragment fragment, IOutputCache output)`
`17`	`17`	`.If(template.IsStatic).Add("static ").EndIf()`
`18`	`18`	`.If(template.IsOverride).Add("override ").EndIf()`
`19`	`19`	`.Add(template.Name)`
	`20`	`+ .If(template.Generics != null && template.Generics.Count > 0).Add("<").Add(template.Generics, ", ").Add(">").EndIf()`
`20`	`21`	`.Add("(")`
`21`	`22`	`.Add(template.Parameters.OrderBy(x => x.DefaultValue == null ? 0 : 1), ", ")`
`22`	`23`	`.Add(")")`
`@@ -26,4 +27,4 @@ public virtual void Write(ICodeFragment fragment, IOutputCache output)`
`26`	`27`	`.EndBlock();`
`27`	`28`	`}`
`28`	`29`	`}`
`29`		`-}`
	`30`	`+}`