diff --git a/.vscode/launch.json b/.vscode/launch.json index d7b69c20f5..83660cff84 100644 --- a/.vscode/launch.json +++ b/.vscode/launch.json @@ -56,9 +56,9 @@ "--language", "csharp", "-o", - "C:/Users/vibiret/Desktop/graphjavav4/utilities/src/main/java/graphjavav4/utilities", + "C:/Users/vibiret/Desktop/graphdotnetv4", "-n", - "graphcsharpv4.utilities" ], + "graphdotnetv4" ], "cwd": "${workspaceFolder}/src/kiota", // For more information about the 'console' field, see https://aka.ms/VSCode-CS-LaunchJson-Console "console": "internalConsole", diff --git a/src/kiota.core/PathSegmenters/JavaPathSegementer.cs b/src/kiota.core/PathSegmenters/JavaPathSegementer.cs index 7fb170c216..f7a6313e49 100644 --- a/src/kiota.core/PathSegmenters/JavaPathSegementer.cs +++ b/src/kiota.core/PathSegmenters/JavaPathSegementer.cs @@ -20,7 +20,7 @@ public string GetPath(CodeNamespace currentNamespace, CodeClass currentClass) .Replace(ClientNamespaceName, string.Empty) .TrimStart('.') .Replace('.', Path.DirectorySeparatorChar), - currentClass.Name.ToFirstCharacterLowerCase() + FileSuffix); + currentClass.Name.ToFirstCharacterUpperCase() + FileSuffix); var directoryPath = Path.GetDirectoryName(targetPath); if(!Directory.Exists(directoryPath)) Directory.CreateDirectory(directoryPath); diff --git a/src/kiota.core/Refiners/CSharpRefiner.cs b/src/kiota.core/Refiners/CSharpRefiner.cs index ad2c9ad34c..2a55ba7a20 100644 --- a/src/kiota.core/Refiners/CSharpRefiner.cs +++ b/src/kiota.core/Refiners/CSharpRefiner.cs @@ -7,13 +7,20 @@ public class CSharpRefiner : CommonLanguageRefiner, ILanguageRefiner private static readonly Regex responseHandlerType = new Regex("<(.*),object>"); public override void Refine(CodeNamespace generatedCode) { - generatedCode.AddUsing(new CodeUsing(generatedCode) { Name = "System" }); - generatedCode.AddUsing(new CodeUsing(generatedCode) { Name = "System.Threading.Tasks" }); - generatedCode.AddUsing(new CodeUsing(generatedCode) { Name = "System.Net.Http" }); + AddDefaultImports(generatedCode); AddAsyncSuffix(generatedCode); AddInnerClasses(generatedCode); MakeNativeResponseHandlers(generatedCode); } + private void AddDefaultImports(CodeElement current) { + if(current is CodeClass currentClass) { + currentClass.AddUsing(new CodeUsing(currentClass) { Name = "System" }); + currentClass.AddUsing(new CodeUsing(currentClass) { Name = "System.Threading.Tasks" }); + currentClass.AddUsing(new CodeUsing(currentClass) { Name = "System.Net.Http" }); + } + foreach(var childClass in current.GetChildElements()) + AddDefaultImports(childClass); + } private void MakeNativeResponseHandlers(CodeNamespace generatedCode) { diff --git a/src/kiota.core/Refiners/JavaRefiner.cs b/src/kiota.core/Refiners/JavaRefiner.cs index 04c9194e7e..8f34e3c02c 100644 --- a/src/kiota.core/Refiners/JavaRefiner.cs +++ b/src/kiota.core/Refiners/JavaRefiner.cs @@ -1,12 +1,31 @@ -using System.Linq; +using System.Collections.Generic; +using System.Linq; namespace kiota.core { public class JavaRefiner : CommonLanguageRefiner, ILanguageRefiner { + private readonly HashSet defaultTypes = new HashSet {"string", "integer", "boolean", "array", "object", "java.util.function.Function"}; public override void Refine(CodeNamespace generatedCode) { + PatchResponseHandlerType(generatedCode); AddInnerClasses(generatedCode); MakeQueryStringParametersNonOptionalAndInsertOverrideMethod(generatedCode); + AddRelativeImports(generatedCode); + } + private void AddRelativeImports(CodeElement current) { + if(current is CodeClass currentClass) { + var additionalUsings = current + .GetChildElements() + .OfType() + .Select(x =>x.Type) + .Union(current.GetChildElements().OfType().Select(x => x.ReturnType)) + .Where(x => !defaultTypes.Contains(x.Name)) + .Select(x => new CodeUsing(currentClass){Name = x.Name, Declaration = x}); + if(additionalUsings.Any()) + currentClass.AddUsing(additionalUsings.ToArray()); + } + foreach(var childClass in current.GetChildElements()) + AddRelativeImports(childClass); } private void MakeQueryStringParametersNonOptionalAndInsertOverrideMethod(CodeElement currentElement) { var codeMethods = currentElement @@ -35,5 +54,17 @@ private CodeMethod GetMethodClone(CodeMethod currentMethod) { } else return null; } + private void PatchResponseHandlerType(CodeElement current) { + var properties = current.GetChildElements() + .OfType(); + properties + .Where(x => x.PropertyKind == CodePropertyKind.ResponseHandler) + .ToList() + .ForEach(x => x.Type.Name = "java.util.function.Function"); + current.GetChildElements() + .Except(properties) + .ToList() + .ForEach(x => PatchResponseHandlerType(x)); + } } } diff --git a/src/kiota.core/Refiners/TypeScriptRefiner.cs b/src/kiota.core/Refiners/TypeScriptRefiner.cs index d62afc54d3..0312fa333f 100644 --- a/src/kiota.core/Refiners/TypeScriptRefiner.cs +++ b/src/kiota.core/Refiners/TypeScriptRefiner.cs @@ -4,9 +4,10 @@ namespace kiota.core { public class TypeScriptRefiner : ILanguageRefiner { - private readonly HashSet defaultTypes = new HashSet {"string", "integer", "boolean", "array", "object"}; + private readonly HashSet defaultTypes = new HashSet {"string", "integer", "boolean", "array", "object", "(input: object) => object"}; public void Refine(CodeNamespace generatedCode) { + PatchResponseHandlerType(generatedCode); AddRelativeImports(generatedCode); } private void AddRelativeImports(CodeElement current) { @@ -24,5 +25,17 @@ private void AddRelativeImports(CodeElement current) { foreach(var childClass in current.GetChildElements()) AddRelativeImports(childClass); } + private void PatchResponseHandlerType(CodeElement current) { + var properties = current.GetChildElements() + .OfType(); + properties + .Where(x => x.PropertyKind == CodePropertyKind.ResponseHandler) + .ToList() + .ForEach(x => x.Type.Name = "(input: object) => object"); + current.GetChildElements() + .Except(properties) + .ToList() + .ForEach(x => PatchResponseHandlerType(x)); + } } } diff --git a/src/kiota.core/Writers/CSharpWriter.cs b/src/kiota.core/Writers/CSharpWriter.cs index 0794276680..8e974dffda 100644 --- a/src/kiota.core/Writers/CSharpWriter.cs +++ b/src/kiota.core/Writers/CSharpWriter.cs @@ -88,14 +88,11 @@ public override string TranslateType(string typeName, OpenApiSchema schema) { switch (typeName) { - case "integer": typeName = "int"; break; + case "integer": return "int"; case "boolean": return "bool"; - case "array": - typeName = TranslateType(schema.Items.Type, schema.Items) + "[]"; - break; + case "array": return TranslateType(schema.Items.Type, schema.Items) + "[]"; + default: return typeName ?? "object"; } - - return typeName; } public override string GetParameterSignature(CodeParameter parameter) diff --git a/src/kiota.core/Writers/JavaWriter.cs b/src/kiota.core/Writers/JavaWriter.cs index eb33b3ba07..12eb6615a6 100644 --- a/src/kiota.core/Writers/JavaWriter.cs +++ b/src/kiota.core/Writers/JavaWriter.cs @@ -41,9 +41,8 @@ public override string TranslateType(string typeName, OpenApiSchema schema) case "string": return "String"; case "object": return "Object"; case "array": return $"{TranslateType(schema.Items.Type, schema.Items)}[]"; + default: return typeName ?? "Object"; } - - return typeName; } public override void WriteCodeClassDeclaration(CodeClass.Declaration code) @@ -51,13 +50,14 @@ public override void WriteCodeClassDeclaration(CodeClass.Declaration code) if(code?.Parent?.Parent is CodeNamespace) { WriteLine($"package {code.Parent.Parent.Name};"); WriteLine(); - foreach (var codeUsing in code.Usings) - { - WriteLine($"import {codeUsing.Name}.*;"); - } + code.Usings + .Select(x => $"import {x.Declaration?.TypeDefinition?.GetImmediateParentOfType()?.Name ?? code.Parent.Parent.Name}.{x.Name.ToFirstCharacterUpperCase()};") + .Distinct() + .ToList() + .ForEach(x => WriteLine(x)); } //TODO: missing javadoc - WriteLine($"public class {code.Name} {{"); + WriteLine($"public class {code.Name.ToFirstCharacterUpperCase()} {{"); IncreaseIndent(); } @@ -85,7 +85,7 @@ public override void WriteMethod(CodeMethod code) { //TODO javadoc WriteLine("@javax.annotation.Nonnull"); - WriteLine($"public java.util.concurrent.Future<{GetTypeString(code.ReturnType)}> {code.Name.ToFirstCharacterLowerCase()}({string.Join(',', code.Parameters.Select(p=> GetParameterSignature(p)).ToList())}) {{ return null; }}"); + WriteLine($"public java.util.concurrent.Future<{GetTypeString(code.ReturnType).ToFirstCharacterUpperCase()}> {code.Name.ToFirstCharacterLowerCase()}({string.Join(',', code.Parameters.Select(p=> GetParameterSignature(p)).ToList())}) {{ return null; }}"); } public override void WriteProperty(CodeProperty code) diff --git a/src/kiota.core/Writers/TypeScriptWriter.cs b/src/kiota.core/Writers/TypeScriptWriter.cs index 0215b073c9..5aaccff05b 100644 --- a/src/kiota.core/Writers/TypeScriptWriter.cs +++ b/src/kiota.core/Writers/TypeScriptWriter.cs @@ -53,9 +53,8 @@ public override string TranslateType(string typeName, OpenApiSchema schema) {//TODO we're probably missing a bunch of type mappings case "integer": return "number"; case "array": return $"{TranslateType(schema.Items.Type, schema.Items)}[]"; + default: return typeName ?? "object"; } // string, boolean, object : same casing - - return typeName; } public override void WriteCodeClassDeclaration(CodeClass.Declaration code)