Ejemplo n.º 1
0
        public void RunRequestProperty()
        {
            var methodStructure = new MethodStructure
            {
                URL    = "/API/Person",
                Name   = "Put",
                Result = new TypeStructure
                {
                    IsSytemType = false,
                    IsArray     = true,
                    TypeName    = "AddPersonResult",
                },
                Parameters = new List <TypeStructure>
                {
                    new TypeStructure {
                        Name = "Id", IsSytemType = true, Type = typeof(int), Attributes = new Dictionary <string, Attribute> {
                        }
                    },
                    new TypeStructure {
                        Name = "Details", IsSytemType = false, TypeName = "PersonDetails", Attributes = new Dictionary <string, Attribute> {
                            { "FromBodyAttribute", new IgnoreAttribute() }
                        }
                    }
                },
                Attributes = new Dictionary <string, Attribute> {
                    { "HttpPutAttribute", new IgnoreAttribute() }
                }
            };
            var jsCode = ((JSRenderble)DI.Get <IRunRequestProperty>(methodStructure)).GetText();

            Assert.AreEqual(jsCode, "this._PutById = new request(this.baseUrl,\"/API/Person\",\"PUT\",{Id:\"QUERY\",Details:\"BODY\"}, AddPersonResult);\r\n");
        }
        public void RunRequestMethodComment()
        {
            var methodStructure = new MethodStructure
            {
                URL    = "/Person/Add",
                Result = new TypeStructure
                {
                    IsSytemType = false,
                    IsArray     = true,
                    TypeName    = "AddPersonResult",
                },
                Parameters = new List <TypeStructure>
                {
                    new TypeStructure {
                        Name = "Id", IsSytemType = true, Type = typeof(int)
                    },
                    new TypeStructure {
                        Name = "Name", IsSytemType = true, Type = typeof(string)
                    },
                    new TypeStructure {
                        Name = "DateOfBirth", IsSytemType = true, Type = typeof(DateTime)
                    },
                    new TypeStructure {
                        Name = "Details", IsSytemType = false, TypeName = "PersonDetails"
                    }
                },
                Attributes = new Dictionary <string, Attribute> {
                    { "HttpPostAttribute", new IgnoreAttribute() }
                }
            };
            var jsCode = ((JSRenderble)DI.Get <IRunRequestMethodComment>(methodStructure)).GetText();

            Assert.AreEqual(jsCode, " /**\r\n    * Method used to invoke request of type: POST to URL: /Person/Add.\r\n    * @param { Number } Id\r\n    * @param { String } Name\r\n    * @param { Date } DateOfBirth\r\n    * @param { PersonDetails } Details\r\n    * @return {PromiseLike<AddPersonResult[]>}\r\n*/");
        }
Ejemplo n.º 3
0
        public void RunMethodRequest()
        {
            var methodStructure = new MethodStructure
            {
                URL    = "/API/Person",
                Name   = "Put",
                Result = new TypeStructure
                {
                    IsSytemType = false,
                    IsArray     = true,
                    TypeName    = "AddPersonResult",
                },
                Parameters = new List <TypeStructure>
                {
                    new TypeStructure {
                        Name = "Id", IsSytemType = true, Type = typeof(int), Attributes = new Dictionary <string, Attribute> {
                        }
                    },
                    new TypeStructure {
                        Name = "Details", IsSytemType = false, TypeName = "PersonDetails", Attributes = new Dictionary <string, Attribute> {
                            { "FromBodyAttribute", new IgnoreAttribute() }
                        }
                    }
                },
                Attributes = new Dictionary <string, Attribute> {
                    { "HttpPutAttribute", new IgnoreAttribute() }
                }
            };
            var jsCode = ((JSRenderble)DI.Get <IRunRequestMethod>(methodStructure, "")).GetText();

            Assert.AreEqual(jsCode, "     /**\r\n    * Method used to invoke request of type: PUT to URL: /API/Person.\r\n    * @param { Number } Id\r\n    * @param { PersonDetails } Details\r\n    * @return {PromiseLike<AddPersonResult[]>}\r\n*/\r\n    PutById (Id,Details)\r\n    {\r\n        return this._PutById.ExecuteRequest({Id:Id,Details:Details});\r\n    }\r\n");
        }
