POST multipart/form-data support, IFormFile and upload

Author: gencebay

README.md

@@ -17,7 +17,7 @@ Flying Proxy aims to:
 
 ### Usage for Client Side
 
-#### Startup ConfigureServices (ASP.NET Core method gets called by the runtime.)
+#### Startup ConfigureServices
 ```csharp
 public void ConfigureServices(IServiceCollection services)
 {
@@ -33,7 +33,7 @@ public void ConfigureServices(IServiceCollection services)
 }
 ```
 
-#### Example Dependency Injection
+#### Example dependency injection
 ```csharp
 public class TestController : Controller
 {
@@ -52,8 +52,8 @@ public class TestController : Controller
 }
 ```
 
-#### Add Configuration Section to the appsettings.json file (or your configuration file)
-##### Example for development environment:
+#### Add configuration section to the appsettings.json file (or your configuration file)
+##### Example:
 ```json
 "ProxySettings": {
     "RegionKeys": {
@@ -68,6 +68,7 @@ public class TestController : Controller
 
 #### API Contract Definition (Default HttpMethod is HttpGet)
 ```csharp
+// This APIs expose methods from localhost:5000 and localhost:5001 as configured on ProxySettings
 [ApiRoute("api/[controller]", regionKey: "Main")]
 public interface IGuidelineApi : IApiContract
 {
@@ -86,7 +87,7 @@ public interface IGuidelineApi : IApiContract
 }
 ```
 
-### Usage for Backend - Server Side
+### Backend - Server Side
 #### API Contract Implementation
 ```csharp
 [Route("api/[controller]")]
