binding model, content resolvers

gencebay · gencebay · commit 75f5043d9af6 · 2018-01-21T23:32:00.000+03:00
diff --git a/src/NetCoreStack.Proxy/Binders/HttpDeleteContentBinder.cs b/src/NetCoreStack.Proxy/Binders/HttpDeleteContentBinder.cs
@@ -13,7 +13,7 @@ public override void BindContent(ContentModelBindingContext bindingContext)
         {
             ModelDictionaryResult result = bindingContext.GetResolvedContentResult();
             List<string> keys = result.Dictionary.Keys.ToList();
-            EnsureTemplate(bindingContext.MethodMarkerTemplate, bindingContext.Args, bindingContext.UriDefinition, result.Dictionary, keys);
+            EnsureTemplate(bindingContext.MethodMarkerTemplate, bindingContext.UriDefinition, result.Dictionary, keys);
 
             bindingContext.TryUpdateUri(result.Dictionary);
         }
diff --git a/src/NetCoreStack.Proxy/Binders/HttpGetContentBinder.cs b/src/NetCoreStack.Proxy/Binders/HttpGetContentBinder.cs
@@ -13,7 +13,7 @@ public override void BindContent(ContentModelBindingContext bindingContext)
         {
             ModelDictionaryResult result = bindingContext.GetResolvedContentResult();
             List<string> keys = result.Dictionary.Keys.ToList();
-            EnsureTemplate(bindingContext.MethodMarkerTemplate, bindingContext.Args, bindingContext.UriDefinition, result.Dictionary, keys);
+            EnsureTemplate(bindingContext.MethodMarkerTemplate, bindingContext.UriDefinition, result.Dictionary, keys);
 
             bindingContext.TryUpdateUri(result.Dictionary);
         }
diff --git a/src/NetCoreStack.Proxy/Binders/HttpPutContentBinder.cs b/src/NetCoreStack.Proxy/Binders/HttpPutContentBinder.cs
@@ -2,7 +2,6 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Net.Http;
-using NetCoreStack.Contracts;
 
 namespace NetCoreStack.Proxy
 {
@@ -12,31 +11,29 @@ public class HttpPutContentBinder : BodyContentBinder
 
         public override void BindContent(ContentModelBindingContext bindingContext)
         {
+            var isMultiPartFormData = bindingContext.IsMultiPartFormData;
+            var templateKeys = bindingContext.UriDefinition.TemplateKeys;
+
+            // bindingContext.Parameters.Select(p => p.PropertyName);
+
+            //if (bindingContext.ArgsLength == 1)
+            //{
+
+            //}
+
             ModelDictionaryResult result = bindingContext.GetResolvedContentResult();
             List<string> keys = result.Dictionary.Keys.ToList();
-            EnsureTemplate(bindingContext.MethodMarkerTemplate, bindingContext.Args, bindingContext.UriDefinition, result.Dictionary, keys);
-            if (bindingContext.ArgsLength == 1)
-            {
-                bindingContext.ContentResult = ContentModelBindingResult.Success(SerializeToString(bindingContext.Args[0]));
+            EnsureTemplate(bindingContext.MethodMarkerTemplate, bindingContext.UriDefinition, result.Dictionary, keys);
+            if (isMultiPartFormData)
+            { 
+                var content = GetMultipartFormDataContent(result);
+                bindingContext.ContentResult = ContentModelBindingResult.Success(content);
                 return;
-                // request.Content = SerializeToString(argsDic.First().Value);
             }
-            else if (bindingContext.ArgsLength == 2)
-            {
-                var firstParameter = result.Dictionary[keys[0]];
-                var secondParameter = result.Dictionary[keys[1]];
 
-                // PUT Request first parameter should be Id or Key
-                if (firstParameter.GetType().IsPrimitive())
-                {
-                    bindingContext.UriBuilder.Query += string.Format("&{0}={1}", keys[0], firstParameter);
-                }
-
-                // request.RequestUri = uriBuilder.Uri;
-                // request.Content = SerializeToString(secondParameter);
-                bindingContext.ContentResult = ContentModelBindingResult.Success(SerializeToString(secondParameter));
-                return;
-            }
+            // PUT Request first parameter should be Id or Key then will be removed from the result dictionary
+            // The remaining parameters belong to the body
+            bindingContext.ContentResult = ContentModelBindingResult.Success(SerializeToString(result.Dictionary));
         }
     }
 }
