Added Kind properties for special handling

microsoft · Dec 31, 2020 · 034a601 · 034a601
1 parent c9700db
commit 034a601
Show file tree

Hide file tree

Showing 6 changed files with 36 additions and 12 deletions.
diff --git a/src/kiota.core/CodeDOM/CodeMethod.cs b/src/kiota.core/CodeDOM/CodeMethod.cs
@@ -4,15 +4,23 @@
 
 namespace kiota.core
 {
+    public enum CodeMethodKind
+    {
+        Custom,
+        ResponseHandler
+    }
+
     public class CodeMethod : CodeTerminal, ICloneable
     {
+        public CodeMethodKind MethodKind = CodeMethodKind.Custom;
         public CodeType ReturnType;
         public List<CodeParameter> Parameters = new List<CodeParameter>();
         public bool IsStatic = false;
 
         public object Clone()
         {
             return new CodeMethod {
+                MethodKind = MethodKind,
                 ReturnType = ReturnType.Clone() as CodeType,
                 Parameters = Parameters.Select(x => x.Clone() as CodeParameter).ToList(),
                 Name = Name.Clone() as string,

diff --git a/src/kiota.core/CodeDOM/CodeParameter.cs b/src/kiota.core/CodeDOM/CodeParameter.cs
@@ -2,17 +2,23 @@
 
 namespace kiota.core
 {
+    public enum CodeParameterKind
+    {
+        Custom,
+        QueryParameter
+    }
+
     public class CodeParameter : CodeTerminal, ICloneable
     {
+        public CodeParameterKind ParameterKind = CodeParameterKind.Custom;
         public CodeType Type;
         public bool Optional = false;
-        public bool IsQueryParameter { get; set; }
 
         public object Clone()
         {
             return new CodeParameter{
                 Optional = Optional,
-                IsQueryParameter = IsQueryParameter,
+                ParameterKind = ParameterKind,
                 Name = Name.Clone() as string,
                 Type = Type.Clone() as CodeType,
             };

diff --git a/src/kiota.core/CodeDOM/CodeProperty.cs b/src/kiota.core/CodeDOM/CodeProperty.cs
@@ -1,7 +1,15 @@
 namespace kiota.core
 {
+    public enum CodePropertyKind
+    {
+        Custom,
+        ResponseHandler
+    }
+
     public class CodeProperty : CodeTerminal
     {
+        public CodePropertyKind PropertyKind = CodePropertyKind.Custom;
+
         public override string Name
         {
             get; set;

diff --git a/src/kiota.core/KiotaBuilder.cs b/src/kiota.core/KiotaBuilder.cs
@@ -283,7 +283,7 @@ private CodeMethod CreateOperationMethod(OperationType operationType, OpenApiOpe
                 Name = "q",
                 Type = new CodeType() { Name = parameterClass.Name, ActionOf = true, TypeDefinition = parameterClass },
                 Optional = true,
-                IsQueryParameter = true,
+                ParameterKind = CodeParameterKind.QueryParameter
             };
             method.AddParameter(methodParameter);
             return method;
@@ -388,13 +388,14 @@ private static string FixPathIdentifier(string identifier)
         private void CreateResponseHandler(CodeClass requestBuilder)
         {
             // Default ResponseHandler Implementation
-            var responseHandlerImpl = new CodeMethod { Name = "DefaultResponseHandler", IsStatic = true };
+            var responseHandlerImpl = new CodeMethod { Name = "DefaultResponseHandler", IsStatic = true, MethodKind = CodeMethodKind.ResponseHandler };
             responseHandlerImpl.AddParameter(new CodeParameter { Name = "response", Type = new CodeType { Name = "object" } });  // replace native HTTP response object type in language refiner
             responseHandlerImpl.ReturnType = new CodeType { Name = "object" };
             requestBuilder.AddMethod(responseHandlerImpl);
 
             // Property to allow replacing Response Handler
             var responseHandlerProperty = CreateProperty("ResponseHandler", "Func<object,object>", "DefaultResponseHandler"); // HttpResponseMessage, model
+            responseHandlerProperty.PropertyKind = CodePropertyKind.ResponseHandler;
             responseHandlerProperty.ReadOnly = false;
             requestBuilder.AddProperty(responseHandlerProperty);  
         }

diff --git a/src/kiota.core/Refiners/CSharpRefiner.cs b/src/kiota.core/Refiners/CSharpRefiner.cs
@@ -22,14 +22,15 @@ private void MakeNativeResponseHandlers(CodeNamespace generatedCode)
                 switch (codeElement)
                 {
                     case CodeClass c:
-                        var responseHandlerProp = c.InnerChildElements.OfType<CodeProperty>().Where(e => e.Name == "ResponseHandler")
-                                                                        .OfType<CodeProperty>().FirstOrDefault();
+                        var responseHandlerProp = c.InnerChildElements.OfType<CodeProperty>().Where(e => e.PropertyKind == CodePropertyKind.ResponseHandler)
+                                                                        .FirstOrDefault();
                         if (responseHandlerProp != null)
                         {
                             responseHandlerProp.Type.Name = responseHandlerType.Replace(responseHandlerProp.Type.Name, "<HttpResponseMessage,Task<$1>>"); // TODO: We should probably generic types properly 
                         }
-                        var defaultResponseHandler = c.InnerChildElements.Where(e => e is CodeMethod && e.Name == "DefaultResponseHandler")
-                                                                      .OfType<CodeMethod>().FirstOrDefault();
+                        var defaultResponseHandler = c.InnerChildElements.OfType<CodeMethod>()
+                                                                            .Where(m=> m.MethodKind == CodeMethodKind.ResponseHandler)
+                                                                            .FirstOrDefault();
                         if (defaultResponseHandler != null)
                         {
                             defaultResponseHandler.Parameters.FirstOrDefault().Type.Name = "HttpResponseMessage";

diff --git a/src/kiota.core/Refiners/JavaRefiner.cs b/src/kiota.core/Refiners/JavaRefiner.cs
@@ -1,4 +1,4 @@
-using System.Linq;
+using System.Linq;
 
 namespace kiota.core {
     public class JavaRefiner : CommonLanguageRefiner, ILanguageRefiner
@@ -15,7 +15,7 @@ private void MakeQueryStringParametersNonOptionalAndInsertOverrideMethod(CodeEle
             if(currentElement is CodeClass currentClass && codeMethods.Any()) {
                 codeMethods
                     .SelectMany(x => x.Parameters)
-                    .Where(x => x.IsQueryParameter)
+                    .Where(x => x.ParameterKind == CodeParameterKind.QueryParameter)
                     .ToList()
                     .ForEach(x => x.Optional = false);
                 currentClass.AddMethod(codeMethods
@@ -28,9 +28,9 @@ private void MakeQueryStringParametersNonOptionalAndInsertOverrideMethod(CodeEle
                 MakeQueryStringParametersNonOptionalAndInsertOverrideMethod(childElement);
         }
         private CodeMethod GetMethodClone(CodeMethod currentMethod) {
-            if(currentMethod.Parameters.Any(x => x.IsQueryParameter)) {
+            if(currentMethod.Parameters.Any(x => x.ParameterKind == CodeParameterKind.QueryParameter)) {
                 var cloneMethod = currentMethod.Clone() as CodeMethod;
-                cloneMethod.Parameters.RemoveAll(x => x.IsQueryParameter);
+                cloneMethod.Parameters.RemoveAll(x => x.ParameterKind == CodeParameterKind.QueryParameter);
                 return cloneMethod;
             }
             else return null;