Ejemplo n.º 4
0
 public static string GetHTTPMethod(MethodStructure methodStructure)
 {
     return(methodStructure.Attributes.ContainsKey("HttpPostAttribute") ? "POST" :
            methodStructure.Attributes.ContainsKey("HttpPutAttribute") ? "PUT" :
            methodStructure.Attributes.ContainsKey("HttpDeleteAttribute") ? "DELETE" :
            methodStructure.Attributes.ContainsKey("HttpPatchAttribute") ? "PATCH" : "GET");
 }
Ejemplo n.º 5
0
 private void handleMethod(List <IJSProperty> properties, bool isRPCMode, MethodStructure method)
 {
     method.IsRPC = isRPCMode;
     properties.Add(JSBuilderIOCContainer.Instance.CreatePropertyFromMethod(method));
     ((List <IRenderble>)Methods).Add((IRenderble)JSBuilderIOCContainer.Instance.CreateRunMethodRequestFromMethod(method));
     buildResultTypeImports(method);
     buildParameterTypeImports(method);
 }
Ejemplo n.º 6
0
 private void buildResultTypeImports(MethodStructure method)
 {
     if (!method.Result.IsSytemType && !Imports.Any(x => x.Modules.Any(m => m == method.Result.TypeName)) && method.Result.TypeName != null)
     {
         var import = JSBuilderIOCContainer.Instance.CreateImport();
         ((List <String>)import.Modules).Add(method.Result.TypeName);
         import.URL = $"./{Configuration.Instance.ModelsFolder}/{method.Result.TypeName}.js";
         ((List <IImport>)Imports).Add(import);
     }
 }
 public RunRequestProperty(MethodStructure methodStructure) : base("RunRequestProperty")
 {
     tagValues = new Dictionary <string, string> {
         { nameTag, methodStructure.IsRPC ? methodStructure.Name : NamingHelpers.GetRestfullMethodName(methodStructure) },
         { urlTag, methodStructure.URL },
         { methodTag, HttpHelpers.GetHTTPMethod(methodStructure) },
         { parameterSourceBindingTag, HttpHelpers.GetRequestParametersSourceObject(methodStructure) },
         { resultTypeTag, !methodStructure.Result.IsSytemType && methodStructure.Result.TypeName != null?Configuration.Instance.ModelsNameFactory(methodStructure.Result.TypeName) :  "null" }
     };
 }
 public RunMethodRequest(MethodStructure methodStructure, string name) : base("RunMethodRequest")
 {
     tagValues = new Dictionary <string, string> {
         { controllerNameTag, name },
         { nameTag, methodStructure.IsRPC ? methodStructure.Name : NamingHelpers.GetRestfullMethodName(methodStructure) },
         { parameterTag, methodStructure.Parameters.GetCSV(x => x.Name) },
         { requestObjectTag, methodStructure.Parameters.GetCSV(x => $"{x.Name}:{x.Name}") }
     };
     childRenderbles.Add((JSRenderble)DI.Get <IRunRequestMethodComment>(methodStructure));
 }
Ejemplo n.º 9
0
 private void createPropertyAssignable(MethodStructure methodStructure)
 {
     Assignable = JSBuilderIOCContainer.Instance.CreateAssignable();
     Assignable.NewInstanceParamters = new List <string> {
         "this._baseUrl",
         $"\"{methodStructure.URL}\"",
         $"\"{HttpHelpers.GetHTTPMethod(methodStructure)}\"",
         getRequestParametersSourceObject(methodStructure),
         !methodStructure.Result.IsSytemType && methodStructure.Result.TypeName != null ? methodStructure.Result.TypeName :  "null"
     };
     Assignable.NewInstanceType = "request";
 }
Ejemplo n.º 10
0
        public RunMethodRequest(MethodStructure methodStructure) : base(Resources.runRequestMethod)
        {
            Name = methodStructure.IsRPC ? methodStructure.Name : NamingHelpers.GetRestfullMethodName(methodStructure);

            Comment                      = JSBuilderIOCContainer.Instance.CreateComment();
            Comment.Description          = $"Method to invoke request to {methodStructure.URL}. Method: {HttpHelpers.GetHTTPMethod(methodStructure)}.";
            Comment.Params               = methodStructure.Parameters.ToDictionary(k => k.Name, v => JSTypeMapping.GetJSType(v));
            Comment.ReturnType           = JSTypeMapping.GetJSType(methodStructure.Result);
            Comment.ReturnType.IsPromise = true;

            Parameters = methodStructure.Parameters.Select(x => x.Name).ToList();
        }
