going next swagger

ignatandrei · May 9, 2020 · 9a9526f · 9a9526f
1 parent 6541fce
commit 9a9526f
Show file tree

Hide file tree

Showing 6 changed files with 156 additions and 12 deletions.
diff --git a/src/NetCore2Blockly/NetCore2Blockly/ExtensionMethods/ActionListExtensions.cs b/src/NetCore2Blockly/NetCore2Blockly/ExtensionMethods/ActionListExtensions.cs
@@ -8,7 +8,7 @@ namespace NetCore2Blockly
     /// <summary>
     /// extension to generate types
     /// </summary>
-    public static class ActionListExtensions
+    static class ActionListExtensions
     {
 
 
@@ -17,7 +17,7 @@ public static class ActionListExtensions
         /// </summary>
         /// <param name="list">The list.</param>
         /// <returns></returns>
-        public static TypeArgumentBase[] GetAllTypesWithNullBlocklyType(this List<ActionInfo> list)
+        internal static TypeArgumentBase[] GetAllTypesWithNullBlocklyType(this List<ActionInfo> list)
         {
             return  list
 

diff --git a/src/NetCore2Blockly/NetCore2Blockly/ExtensionMethods/CLIExtension.cs b/src/NetCore2Blockly/NetCore2Blockly/ExtensionMethods/CLIExtension.cs
@@ -49,7 +49,7 @@ public static IApplicationBuilder UseBlocklySwagger(this IApplicationBuilder app
             var blocklyFilesHostedService =app.
     ApplicationServices
     .GetService<GenerateBlocklyFilesHostedService>();
-            blocklyFilesHostedService.AddSwagger(name, endPoint);
+            blocklyFilesHostedService.AddSwagger(name, endPoint).ConfigureAwait(false).GetAwaiter().GetResult();
             return app;
         }
         /// <summary>

diff --git a/src/NetCore2Blockly/NetCore2Blockly/GenerateBlocklyFilesHostedService.cs b/src/NetCore2Blockly/NetCore2Blockly/GenerateBlocklyFilesHostedService.cs
@@ -1,9 +1,13 @@
 using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.Mvc.ApiExplorer;
 using Microsoft.Extensions.Hosting;
+using Microsoft.OpenApi.Extensions;
+using Microsoft.OpenApi.Readers;
+using NetCore2Blockly.Swagger;
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Net.Http;
 using System.Threading;
 using System.Threading.Tasks;
 
@@ -17,14 +21,22 @@ public class GenerateBlocklyFilesHostedService : IHostedService
     {
 
         #region swaggers
-        private Dictionary<string, string> swaggers;
+        private Dictionary<string, List<ActionInfo>> swaggers;
         internal string[] KeySwaggers()
         {
             return swaggers.Select(it => it.Key).ToArray();
         }
         internal string SwaggerBlocklyTypesDefinition(string key)
         {
-            return "";
+
+            var blocklyFileGenerator = new BlocklyFileGenerator(swaggers[key]);
+            return blocklyFileGenerator.GenerateNewBlocklyTypesDefinition();
+            //BlocklyTypesDefinition = blocklyFileGenerator.GenerateNewBlocklyTypesDefinition();
+            //BlocklyAPIFunctions = blocklyFileGenerator.GenerateBlocklyAPIFunctions();
+            //BlocklyToolBoxValueDefinition = blocklyFileGenerator.GenerateBlocklyToolBoxValueDefinitionFile();
+            //BlocklyToolBoxFunctionDefinition = blocklyFileGenerator.GenerateBlocklyToolBoxFunctionDefinitionFile();
+
+
         }
         internal string SwaggersDictionaryJS
         {
@@ -36,9 +48,109 @@ internal string SwaggersDictionaryJS
                 return $@"var dictSwagger=[]; {s}";
             }
         }
-        internal void AddSwagger(string name, string endpoint)
+        async Task<List<ActionInfo>> GenerateFromSwaggerEndPoint(string endpoint)
+        {
+            var uri = new Uri(endpoint);
+            var site = uri.Scheme + "://" + uri.Authority + (uri.IsDefaultPort ? "" : ":" + uri.Port);
+            var httpClient = new HttpClient
+            {
+                BaseAddress = new Uri(site)
+            };
+            using var stream = await httpClient.GetStreamAsync(uri.PathAndQuery);
+            var openApiDocument = new OpenApiStreamReader().Read(stream, out var diagnostic);
+            var comp = openApiDocument.Components;
+
+            var types = new AllTypes();
+            foreach (var schema in comp.Schemas)
+            {
+
+                var t = new TypeToGenerateSwagger(schema);
+                t.Site = site;
+                types.Add(t);
+            }
+            var functions = openApiDocument.Paths;
+            var actions = new List<ActionInfo>();
+            foreach (var f in functions)
+            {
+                var val = f.Value;
+                foreach (var op in val.Operations)
+                {
+                    var val1 = op.Value;
+                    var act = new ActionInfoSwagger();
+                    actions.Add(act);
+                    act.Site = site;
+                    act.RelativeRequestUrl = f.Key;
+                    act.Verb = op.Key.GetDisplayName();
+                    if (val1.Tags?.Count > 0)
+                    {
+                        act.ControllerName = val1.Tags.First().Name;
+                    }
+                    else
+                    {
+                        act.ControllerName = ActionInfoSwagger.GenerateControllerName(act.RelativeRequestUrl);
+                    }
+                    foreach (var par in val1.Parameters)
+                    {
+                        var name = par.Name;
+                        var s = par.In;//path , query
+                        var schema = par.Schema;
+                        TypeArgumentBase myType = null;
+                        if (schema.Type != null)
+                        {
+                            myType = types.FindAfterId(schema.Type);
+                        }
+                        if (schema.Reference != null)
+                        {
+                            var id = schema.Reference.ReferenceV2 + "_" + schema.Reference.ReferenceV3;
+                            myType = types.FindAfterId(id);
+
+                        }
+                        var bs = BindingSourceDefinition.None;
+                        switch (par.In.GetDisplayName().ToLower())
+                        {
+                            case "path":
+                                bs = BindingSourceDefinition.Path;
+                                break;
+                            case "query":
+                                bs = BindingSourceDefinition.Query;
+                                break;
+                            default:
+                                //https://swagger.io/docs/specification/describing-parameters/
+                                break;
+
+                        }
+                        act.Params.Add(name, (myType, bs));
+                    }
+                    var postData = val1.RequestBody?.Content;
+                    if (postData != null)
+                    {
+                        var bs = BindingSourceDefinition.Body;
+                        var data = postData.Values.FirstOrDefault();
+                        var s = data.Schema;
+                        var name = s.Type;
+                        TypeArgumentBase myType = null;
+                        if (s.Reference != null)
+                        {
+                            var id = s.Reference.ReferenceV2 + "_" + s.Reference.ReferenceV3;
+                            myType = types.FindAfterId(id);
+                            name = myType.Name;
+                        }
+                        else
+                        {
+                            myType = types.FindAfterId(s.Type);
+                            name = myType.Name;
+                        }
+                        act.Params.Add(name, (myType, bs));
+                    }
+                    Console.WriteLine(op.Key);
+                }
+            }
+            return actions;
+
+        }
+        internal async Task AddSwagger(string key, string endpoint)
         {
-            swaggers.Add(name, endpoint);
+                        swaggers.Add(key, await GenerateFromSwaggerEndPoint(endpoint));
         }
 
         #endregion
@@ -75,7 +187,7 @@ internal void AddSwagger(string name, string endpoint)
         public GenerateBlocklyFilesHostedService(IApiDescriptionGroupCollectionProvider api)
         {
             this.api = api;
-            this.swaggers = new Dictionary<string, string>();
+            this.swaggers = new Dictionary<string, List<ActionInfo>>();
         }
         /// <summary>
         /// starts

diff --git a/src/NetCore2Blockly/NetCore2Blockly/JavascriptGeneration/BlocklyDefinitionGenerator.cs b/src/NetCore2Blockly/NetCore2Blockly/JavascriptGeneration/BlocklyDefinitionGenerator.cs
@@ -9,14 +9,14 @@ namespace NetCore2Blockly.JavascriptGeneration
     /// <summary>
     /// generates blockly definition for a type
     /// </summary>
-    public class BlocklyDefinitionGenerator
+    class BlocklyDefinitionGenerator
     {
         /// <summary>
         /// Generates the blockly definition.
         /// </summary>
         /// <param name="type">The type.</param>
         /// <returns></returns>
-        public string GenerateBlocklyDefinition(TypeArgumentBase type)
+        internal string GenerateBlocklyDefinition(TypeArgumentBase type)
         {
 
             if (type.ConvertibleToBlocklyType())

diff --git a/src/NetCore2Blockly/NetCore2Blockly/TypeArgument.cs b/src/NetCore2Blockly/NetCore2Blockly/TypeArgument.cs
@@ -1,8 +1,33 @@
-using System.Collections.Generic;
+using NetCore2Blockly.Swagger;
+using System.Collections.Generic;
+using System.Linq;
 using System.Net.Mail;
 
 namespace NetCore2Blockly
 {
+   class AllTypes : List<TypeArgumentBase>
+    {
+        public TypeArgumentBase FindAfterId(string id)
+        {
+            var ret = this.FirstOrDefault(it => it.id == id);
+            if (ret == null)
+            {
+                ret = BlocklyType.CreateValue(id);
+                this.Add(ret);
+            }
+            return ret;
+        }
+
+        public TypeToGenerateSwagger[] MustCreateBlocks()
+        {
+            return this
+                .Where(it => it as TypeToGenerateSwagger != null)
+
+                .Cast<TypeToGenerateSwagger>()
+
+                .ToArray();
+        }
+    }
     /// <summary>
     /// emultates a type
     /// </summary>

diff --git a/src/NetCore2Blockly/TestBlocklyHtml/wwwroot/blockly.html b/src/NetCore2Blockly/TestBlocklyHtml/wwwroot/blockly.html
@@ -972,18 +972,25 @@ <h1>
         //swagger
 
         //window.alert(JSON.stringify(dictSwagger));
+        function addScript(src) {
+            var s = document.createElement('script');
+            s.setAttribute('src', src);
+            document.body.appendChild(s);
+        }
         var toolbox = document.getElementById('toolbox');
         var xmlString = '';
         for (var i = 0; i < dictSwagger.length; i++) {
             var nameSwagger = dictSwagger[i].key;
-            xmlString += `<category name="${nameSwagger}" expanded="true">`;
+            xmlString += `<category name="TEST${nameSwagger}" expanded="true">`;
             xmlString += `<category name="${nameSwagger} Functions" expanded="true"></category>`;
             xmlString += `<category name="${nameSwagger} Values"></category>`;
             xmlString += "</category>";
+            addScript(`/BlocklyDefinitions${nameSwagger}`);
         }
 
         var html = toolbox.innerHTML.replace('<category name="OtherSwagggers"></category>', xmlString);
         toolbox.innerHTML = html;
+
         //end swagger