diff --git a/src/NetCoreStack.Proxy/DefaultModelContentResolver.cs b/src/NetCoreStack.Proxy/DefaultModelContentResolver.cs
@@ -176,7 +176,16 @@ private void ResolveInternal(ProxyModelMetadata modelMetadata, ModelDictionaryRe
         {
             var key = isTopLevelObject ? string.Empty : modelMetadata.PropertyName;
             if (!string.IsNullOrEmpty(prefix))
-                key = $"{prefix}.{key}";
+            {
+                if (string.IsNullOrEmpty(key))
+                {
+                    key = prefix;
+                }
+                else
+                {
+                    key = $"{prefix}.{key}";
+                }
+            }
 
             if (modelMetadata.IsFormFile || (modelMetadata.IsEnumerableType && modelMetadata.ElementType.IsFormFile))
             {
diff --git a/src/NetCoreStack.Proxy/DefaultProxyContentStreamProvider.cs b/src/NetCoreStack.Proxy/DefaultProxyContentStreamProvider.cs
@@ -28,6 +28,7 @@ public async Task CreateRequestContentAsync(RequestDescriptor requestContext,
 
             var bindingContext = new ContentModelBindingContext
             {
+                HttpMethod = httpMethod,
                 UriDefinition = proxyUriDefinition,
                 MethodMarkerTemplate = descriptor.MethodMarkerTemplate,
                 IsMultiPartFormData = isMultiPartFormData,
diff --git a/src/NetCoreStack.Proxy/Internal/DefaultProxyTypeManager.cs b/src/NetCoreStack.Proxy/Internal/DefaultProxyTypeManager.cs
@@ -67,6 +67,19 @@ private IList<ProxyDescriptor> GetProxyDescriptors()
                     var httpMethodAttribute = method.GetCustomAttributes(inherit: true)
                         .OfType<HttpMethodMarkerAttribute>().FirstOrDefault();
 
+                    var httpHeaders = method.GetCustomAttribute<HttpHeadersAttribute>();
+                    if (httpHeaders != null && httpHeaders.Headers != null)
+                    {
+                        foreach (var header in httpHeaders.Headers)
+                        {
+                            var token = header.Split(':');
+                            if (token.Length > 1)
+                            {
+                                proxyMethodDescriptor.Headers[token[0].Trim()] = token[1].Trim();
+                            }
+                        }
+                    }
+
                     if (httpMethodAttribute != null)
                     {
                         if (httpMethodAttribute.Template.HasValue())
@@ -88,7 +101,6 @@ private IList<ProxyDescriptor> GetProxyDescriptors()
                     }
 
                     bool isMultipartFormData = false;
-                    proxyMethodDescriptor.Parameters = new List<ProxyModelMetadata>();
                     foreach (var parameter in method.GetParameters())
                     {
                         var modelMetadata = MetadataProvider.GetMetadataForParameter(parameter);
diff --git a/src/NetCoreStack.Proxy/Internal/ProxyManager.cs b/src/NetCoreStack.Proxy/Internal/ProxyManager.cs
@@ -81,21 +81,25 @@ public HttpClient HttpClient
         public bool HasFilter { get; }
         public List<IProxyRequestFilter> RequestFilters { get; }
 
-        private HttpRequestMessage CreateHttpRequest()
+        private HttpRequestMessage CreateHttpRequest(ProxyMethodDescriptor methodDescriptor)
         {
             HttpRequestMessage requestMessage = new HttpRequestMessage();
 
             foreach (KeyValuePair<string, string> entry in _headerProvider.Headers)
             {
                 requestMessage.Headers.Add(entry.Key, entry.Value);
-            } 
+            }
+
+            foreach (KeyValuePair<string, string> entry in methodDescriptor.Headers)
+            {
+                requestMessage.Headers.Add(entry.Key, entry.Value);
+            }
 
             return requestMessage;
         }
 
         public async Task<RequestContext> CreateRequestAsync(RequestDescriptor descriptor)
         {
-            HttpRequestMessage request = CreateHttpRequest();
             var proxyDescriptor = _typeManager.ProxyDescriptors.FirstOrDefault(x => x.ProxyType == descriptor.ProxyType);
 
             if (proxyDescriptor == null)
@@ -107,6 +111,7 @@ public async Task<RequestContext> CreateRequestAsync(RequestDescriptor descripto
             if (!proxyDescriptor.Methods.TryGetValue(descriptor.TargetMethod, out methodDescriptor))
                 throw new ArgumentOutOfRangeException("Method (Action) info could not be found!");
 
+            HttpRequestMessage request = CreateHttpRequest(methodDescriptor);
             request.Method = methodDescriptor.HttpMethod;
             var methodPath = descriptor.TargetMethod.Name;
             if (methodDescriptor.MethodMarkerTemplate.HasValue())
diff --git a/src/NetCoreStack.Proxy/Types/ContentModelBinder.cs b/src/NetCoreStack.Proxy/Types/ContentModelBinder.cs
@@ -6,7 +6,6 @@ namespace NetCoreStack.Proxy
     public abstract class ContentModelBinder : IContentModelBinder
     {
         protected virtual void EnsureTemplate(string methodMarkerTemplate,
-            object[] args,
             ProxyUriDefinition proxyUriDefinition,
             Dictionary<string, string> argsDic,
             List<string> keys)
@@ -18,8 +17,11 @@ protected virtual void EnsureTemplate(string methodMarkerTemplate,
                     for (int i = 0; i < proxyUriDefinition.ParameterParts.Count; i++)
                     {
                         var key = keys[i];
-                        proxyUriDefinition.UriBuilder.Path += ($"/{WebUtility.UrlEncode(args[i]?.ToString())}");
-                        argsDic.Remove(key);
+                        if(argsDic.TryGetValue(key, out string value))
+                        {
+                            proxyUriDefinition.UriBuilder.Path += ($"/{WebUtility.UrlEncode(value)}");
+                            argsDic.Remove(key);
+                        }
                     }
                 }
             }
diff --git a/src/NetCoreStack.Proxy/Types/ContentModelBindingContext.cs b/src/NetCoreStack.Proxy/Types/ContentModelBindingContext.cs
@@ -1,5 +1,6 @@
 ﻿using System;
 using System.Collections.Generic;
+using System.Net.Http;
 
 namespace NetCoreStack.Proxy
 {
@@ -22,5 +23,6 @@ public int ArgsLength
         public List<ProxyModelMetadata> Parameters { get; set; }
         public ContentModelBindingResult ContentResult { get; set; }
         public ProxyUriDefinition UriDefinition { get; set; }
+        public HttpMethod HttpMethod { get; set; }
     }
-}
+}
diff --git a/src/NetCoreStack.Proxy/Types/ProxyMethodDescriptor.cs b/src/NetCoreStack.Proxy/Types/ProxyMethodDescriptor.cs
@@ -23,21 +23,25 @@ public class ProxyMethodDescriptor
 
         public bool IsMultiPartFormData { get; set; }
 
-        public List<ProxyModelMetadata> Parameters { get; set; }
+        public List<ProxyModelMetadata> Parameters { get; }
 
         public bool IsVoidReturn { get; }
 
         public bool IsTaskReturn { get; }
 
         public bool IsGenericTaskReturn { get; }
 
+        public Dictionary<string, string> Headers { get; }
+
         public ProxyMethodDescriptor(MethodInfo methodInfo)
         {
             MethodInfo = methodInfo;
             ReturnType = methodInfo.ReturnType;
             IsVoidReturn = ReturnType == typeof(void);
             IsTaskReturn = ReturnType.IsAssignableFrom(typeof(Task)) ? true : false;
             IsGenericTaskReturn = ReturnType.IsGenericTask() ? true : false;
+            Headers = new Dictionary<string, string>(StringComparer.Ordinal);
+            Parameters = new List<ProxyModelMetadata>();
 
             if (IsGenericTaskReturn)
             {
diff --git a/src/NetCoreStack.Proxy/Types/ProxyUriDefinition.cs b/src/NetCoreStack.Proxy/Types/ProxyUriDefinition.cs
@@ -14,11 +14,14 @@ public class ProxyUriDefinition
 
         public bool HasParameter { get; private set; }
 
+        public List<string> TemplateKeys { get; private set; }
+
         public List<TemplatePart> ParameterParts { get; private set; }
 
         public ProxyUriDefinition(UriBuilder uriBuilder)
         {
             UriBuilder = uriBuilder;
+            TemplateKeys = new List<string>();
         }
 
         public void ResolveTemplate(RouteTemplate routeTemplate, string route, string template)
@@ -38,11 +41,11 @@ public void ResolveTemplate(RouteTemplate routeTemplate, string route, string te
                         return;
                     }
 
-                    var segments = routeTemplate.Segments
+                    TemplateKeys = routeTemplate.Segments
                         .SelectMany(s => s.Parts.Where(p => p.IsLiteral)
                         .Select(t => t.Text)).ToList();
 
-                    tmpl = string.Join("/", segments);
+                    tmpl = string.Join("/", TemplateKeys);
                     TemplateCache.Add(key, tmpl);
 
                     path += $"{route}/{tmpl}";
diff --git a/test/NetCoreStack.Proxy.Mvc.Hosting/Controllers/GuidelineController.cs b/test/NetCoreStack.Proxy.Mvc.Hosting/Controllers/GuidelineController.cs
@@ -80,6 +80,14 @@ public async Task TaskActionPut(long id, SampleModel model)
             _logger.LogDebug(JsonConvert.SerializeObject(new { id, model }));
         }
 
+        [HttpPut(nameof(CreateOrUpdateKey))]
+        public async Task<bool> CreateOrUpdateKey(string key, Bar body)
+        {
+            await Task.CompletedTask;
+            _logger.LogDebug(JsonConvert.SerializeObject(new { key, body }));
+            return true;
+        }
+
         [HttpDelete(nameof(TaskActionDelete))]
         public async Task TaskActionDelete(long id)
         {
diff --git a/test/NetCoreStack.Proxy.Test.Contracts/IGuidelineApi.cs b/test/NetCoreStack.Proxy.Test.Contracts/IGuidelineApi.cs
@@ -8,6 +8,7 @@ namespace NetCoreStack.Proxy.Test.Contracts
     [ApiRoute("api/[controller]", regionKey: "Main")]
     public interface IGuidelineApi : IApiContract
     {
+        [HttpHeaders("X-Method-Header: Some Value")]
         Task TaskOperation();
 
         Task GetComplexType(ComplexTypeModel model);
@@ -26,6 +27,15 @@ public interface IGuidelineApi : IApiContract
         [HttpPutMarker]
         Task TaskActionPut(long id, SampleModel model);
 
+        /// <summary>
+        /// Template and parameter usage, key parameter will be part of the request Url and extracting it as api/guideline/kv/<key>
+        /// </summary>
+        /// <param name="key"></param>
+        /// <param name="body"></param>
+        /// <returns></returns>
+        [HttpPutMarker(Template = "kv/{key}")]
+        Task<bool> CreateOrUpdateKey(string key, Bar body);
+
         [HttpDeleteMarker]
         Task TaskActionDelete(long id);
     }
diff --git a/test/NetCoreStack.Proxy.Tests/ProxyCreationTests.cs b/test/NetCoreStack.Proxy.Tests/ProxyCreationTests.cs
@@ -2,6 +2,7 @@
 using Microsoft.Extensions.DependencyInjection;
 using NetCoreStack.Contracts;
 using NetCoreStack.Proxy.Test.Contracts;
+using Newtonsoft.Json;
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -12,6 +13,8 @@ namespace NetCoreStack.Proxy.Tests
 {
     public class ProxyCreationTests
     {
+        private readonly string _someKey = "248fd6db0ae44ec48169fa2391b067da";
+
         protected IServiceProvider Resolver { get; }
         protected IConfigurationRoot Configuration { get; }
 
@@ -49,7 +52,8 @@ public async Task PrimitiveReturnTest()
         public async Task GetWithComplexReferenceTypeTest()
         {
             var guidelineApi = Resolver.GetService<IGuidelineApi>();
-            var task = guidelineApi.GetWithComplexReferenceType(new CollectionRequest {
+            var task = guidelineApi.GetWithComplexReferenceType(new CollectionRequest
+            {
                 Draw = 1,
                 Filters = "",
                 Length = 10,
@@ -129,6 +133,20 @@ public async Task TaskActionPutTest()
             Assert.True(true);
         }
 
+        [Fact]
+        public async Task CreateOrUpdateKeyTest()
+        {
+            var guidelineApi = Resolver.GetService<IGuidelineApi>();
+            var result = await guidelineApi.CreateOrUpdateKey(_someKey, new Bar
+            {
+                String = "Bar string value!",
+                someint = 6,
+                SomeEnum = SomeEnum.Value2,
+                Foo = new Foo { IEnumerableInt = new[] { 1, 3, 5, 7, 9 }, String = "Foo string value!" }
+            });
+            Assert.True(result);
+        }
+
         [Fact]
         public async Task TaskActionDeleteTest()
         {
diff --git a/test/NetCoreStack.Proxy.Tests/appsettings.json b/test/NetCoreStack.Proxy.Tests/appsettings.json
@@ -1,7 +1,7 @@
 ﻿{
   "ProxySettings": {
     "RegionKeys": {
-      "Main": "http://localhost:5003/,http://localhost:5004/",
+      "Main": "http://localhost:5003/,http://localhost:5003/",
       "Consul": "http://localhost:8500/"
     }
   }
diff --git a/test/NetCoreStack.Proxy.Tests/httplive.db b/test/NetCoreStack.Proxy.Tests/httplive.db

Original file line number	Diff line number	Diff line change
`@@ -13,7 +13,7 @@ public override void BindContent(ContentModelBindingContext bindingContext)`
`13`	`13`	`{`
`14`	`14`	`ModelDictionaryResult result = bindingContext.GetResolvedContentResult();`
`15`	`15`	`List<string> keys = result.Dictionary.Keys.ToList();`
`16`		`- EnsureTemplate(bindingContext.MethodMarkerTemplate, bindingContext.Args, bindingContext.UriDefinition, result.Dictionary, keys);`
	`16`	`+ EnsureTemplate(bindingContext.MethodMarkerTemplate, bindingContext.UriDefinition, result.Dictionary, keys);`
`17`	`17`
`18`	`18`	`bindingContext.TryUpdateUri(result.Dictionary);`
`19`	`19`	`}`
Original file line number	Diff line number	Diff line change
`@@ -28,6 +28,7 @@ public async Task CreateRequestContentAsync(RequestDescriptor requestContext,`
`28`	`28`
`29`	`29`	`var bindingContext = new ContentModelBindingContext`
`30`	`30`	`{`
	`31`	`+ HttpMethod = httpMethod,`
`31`	`32`	`UriDefinition = proxyUriDefinition,`
`32`	`33`	`MethodMarkerTemplate = descriptor.MethodMarkerTemplate,`
`33`	`34`	`IsMultiPartFormData = isMultiPartFormData,`
Original file line number	Diff line number	Diff line change
`@@ -6,7 +6,6 @@ namespace NetCoreStack.Proxy`
`6`	`6`	`public abstract class ContentModelBinder : IContentModelBinder`
`7`	`7`	`{`
`8`	`8`	`protected virtual void EnsureTemplate(string methodMarkerTemplate,`
`9`		`- object[] args,`
`10`	`9`	`ProxyUriDefinition proxyUriDefinition,`
`11`	`10`	`Dictionary<string, string> argsDic,`
`12`	`11`	`List<string> keys)`
`@@ -18,8 +17,11 @@ protected virtual void EnsureTemplate(string methodMarkerTemplate,`
`18`	`17`	`for (int i = 0; i < proxyUriDefinition.ParameterParts.Count; i++)`
`19`	`18`	`{`
`20`	`19`	`var key = keys[i];`
`21`		`- proxyUriDefinition.UriBuilder.Path += ($"/{WebUtility.UrlEncode(args[i]?.ToString())}");`
`22`		`- argsDic.Remove(key);`
	`20`	`+ if(argsDic.TryGetValue(key, out string value))`
	`21`	`+ {`
	`22`	`+ proxyUriDefinition.UriBuilder.Path += ($"/{WebUtility.UrlEncode(value)}");`
	`23`	`+ argsDic.Remove(key);`
	`24`	`+ }`
`23`	`25`	`}`
`24`	`26`	`}`
`25`	`27`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,6 @@`
`1`	`1`	`using System;`
`2`	`2`	`using System.Collections.Generic;`
	`3`	`+using System.Net.Http;`
`3`	`4`
`4`	`5`	`namespace NetCoreStack.Proxy`
`5`	`6`	`{`
`@@ -22,5 +23,6 @@ public int ArgsLength`
`22`	`23`	`public List<ProxyModelMetadata> Parameters { get; set; }`
`23`	`24`	`public ContentModelBindingResult ContentResult { get; set; }`
`24`	`25`	`public ProxyUriDefinition UriDefinition { get; set; }`
	`26`	`+ public HttpMethod HttpMethod { get; set; }`
`25`	`27`	`}`
`26`		`-}`
	`28`	`+}`