Ejemplo n.º 11
0
        public static string GetRestfullMethodName(MethodStructure methodStructure)
        {
            var parameters = methodStructure.Parameters.Where(x => !x.Attributes.ContainsKey("FromBodyAttribute"));

            if (parameters.Count() > 0)
            {
                return($"{methodStructure.Name}{"By" + parameters.Select(x => x.Name.Substring(0, 1).ToUpper() + x.Name.Substring(1)).Aggregate((a, b) => a + "And" + b)}");
            }
            else
            {
                return(methodStructure.Name);
            }
        }
Ejemplo n.º 12
0
 private void buildParameterTypeImports(MethodStructure method)
 {
     foreach (var parameter in method.Parameters)
     {
         if (!parameter.IsSytemType && !Imports.Any(x => x.Modules.Any(m => m == parameter.TypeName)))
         {
             var import = JSBuilderIOCContainer.Instance.CreateImport();
             ((List <String>)import.Modules).Add(parameter.TypeName);
             import.URL = $"./{Configuration.Instance.ModelsFolder}/{parameter.TypeName}.js";
             ((List <IImport>)Imports).Add(import);
         }
     }
 }
Ejemplo n.º 13
0
        public RunRequestMethodComment(MethodStructure methodStructure) : base("RunRequestMethodComment")
        {
            tagValues = new Dictionary <string, string> {
                { descriptionTag, Configuration.Instance.Comments.RequestMethod(HttpHelpers.GetHTTPMethod(methodStructure), methodStructure.URL) },
                { resultTypeTag, JSTypeMapping.GetJSType(methodStructure.Result, true).JSTypeDef }
            };

            multiplyTags(methodStructure.Parameters.Count, ((JSRenderble)DI.Get <IParameterTypeComment>()).Name);

            methodStructure.Parameters.ForEach(parameter =>
                                               childRenderbles.Add((JSRenderble)DI.Get <IParameterTypeComment>(JSTypeMapping.GetJSType(parameter), parameter.Name))
                                               );
        }
Ejemplo n.º 14
0
        private MethodStructure getMethodStructureInstance <T>(MethodInfo action, ClassStructure classStructure, ClassContainter <T> classContainter)
        {
            var actionURL = action.GetCustomAttribute <HttpMethodAttribute>()?.Template ?? null;
            var newMethod = new MethodStructure
            {
                Attributes = filterAndMapAttributesToDictionary(action.GetCustomAttributes(), classContainter),
                Name       = action.Name,
                URL        = classStructure.URL.Replace("[controller]", classStructure.Name).Replace("[action]", action.Name) + ((actionURL != null) ? $"/{actionURL}" : "")
            };

            classStructure.Methods.Add(newMethod);
            return(newMethod);
        }
Ejemplo n.º 15
0
        public void travelAction <T>(MethodInfo action, ClassStructure classStructure, ClassContainter <T> classContainter)
        {
            if (shouldMethodBeExcluded(action, classContainter) || shouldMethodBeIncluded(action, classContainter))
            {
                return;
            }
            MethodStructure newMethod = getMethodStructureInstance(action, classStructure, classContainter);

            populateParameters(action, classContainter, newMethod);
            var resultTypeStructure = new TypeStructure();

            travelResult <T>(action.ReturnType, resultTypeStructure, classContainter);
            newMethod.Result = new TypeStructure(resultTypeStructure);
        }
Ejemplo n.º 16
0
        public void travelParamters <T>(ParameterInfo parameter, MethodStructure method, ClassContainter <T> classContainter)
        {
            if (shouldExcludeParameter(parameter, classContainter) || shouldIncludeParamter(parameter, classContainter))
            {
                return;
            }
            var           objectType         = GetItemType(parameter.ParameterType);
            TypeStructure parameterStructure = getNewTypeStructuree <T>(classContainter, parameter, method, objectType);

            if (shouldProcessParameter(objectType, parameterStructure))
            {
                var properties = parameter.ParameterType.GetProperties(propertyBindingFlags).ToList();
                properties.ForEach(property => travelObject(property, parameterStructure, classContainter));
            }
        }
