Expose response ContentTypes in api-definition and use them in proxies

framework/src/Volo.Abp.AspNetCore.Mvc/Volo/Abp/AspNetCore/Mvc/AspNetCoreApiDescriptionModelProvider.cs

@@ -175,7 +175,8 @@ private async Task AddApiDescriptionToModelAsync(
                 GetSupportedVersions(controllerType, method, setting),
                 allowAnonymous,
                 authorizeModels,
-                implementFrom
+                implementFrom,
+                GetReturnValueContentTypes(apiDescription)
             )
         );
 
@@ -199,6 +200,27 @@ private async Task AddApiDescriptionToModelAsync(
         }
     }
 
+    private static List<string>? GetReturnValueContentTypes(ApiDescription apiDescription)
+    {
+        var preferred = apiDescription.SupportedResponseTypes
+            .FirstOrDefault(x => x.StatusCode == 200 && x.ApiResponseFormats.Any())
+            ?? apiDescription.SupportedResponseTypes
+                .FirstOrDefault(x => x.StatusCode is >= 200 and < 300 && x.ApiResponseFormats.Any());
+
+        if (preferred == null)
+        {
+            return null;
+        }
+
+        var contentTypes = preferred.ApiResponseFormats
+            .Select(f => f.MediaType)
+            .Where(m => !string.IsNullOrWhiteSpace(m))
+            .Distinct()
+            .ToList();
+
+        return contentTypes.Count > 0 ? contentTypes : null;
+    }
+
     private static List<string> GetSupportedVersions(Type controllerType, MethodInfo method,
         ConventionalControllerSetting? setting)
     {

framework/src/Volo.Abp.Http.Client/Volo/Abp/Http/Client/ClientProxying/ClientProxyBase.cs

@@ -108,8 +108,7 @@ protected virtual async Task<T> RequestAsync<T>(ClientProxyRequestContext reques
     {
         var responseContent = await RequestAsync(requestContext);
 
-        if (typeof(T) == typeof(IRemoteStreamContent) ||
-            typeof(T) == typeof(RemoteStreamContent))
+        if (typeof(T) == typeof(IRemoteStreamContent) || typeof(T) == typeof(RemoteStreamContent))
         {
             /* returning a class that holds a reference to response
              * content just to be sure that GC does not dispose of
@@ -127,7 +126,8 @@ await responseContent.ReadAsStreamAsync(),
             var stringContent = await responseContent.ReadAsStringAsync();
             if (typeof(T) == typeof(string))
             {
-                return (T)(object)stringContent;
+                var unwrapped = UnwrapStringResponse(stringContent, responseContent.Headers?.ContentType?.MediaType);
+                return (T)(object)unwrapped!;
             }
 
             if (stringContent.IsNullOrWhiteSpace())
@@ -139,6 +139,39 @@ await responseContent.ReadAsStreamAsync(),
         }
     }
 
+    protected virtual string? UnwrapStringResponse(string body, string? contentType)
+    {
+        if (body.IsNullOrEmpty() || contentType.IsNullOrWhiteSpace())
+        {
+            return body;
+        }
+
+        if (!IsJsonMediaType(NormalizeMediaType(contentType!)))
+        {
+            return body;
+        }
+
+        try
+        {
+            var parsed = JsonSerializer.Deserialize<string>(body);
+            return parsed ?? string.Empty;
+        }
+        catch
+        {
+            return body;
+        }
+    }
+
+    protected static string NormalizeMediaType(string mediaType)
+    {
+        if (mediaType.IsNullOrWhiteSpace())
+        {
+            return string.Empty;
+        }
+        var semi = mediaType.IndexOf(';');
+        return (semi < 0 ? mediaType : mediaType.Substring(0, semi)).Trim().ToLowerInvariant();
+    }
+
     protected virtual async Task<HttpContent> RequestAsync(ClientProxyRequestContext requestContext)
     {
         var clientConfig = ClientOptions.Value.HttpClientProxies.GetOrDefault(requestContext.ServiceType) ?? throw new AbpException($"Could not get HttpClientProxyConfig for {requestContext.ServiceType.FullName}.");
@@ -326,14 +359,7 @@ protected virtual void AddHeaders(
         HttpRequestMessage requestMessage,
         ApiVersionInfo apiVersion)
     {
-        //API Version
-        if (!apiVersion.Version.IsNullOrEmpty())
-        {
-            //TODO: What about other media types?
-            requestMessage.Headers.Add("accept", $"{MimeTypes.Text.Plain}; v={apiVersion.Version}");
-            requestMessage.Headers.Add("accept", $"{MimeTypes.Application.Json}; v={apiVersion.Version}");
-            requestMessage.Headers.Add("api-version", apiVersion.Version);
-        }
+        AddAcceptHeaders(action, requestMessage, apiVersion);
 
         //Header parameters
         var headers = action.Parameters.Where(p => p.BindingSourceId == ParameterBindingSources.Header).ToArray();
@@ -378,6 +404,57 @@ protected virtual void AddHeaders(
         }
     }
 
+    protected virtual void AddAcceptHeaders(
+        ActionApiDescriptionModel action,
+        HttpRequestMessage requestMessage,
+        ApiVersionInfo apiVersion)
+    {
+        var acceptForReturn = GetAcceptForActionReturn(action);
+        var versionSuffix = apiVersion.Version.IsNullOrEmpty() ? string.Empty : $"; v={apiVersion.Version}";
+
+        if (!acceptForReturn.IsNullOrEmpty())
+        {
+            requestMessage.Headers.Add("accept", acceptForReturn + versionSuffix);
+        }
+        else
+        {
+            requestMessage.Headers.Add("accept", MimeTypes.Text.Plain + versionSuffix);
+            requestMessage.Headers.Add("accept", MimeTypes.Application.Json + versionSuffix);
+        }
+
+        if (!apiVersion.Version.IsNullOrEmpty())
+        {
+            requestMessage.Headers.Add("api-version", apiVersion.Version);
+        }
+    }
+
+    protected virtual string? GetAcceptForActionReturn(ActionApiDescriptionModel action)
+    {
+        if (action.ReturnValue.IsRemoteStream ||
+            action.ReturnValue.Type == typeof(IRemoteStreamContent).FullName ||
+            action.ReturnValue.Type == typeof(RemoteStreamContent).FullName)
+        {
+            return MimeTypes.Application.OctetStream;
+        }
+
+        var contentTypes = action.ReturnValue.ContentTypes;
+        if (contentTypes == null || contentTypes.Count == 0)
+        {
+            return null;
+        }
+
+        var normalized = contentTypes.Select(NormalizeMediaType).ToList();
+
+        return normalized.FirstOrDefault(IsJsonMediaType) ?? normalized[0];
+    }
+
+    private static bool IsJsonMediaType(string normalizedMediaType)
+    {
+        return normalizedMediaType.Equals(MimeTypes.Application.Json, StringComparison.OrdinalIgnoreCase) ||
+               normalizedMediaType.Equals("text/json", StringComparison.OrdinalIgnoreCase) ||
+               normalizedMediaType.EndsWith("+json", StringComparison.OrdinalIgnoreCase);
+    }
+
     protected virtual StringSegment RemoveQuotes(StringSegment input)
     {
         if (!StringSegment.IsNullOrEmpty(input) && input.Length >= 2 && input[0] == '"' && input[input.Length - 1] == '"')

framework/src/Volo.Abp.Http/Volo/Abp/Http/Modeling/ActionApiDescriptionModel.cs

@@ -45,7 +45,7 @@ public ActionApiDescriptionModel()
 
     }
 
-    public static ActionApiDescriptionModel Create([NotNull] string uniqueName, [NotNull] MethodInfo method, [NotNull] string url, string? httpMethod, [NotNull] IList<string> supportedVersions, bool? allowAnonymous = null, IList<AuthorizeDataApiDescriptionModel>? authorizeDatas = null, string? implementFrom = null)
+    public static ActionApiDescriptionModel Create([NotNull] string uniqueName, [NotNull] MethodInfo method, [NotNull] string url, string? httpMethod, [NotNull] IList<string> supportedVersions, bool? allowAnonymous = null, IList<AuthorizeDataApiDescriptionModel>? authorizeDatas = null, string? implementFrom = null, IList<string>? returnValueContentTypes = null)
     {
         Check.NotNull(uniqueName, nameof(uniqueName));
         Check.NotNull(method, nameof(method));
@@ -58,7 +58,7 @@ public static ActionApiDescriptionModel Create([NotNull] string uniqueName, [Not
             Name = method.Name,
             Url = url,
             HttpMethod = httpMethod,
-            ReturnValue = ReturnValueApiDescriptionModel.Create(method.ReturnType),
+            ReturnValue = ReturnValueApiDescriptionModel.Create(method.ReturnType, returnValueContentTypes),
             Parameters = new List<ParameterApiDescriptionModel>(),
             ParametersOnMethod = method
                 .GetParameters()

framework/src/Volo.Abp.Http/Volo/Abp/Http/Modeling/ReturnValueApiDescriptionModel.cs

@@ -1,4 +1,6 @@
 using System;
+using System.Collections.Generic;
+using Volo.Abp.Content;
 using Volo.Abp.Reflection;
 using Volo.Abp.Threading;
 
@@ -13,19 +15,30 @@ public class ReturnValueApiDescriptionModel
 
     public string? Summary { get; set; }
 
+    public IList<string>? ContentTypes { get; set; }
+
+    public bool IsRemoteStream { get; set; }
+
     public ReturnValueApiDescriptionModel()
     {
 
     }
 
-    public static ReturnValueApiDescriptionModel Create(Type type)
+    public static ReturnValueApiDescriptionModel Create(Type type, IList<string>? contentTypes = null)
     {
         var unwrappedType = AsyncHelper.UnwrapTask(type);
 
         return new ReturnValueApiDescriptionModel
         {
             Type = TypeHelper.GetFullNameHandlingNullableAndGenerics(unwrappedType),
-            TypeSimple = ApiTypeNameHelper.GetSimpleTypeName(unwrappedType)
+            TypeSimple = ApiTypeNameHelper.GetSimpleTypeName(unwrappedType),
+            ContentTypes = contentTypes,
+            IsRemoteStream = IsRemoteStreamType(unwrappedType)
         };
     }
+
+    private static bool IsRemoteStreamType(Type type)
+    {
+        return type == typeof(IRemoteStreamContent) || type == typeof(RemoteStreamContent);
+    }
 }

framework/src/Volo.Abp.Http/Volo/Abp/Http/ProxyScripting/Generators/JQuery/JQueryProxyScriptGenerator.cs

@@ -135,17 +135,64 @@ private static void AddActionScript(StringBuilder script, string controllerName,
 
         AddAjaxCallParameters(script, action);
 
-        var ajaxParamsIsFromForm = action.Parameters.Any(x => x.BindingSourceId == ParameterBindingSources.Form);
-        var dataType = action.ReturnValue.Type == ReturnValueApiDescriptionModel.Create(typeof(string)).Type
-            ? "{ dataType: 'text' }, "
-            : string.Empty;
+        var hasFormFile = action.Parameters.Any(x => x.BindingSourceId == ParameterBindingSources.FormFile);
+        var ajaxParamsIsFromForm = !hasFormFile && action.Parameters.Any(x => x.BindingSourceId == ParameterBindingSources.Form);
+        var dataType = GetJQueryDataTypeAndAcceptOverride(action);
         script.AppendLine(ajaxParamsIsFromForm
             ? "      }, $.extend(true, {}, " + dataType + "{ contentType: 'application/x-www-form-urlencoded; charset=UTF-8' }, ajaxParams)));"
             : "      }, " + dataType + "ajaxParams));");
 
         script.AppendLine("    };");
     }
 
+    private static string GetJQueryDataTypeAndAcceptOverride(ActionApiDescriptionModel action)
+    {
+        if (action.ReturnValue.IsRemoteStream)
+        {
+            return string.Empty;
+        }
+
+        var contentTypes = action.ReturnValue.ContentTypes;
+        var isStringReturn = action.ReturnValue.Type == ReturnValueApiDescriptionModel.Create(typeof(string)).Type;
+
+        if (contentTypes is { Count: > 0 })
+        {
+            var normalized = contentTypes.Select(NormalizeMediaType).ToList();
+
+            var firstJsonShaped = normalized.FirstOrDefault(IsJsonMediaType);
+            if (firstJsonShaped != null)
+            {
+                return "{ dataType: 'json', headers: { Accept: '" + firstJsonShaped + "' } }, ";
+            }
+
+            if (normalized.All(ct => ct.StartsWith("text/", StringComparison.OrdinalIgnoreCase)))
+            {
+                return "{ dataType: 'text', headers: { Accept: '" + normalized[0] + "' } }, ";
+            }
+
+            return "{ headers: { Accept: '" + normalized[0] + "' } }, ";
+        }
+
+        return isStringReturn ? "{ dataType: 'text' }, " : string.Empty;
+    }
+
+    private static bool IsJsonMediaType(string normalizedMediaType)
+    {
+        return normalizedMediaType.Equals("application/json", StringComparison.OrdinalIgnoreCase) ||
+               normalizedMediaType.Equals("text/json", StringComparison.OrdinalIgnoreCase) ||
+               normalizedMediaType.EndsWith("+json", StringComparison.OrdinalIgnoreCase);
+    }
+
+    private static string NormalizeMediaType(string mediaType)
+    {
+        if (string.IsNullOrWhiteSpace(mediaType))
+        {
+            return string.Empty;
+        }
+        var semi = mediaType.IndexOf(';');
+        return (semi < 0 ? mediaType : mediaType.Substring(0, semi)).Trim().ToLowerInvariant();
+    }
+
     private static string FindBestApiVersion(ActionApiDescriptionModel action)
     {
         //var configuredVersion = GetConfiguredApiVersion(); //TODO: Implement
@@ -184,6 +231,20 @@ private static void AddAjaxCallParameters(StringBuilder script, ActionApiDescrip
             script.Append("        headers: " + headers);
         }
 
+        var firstFileParam = action.Parameters.FirstOrDefault(p => p.BindingSourceId == ParameterBindingSources.FormFile);
+        if (firstFileParam != null)
+        {
+            var fileVar = ProxyScriptingJsFuncHelper.NormalizeJsVariableName(firstFileParam.NameOnMethod.ToCamelCase());
+            script.AppendLine(",");
+            script.Append("        data: " + fileVar + ",");
+            script.AppendLine();
+            script.Append("        processData: false,");
+            script.AppendLine();
+            script.Append("        contentType: false");
+            script.AppendLine();
+            return;
+        }
+
         var body = ProxyScriptingHelper.GenerateBody(action);
         if (!body.IsNullOrEmpty())
         {