@@ -152,6 +153,24 @@ public class GuidelineController : Controller, IGuidelineApi
 }
 ```
 
+#### Multipart form data:
+Proxy sends all POST methods as JSON but if the method parameter model contains IFormFile type property it converts the content-type to multipart/form-data. In this case, use any model to POST multipart/form-data to API without [FromBody] attribute on action parameter. For example:
+
+```csharp
+// Interface
+[HttpPostMarker]
+Task<AlbumViewModel> SaveAlbumSubmit(AlbumViewModelSubmit model)    
+```
+
+```csharp
+// API Controller
+[HttpPost(nameof(SaveAlbumSubmit))]
+public async Task<AlbumViewModel> SaveAlbumSubmit(AlbumViewModelSubmit model)  
+```
+
+
+
+
 
 ### Prerequisites
 > [ASP.NET Core](https://github.com/aspnet/Home)

src/NetCoreStack.Proxy/DefaultProxyContentStreamProvider.cs

@@ -1,4 +1,5 @@
-using NetCoreStack.Contracts;
+using Microsoft.AspNetCore.Http;
+using NetCoreStack.Contracts;
 using NetCoreStack.Proxy.Extensions;
 using NetCoreStack.Proxy.Internal;
 using Newtonsoft.Json;
@@ -7,6 +8,7 @@
 using System.Linq;
 using System.Net;
 using System.Net.Http;
+using System.Net.Http.Headers;
 using System.Text;
 using System.Threading.Tasks;
 
@@ -24,9 +26,39 @@ protected virtual StringContent SerializeToString(object value)
             return new StringContent(JsonConvert.SerializeObject(value), Encoding.UTF8, "application/json");
         }
 
-        protected virtual MultipartFormDataContent GetMultipartFormDataContent()
+        protected virtual MultipartFormDataContent GetMultipartFormDataContent(IDictionary<string,object> values)
         {
             MultipartFormDataContent multipartFormDataContent = new MultipartFormDataContent();
+            foreach (KeyValuePair<string, object> entry in values)
+            {
+                var parameterContext = entry.Value as PropertyContext;
+                if (parameterContext != null)
+                {
+                    if (parameterContext.PropertyContentType == PropertyContentType.Multipart)
+                    {
+                        IFormFile formFile = parameterContext.Value as IFormFile;
+                        if (formFile != null)
+                        {
+                            using (var ms = new MemoryStream())
+                            {
+                                formFile.CopyTo(ms);
+                                var fileContent = new ByteArrayContent(ms.ToArray());
+                                fileContent.Headers.ContentType = MediaTypeHeaderValue.Parse(formFile.ContentType);
+                                fileContent.Headers.ContentDisposition = ContentDispositionHeaderValue.Parse(formFile.ContentDisposition);
+                                multipartFormDataContent.Add(fileContent, entry.Key, formFile.FileName);
+                            }
+                        }                                             
+                    }
+                    else
+                    {
+                        var stringContent = parameterContext.Value?.ToString();
+                        if (!string.IsNullOrEmpty(stringContent))
+                        {
+                            multipartFormDataContent.Add(new StringContent(stringContent), entry.Key);
+                        }
+                    }
+                }                
+            }
 
             return multipartFormDataContent;
         }
@@ -84,6 +116,12 @@ public async Task CreateRequestContentAsync(RequestContext requestContext,
             var keys = new List<string>(argsDic.Keys);
             if (descriptor.HttpMethod == HttpMethod.Post)
             {
+                if (descriptor.IsMultiPartFormData)
+                {
+                    request.Content = GetMultipartFormDataContent(argsDic);
+                    return;
+                }
+
                 if (argsCount == 1)
                     request.Content = SerializeToString(argsDic.First().Value);
                 else

src/NetCoreStack.Proxy/Extensions/DictionaryExtensions.cs

@@ -1,8 +1,8 @@
-using Microsoft.AspNetCore.Mvc.Abstractions;
-using Microsoft.AspNetCore.WebUtilities;
+using Microsoft.AspNetCore.WebUtilities;
 using System;
 using System.Collections.Generic;
 using System.Globalization;
+using System.Reflection;
 
 namespace NetCoreStack.Proxy.Extensions
 {
@@ -24,7 +24,7 @@ private static string TypeParser(KeyValuePair<string, object> selector)
             return selector.Value.ToString();
         }
 
-        public static void Merge(this IDictionary<string, object> instance, IDictionary<string, object> from, bool replaceExisting)
+        internal static void Merge(this IDictionary<string, object> instance, IDictionary<string, object> from, bool replaceExisting)
         {
             foreach (KeyValuePair<string, object> entry in from)
             {
@@ -35,18 +35,45 @@ public static void Merge(this IDictionary<string, object> instance, IDictionary<
             }
         }
 
-        public static void MergeArgs(this IDictionary<string, object> dictionary, object[] args, ProxyParameterDescriptor[] parameters)
+        internal static void MergeArgs(this IDictionary<string, object> dictionary, 
+            object[] args, 
+            ProxyParameterDescriptor[] parameters,
+            bool isMultiPartFormData)
         {
             if (args.Length == 0)
                 return;
 
+            if (!isMultiPartFormData)
+            {
+                for (int i = 0; i < parameters.Length; i++)
+                {
+                    dictionary.Add(parameters[i].Name, args[i]);
+                }
+
+                return;
+            }
+
+            // Multipart form data context preparing
             for (int i = 0; i < parameters.Length; i++)
             {
-                dictionary.Add(parameters[i].Name, args[i]);
+                foreach (var prop in parameters[i].Properties)
+                {
+                    string name = prop.Key;
+                    PropertyContentTypeInfo contentTypeInfo = prop.Value;
+
+                    var parameterContext = new PropertyContext
+                    {
+                        Name = name,
+                        Value = contentTypeInfo.PropertyInfo.GetValue(args[i]),
+                        PropertyContentType = contentTypeInfo.PropertyContentType
+                    };
+
+                    dictionary.Add(name, parameterContext);
+                }
             }
         }
 
-        public static string ToQueryString(this Uri baseUrl, IDictionary<string, object> objectDics)
+        internal static string ToQueryString(this Uri baseUrl, IDictionary<string, object> objectDics)
         {
             if (objectDics == null)
                 return baseUrl.AbsoluteUri;

src/NetCoreStack.Proxy/Internal/Constants.cs

@@ -5,6 +5,7 @@ public class Constants
         public static string Prefix = "NetCoreStack";
         public const string ProxySettings = "ProxySettings";
         public const string ContentTypeJsonWithEncoding = "application/json; charset=utf-8";
-        public readonly static string ClientUserAgentHeader = "User-Agent";
+        public const string ContentTypeMultipartFormData = "multipart/form-data";
+        public readonly static string ClientUserAgentHeader = "User-Agent";      
     }
 }

src/NetCoreStack.Proxy/Internal/DefaultProxyTypeManager.cs

@@ -1,6 +1,4 @@
-using Microsoft.AspNetCore.Http;
-using Microsoft.AspNetCore.Mvc.Abstractions;
-using Microsoft.AspNetCore.Mvc.ModelBinding;
+using Microsoft.AspNetCore.Mvc.ModelBinding;
 using NetCoreStack.Contracts;
 using NetCoreStack.Proxy.Extensions;
 using System;
@@ -32,10 +30,10 @@ private IList<ProxyDescriptor> GetProxyDescriptors()
             {
                 var pathAttr = proxyType.GetTypeInfo().GetCustomAttribute<ApiRouteAttribute>();
                 if (pathAttr == null)
-                    throw new ArgumentNullException($"{nameof(ApiRouteAttribute)} required for Proxy - Api interface.");
+                    throw new ProxyException($"{nameof(ApiRouteAttribute)} required for Proxy - Api interface.");
 
                 if (!pathAttr.RegionKey.HasValue())
-                    throw new ArgumentOutOfRangeException($"Specify the \"{nameof(pathAttr.RegionKey)}\"!");
+                    throw new ProxyException($"Specify the \"{nameof(pathAttr.RegionKey)}\"!");
 
                 var route = proxyType.Name.GetApiRootPath(pathAttr.RouteTemplate);
 
@@ -78,7 +76,7 @@ private IList<ProxyDescriptor> GetProxyDescriptors()
                             proxyMethodDescriptor.HttpMethod = HttpMethod.Get;
                         else if (httpMethodAttribute is HttpPostMarkerAttribute)
                             proxyMethodDescriptor.HttpMethod = HttpMethod.Post;
-                        else if(httpMethodAttribute is HttpPutMarkerAttribute)
+                        else if (httpMethodAttribute is HttpPutMarkerAttribute)
                             proxyMethodDescriptor.HttpMethod = HttpMethod.Put;
                         else if (httpMethodAttribute is HttpDeleteMarkerAttribute)
                             proxyMethodDescriptor.HttpMethod = HttpMethod.Delete;
@@ -95,14 +93,30 @@ private IList<ProxyDescriptor> GetProxyDescriptors()
                         var parameterType = parameter.ParameterType;
                         var properties = parameterType.GetProperties().ToList();
 
+                        var proxyParameterDescriptor = new ProxyParameterDescriptor(properties);
+                        if (proxyParameterDescriptor.HasFormFile)
+                        {
+                            if (parameter.CustomAttributes
+                                .Any(a => a.AttributeType.Name == "FromBodyAttribute"))
+                            {
+                                throw new ProxyException($"Parameter: \"{parameter.ParameterType.Name} as {parameter.Name}\" " +
+                                    "contains IFormFile type property. " +
+                                    "Remove FromBody attribute to proper model binding.");
+                            }
+                        }
+
                         proxyMethodDescriptor.Parameters.Add(new ProxyParameterDescriptor(properties)
                         {
                             Name = parameter.Name,
                             ParameterType = parameterType,
                             BindingInfo = BindingInfo.GetBindingInfo(parameter.GetCustomAttributes().OfType<object>())
                         });
                     }
+                    
+                    var isMultipartFormData = proxyMethodDescriptor.Parameters.SelectMany(p => p.Properties)
+                        .Any(c => c.Value.PropertyContentType == PropertyContentType.Multipart);
 
+                    proxyMethodDescriptor.IsMultiPartFormData = isMultipartFormData;
                     descriptor.Methods.Add(method, proxyMethodDescriptor);
                 }
                 #endregion // method resolver

src/NetCoreStack.Proxy/Internal/ProxyException.cs

@@ -4,6 +4,12 @@ namespace NetCoreStack.Proxy
 {
     public class ProxyException : Exception
     {
+        public ProxyException(string message)
+            :base(message)
+        {
+
+        }
+
         public ProxyException(string message, Exception innerException)
             : base(message, innerException)
         {

src/NetCoreStack.Proxy/PropertyContentType.cs

@@ -0,0 +1,22 @@
+using System.Reflection;
+
+namespace NetCoreStack.Proxy
+{
+    public enum PropertyContentType
+    {
+        String = 0,
+        Multipart = 1
+    }
+
+    public class PropertyContentTypeInfo
+    {
+        public PropertyInfo PropertyInfo { get; }
+        public PropertyContentType PropertyContentType { get; }
+
+        public PropertyContentTypeInfo(PropertyInfo propertyInfo, PropertyContentType contentType)
+        {
+            PropertyInfo = propertyInfo;
+            PropertyContentType = contentType;
+        }
+    }
+}

src/NetCoreStack.Proxy/PropertyContext.cs

@@ -0,0 +1,9 @@
+namespace NetCoreStack.Proxy
+{
+    public class PropertyContext
+    {
+        public string Name { get; set; }
+        public object Value { get; set; }
+        public PropertyContentType PropertyContentType { get; set; }
+    }
+}

src/NetCoreStack.Proxy/ProxyMethodDescriptor.cs

@@ -22,6 +22,8 @@ public class ProxyMethodDescriptor
 
         public TimeSpan? Timeout { get; set; }
 
+        public bool IsMultiPartFormData { get; set; }
+
         public List<ProxyParameterDescriptor> Parameters { get; set; }
 
         public bool IsVoidReturn { get; }
@@ -44,9 +46,10 @@ public ProxyMethodDescriptor(MethodInfo methodInfo)
             }
         }
 
+        // per request resolver
         public IDictionary<string, object> Resolve(object[] args)
         {
-            var values = new Dictionary<string, object>();
+            var values = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);
             if (HttpMethod == HttpMethod.Get)
             {
                 // Ref type parameter resolver
@@ -63,7 +66,7 @@ public IDictionary<string, object> Resolve(object[] args)
                 }
             }
 
-            values.MergeArgs(args, Parameters.ToArray());
+            values.MergeArgs(args, Parameters.ToArray(), IsMultiPartFormData);
             return values;
         }
     }

src/NetCoreStack.Proxy/ProxyParameterDescriptor.cs

@@ -1,25 +1,32 @@
 using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Mvc.Abstractions;
+using System;
 using System.Collections.Generic;
-using System.Linq;
 using System.Reflection;
 
 namespace NetCoreStack.Proxy
 {
     public class ProxyParameterDescriptor : ParameterDescriptor
     {
-        public List<PropertyInfo> Properties { get; }
-
-        public bool EnsureMultipartFormData { get; }
-
-
+        public IDictionary<string, PropertyContentTypeInfo> Properties { get; }
+        
+        public bool HasFormFile { get; }
 
         public ProxyParameterDescriptor(List<PropertyInfo> properties)
         {
-            Properties = properties;
-            EnsureMultipartFormData = Properties
-                .Where(p => typeof(IFormFile).IsAssignableFrom(p.PropertyType) ||
-                typeof(byte[]).IsAssignableFrom(p.PropertyType)).Any();
+            Properties = new Dictionary<string, PropertyContentTypeInfo>(StringComparer.OrdinalIgnoreCase);
+
+            foreach (var prop in properties)
+            {
+                PropertyContentType contentType = PropertyContentType.String;
+                if (typeof(IFormFile).IsAssignableFrom(prop.PropertyType))
+                {
+                    HasFormFile = true;
+                    contentType = PropertyContentType.Multipart;
+                }
+
+                Properties.Add(prop.Name, new PropertyContentTypeInfo(prop, contentType));
+            }
         }
     }
 }