Ejemplo n.º 17
0
        public MethodNode(MethodStructure codeStructure, BasicNodeStructure structure, RectangleRenderElementStyle border_style)
            : base(new PropertyStructure(codeStructure.Position, codeStructure.Name, codeStructure.Type, codeStructure.AccessModifier, codeStructure.Modifier), structure, border_style)
        {
            CodeStructure = codeStructure;
            LeftBracket   = new LabelNode(new BasicTextNodeStructure(Position + new Vector(AccessModifierButton.Width + NameTextBox.Width, 0),
                                                                     Renderer.SingleTextWidth, Height, "("),
                                          TextRenderElementStyle.Default, RectangleRenderElementStyle.Textbox);
            string argum = codeStructure.Arguments;

            ArgumentsTextBox = new TextBoxNode(new BasicTextNodeStructure(Position + new Vector(AccessModifierButton.Width + NameTextBox.Width + LeftBracket.Width, 0),
                                                                          Renderer.GetTextWidth(argum.Length), Height, argum),
                                               TextRenderElementStyle.Default, RectangleRenderElementStyle.Textbox);
            RightBracket = new LabelNode(new BasicTextNodeStructure(Position + new Vector(NameTextBox.Width + AccessModifierButton.Width + ArgumentsTextBox.Width + LeftBracket.Width, 0),
                                                                    Renderer.SingleTextWidth, Height, ")"),
                                         TextRenderElementStyle.Default, RectangleRenderElementStyle.Textbox);
            Children.Add(LeftBracket);
            Children.Add(RightBracket);
            Children.Add(ArgumentsTextBox);
            GenerateMenu();
            GenerateOptions();
        }
        public DrawerTestFixture(string sourceCode, string className, string methodName)
        {
            var syntaxTree = CSharpSyntaxTree.ParseText(sourceCode);
            var syntaxRoot = syntaxTree.GetCompilationUnitRoot();
            var ns         = syntaxRoot.Members.OfType <NamespaceDeclarationSyntax>().FirstOrDefault();
            var classes    = ns.Members.OfType <ClassDeclarationSyntax>().FirstOrDefault();
            var usings     = syntaxRoot.Members.OfType <UsingDirectiveSyntax>().ToArray();
            var references = Mock.Of <List <MetadataReference> >();

            var classStructure = new ClassStructure(classes, ns, references, usings, "test", "memory");

            classStructure.ParseClass();
            MethodDeclaration = classes.Members.OfType <MethodDeclarationSyntax>()
                                .Where(m => m.Identifier.ToString().Contains(methodName)).FirstOrDefault();
            var methodStructure = new MethodStructure(classStructure, MethodDeclaration);

            var analyzedClasses = Mock.Of <IDictionary <string, IClassStructure> >();

            Mock.Get(analyzedClasses).Setup(d => d[It.IsAny <string>()]).Returns(classStructure);
            var interfaceResolver = Mock.Of <IInterfaceResolver>();

            DiagramGenerator = new SequenceDiagramGenerator(analyzedClasses, interfaceResolver, null);
        }
Ejemplo n.º 19
0
 private void setPropertyName(MethodStructure methodStructure)
 {
     Name = $"_{(methodStructure.IsRPC ? methodStructure.Name : NamingHelpers.GetRestfullMethodName(methodStructure))}";
 }
Ejemplo n.º 20
0
 private static string getSourceParameters(MethodStructure methodStructure, TypeStructure typeStructure)
 {
     return($"{typeStructure.Name}:{(typeStructure.Attributes.ContainsKey("FromBodyAttribute") ? "\"BODY\"" : methodStructure.URL.Contains($"{{{typeStructure.Name}}}") ? "\"URL\"" : "\"QUERY\"")}");
Ejemplo n.º 21
0
        private void travelObject(PropertyInfo objectType, TypeStructure typeStructure, ClassContainter classContainter, MethodStructure method, int depth)
        {
            depth++;
            if (depth > classContainter.recursionConfiguration.MaxRecursiveDepth)
            {
                throw new Exception($"WillCore.Requests reflection has encountered a method parameter that exceeds the max recursive depth of {classContainter.recursionConfiguration.MaxRecursiveDepth}. This happened on method {method.Name} and type {typeStructure.TypeName}.  " +
                                    $"Please check the class depth or increase the default maximum recursive depth of WillCore.Requests.");
            }
            var           type             = GetItemType(objectType.PropertyType);
            TypeStructure newTypeStructure = getNewTypeStructure(objectType, type, classContainter);

            if (!type.IsSystem && !classContainter.Models.ContainsKey(newTypeStructure.TypeName))
            {
                classContainter.Models[newTypeStructure.TypeName] = newTypeStructure;
                foreach (var property in type.Type.GetProperties(propertyBindingFlags))
                {
                    travelObject(property, newTypeStructure, classContainter, method, depth);
                }
            }
            typeStructure.Properties.Add(new TypeStructure(newTypeStructure));
        }
Ejemplo n.º 22
0
 private void populateParameters <T>(MethodInfo action, ClassContainter <T> classContainter, MethodStructure newMethod)
 {
     foreach (var parameter in action.GetParameters())
     {
         travelParamters <T>(parameter, newMethod, classContainter);
     }
 }
Ejemplo n.º 23
0
 public static string GetRequestParametersSourceObject(MethodStructure methodStructure)
 {
     return(methodStructure.Parameters.Any()
         ? "{" + methodStructure.Parameters.Select(x => getSourceParameters(methodStructure, x)).Aggregate((a, b) => a + "," + b) + "}"
         : "{}");
 }
Ejemplo n.º 24
0
 public MethodGenerator(MethodStructure structure)
 {
     Structure = structure;
     GenerateLines();
 }
Ejemplo n.º 25
0
        private TypeStructure getNewTypeStructuree <T>(ClassContainter <T> classContainter, ParameterInfo parameter, MethodStructure method, Models.ItemType objectType)
        {
            var paramterStructure = new TypeStructure
            {
                Attributes  = filterAndMapAttributesToDictionary(parameter.GetCustomAttributes(), classContainter),
                IsSytemType = objectType.IsSystem,
                Name        = parameter.Name,
                Type        = objectType.Type,
                TypeName    = objectType.Type.Name,
                IsArray     = objectType.Type.IsArray
            };

            method.Parameters.Add(new TypeStructure(paramterStructure));
            if (!paramterStructure.IsSytemType && !classContainter.Models.ContainsKey(paramterStructure.TypeName))
            {
                classContainter.Models[paramterStructure.TypeName] = paramterStructure;
            }
            return(paramterStructure);
        }
Ejemplo n.º 26
0
 public JSProperty(MethodStructure methodStructure) : base(Resources.property)
 {
     createPropertyComment(methodStructure);
     setPropertyName(methodStructure);
     createPropertyAssignable(methodStructure);
 }
Ejemplo n.º 27
0
        public void travelResult(Type type, TypeStructure typeStructure, ClassContainter container, MethodStructure method, int depth)
        {
            var objectType = GetItemType(type);

            typeStructure.IsArray     = objectType.IsArray;
            typeStructure.IsSytemType = objectType.IsSystem;
            typeStructure.Type        = objectType.Type;
            typeStructure.TypeName    = objectType.Type.Name;
            depth++;
            if (depth > container.recursionConfiguration.MaxRecursiveDepth)
            {
                throw new Exception($"WillCore.Requests reflection has encountered a method result that exceeds the max recursive depth of {container.recursionConfiguration.MaxRecursiveDepth}. This happened on method {method.Name} and type {typeStructure.TypeName}.  " +
                                    $"Please check the class depth or increase the default maximum recursive depth of WillCore.Requests.");
            }
            if (type == typeof(void))
            {
                return;
            }
            ;
            if (!objectType.IsSystem && AppDomain.CurrentDomain.GetAssemblies().Contains(objectType.Type.Assembly))
            {
                foreach (var property in typeStructure.Type.GetProperties(propertyBindingFlags))
                {
                    var propertyName     = ResultCamelCase ? $"{property.Name.Substring(0, 1).ToLower()}{(property.Name.Length > 1 ? property.Name.Substring(1) : "")}" : property.Name;
                    var newTypeStructure = new TypeStructure
                    {
                        Name       = propertyName,
                        Attributes = property.GetCustomAttributes().ToDictionary(a => a.GetType().Name, b => b)
                    };
                    travelResult(property.PropertyType, newTypeStructure, container, method, depth);
                    typeStructure.Properties.Add(new TypeStructure(newTypeStructure));
                }
                if (!container.Models.ContainsKey(typeStructure.TypeName))
                {
                    container.Models[typeStructure.TypeName] = typeStructure;
                }
            }
        }
Ejemplo n.º 28
0
 private void createPropertyComment(MethodStructure methodStructure)
 {
     Comment             = JSBuilderIOCContainer.Instance.CreateComment();
     Comment.Description = $"Reqeust {methodStructure.URL}";
 }