jhenriquecosta

WEBAPICLIENT

Oct 27th, 2021
995
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. using System;
  2. using System.IO;
  3. using System.Threading.Tasks;
  4. using Abp.Configuration.Startup;
  5. using Abp.Dependency;
  6. using Abp.UI;
  7. using Abp.Web.Models;
  8. using Flurl.Http;
  9. using Flurl.Http.Content;
  10. using MyCompanyName.AbpZeroTemplate.Extensions;
  11.  
  12. namespace MyCompanyName.AbpZeroTemplate.ApiClient
  13. {
  14.     public class AbpApiClient : ISingletonDependency, IDisposable
  15.     {
  16.         private readonly IAccessTokenManager _accessTokenManager;
  17.         private readonly IApplicationContext _applicationContext;
  18.         private readonly IMultiTenancyConfig _multiTenancyConfig;
  19.         private static FlurlClient _client;
  20.  
  21.         public static int? TimeoutSeconds { get; set; } = 30;
  22.  
  23.         public AbpApiClient(
  24.             IAccessTokenManager accessTokenManager,
  25.             IApplicationContext applicationContext,
  26.             IMultiTenancyConfig multiTenancyConfig)
  27.         {
  28.             _accessTokenManager = accessTokenManager;
  29.             _applicationContext = applicationContext;
  30.             _multiTenancyConfig = multiTenancyConfig;
  31.         }
  32.  
  33.         #region PostAsync<T>
  34.  
  35.         public async Task<T> PostAsync<T>(string endpoint)
  36.         {
  37.             return await PostAsync<T>(endpoint, null, null, _accessTokenManager.GetAccessToken(), true);
  38.         }
  39.  
  40.         public async Task<T> PostAnonymousAsync<T>(string endpoint)
  41.         {
  42.             return await PostAsync<T>(endpoint, null, null, null, true);
  43.         }
  44.  
  45.         public async Task<T> PostAsync<T>(string endpoint, object inputDto)
  46.         {
  47.             return await PostAsync<T>(endpoint, inputDto, null, _accessTokenManager.GetAccessToken(), true);
  48.         }
  49.  
  50.         public async Task<T> PostAsync<T>(string endpoint, object inputDto, object queryParameters)
  51.         {
  52.             return await PostAsync<T>(endpoint, inputDto, queryParameters, _accessTokenManager.GetAccessToken(), true);
  53.         }
  54.  
  55.         /// <summary>
  56.         /// Makes POST request without authentication token.
  57.         /// </summary>
  58.         /// <typeparam name="T"></typeparam>
  59.         /// <param name="endpoint"></param>
  60.         /// <param name="inputDto"></param>
  61.         /// <returns></returns>
  62.         public async Task<T> PostAnonymousAsync<T>(string endpoint, object inputDto)
  63.         {
  64.             return await PostAsync<T>(endpoint, inputDto, null, null, true);
  65.         }
  66.  
  67.         public async Task<T> PostAsync<T>(string endpoint, object inputDto, object queryParameters, string accessToken, bool stripAjaxResponseWrapper)
  68.         {
  69.             var httpResponse = GetClient(accessToken)
  70.                 .Request(endpoint)
  71.                 .SetQueryParams(queryParameters)
  72.                 .PostJsonAsync(inputDto);
  73.  
  74.             if (stripAjaxResponseWrapper)
  75.             {
  76.                 var response = await httpResponse.ReceiveJson<AjaxResponse<T>>();
  77.                 ValidateAbpResponse(response);
  78.                 return response.Result;
  79.             }
  80.  
  81.             return await httpResponse.ReceiveJson<T>();
  82.         }
  83.  
  84.         public async Task<T> PostMultipartAsync<T>(string endpoint, Action<CapturedMultipartContent> buildContent, bool stripAjaxResponseWrapper = true)
  85.         {
  86.             var httpResponse = GetClient(_accessTokenManager.GetAccessToken())
  87.                 .Request(endpoint)
  88.                 .PostMultipartAsync(buildContent);
  89.  
  90.             if (stripAjaxResponseWrapper)
  91.             {
  92.                 var response = await httpResponse.ReceiveJson<AjaxResponse<T>>();
  93.                 ValidateAbpResponse(response);
  94.                 return response.Result;
  95.             }
  96.  
  97.             return await httpResponse.ReceiveJson<T>();
  98.         }
  99.  
  100.         public async Task<T> PostMultipartAsync<T>(string endpoint, Stream stream, string fileName, bool stripAjaxResponseWrapper = true)
  101.         {
  102.             var httpResponse = GetClient(_accessTokenManager.GetAccessToken())
  103.                     .Request(endpoint)
  104.                     .PostMultipartAsync(multiPartContent => multiPartContent.AddFile("file", stream, fileName));
  105.  
  106.             if (stripAjaxResponseWrapper)
  107.             {
  108.                 var response = await httpResponse.ReceiveJson<AjaxResponse<T>>();
  109.                 ValidateAbpResponse(response);
  110.                 return response.Result;
  111.             }
  112.  
  113.             return await httpResponse.ReceiveJson<T>();
  114.         }
  115.  
  116.         public async Task<T> PostMultipartAsync<T>(string endpoint, string filePath, bool stripAjaxResponseWrapper = true)
  117.         {
  118.             var httpResponse = GetClient(_accessTokenManager.GetAccessToken())
  119.                 .Request(endpoint)
  120.                 .PostMultipartAsync(multiPartContent => multiPartContent.AddFile("file", filePath));
  121.  
  122.             if (stripAjaxResponseWrapper)
  123.             {
  124.                 var response = await httpResponse.ReceiveJson<AjaxResponse<T>>();
  125.                 ValidateAbpResponse(response);
  126.                 return response.Result;
  127.             }
  128.  
  129.             return await httpResponse.ReceiveJson<T>();
  130.         }
  131.  
  132.         #endregion
  133.  
  134.         #region  PostAsync
  135.  
  136.         public async Task PostAsync(string endpoint)
  137.         {
  138.             await PostAsync(endpoint, null, null, _accessTokenManager.GetAccessToken(), true);
  139.         }
  140.  
  141.         public async Task PostAsync(string endpoint, object inputDto)
  142.         {
  143.             await PostAsync(endpoint, inputDto, null, _accessTokenManager.GetAccessToken(), true);
  144.         }
  145.  
  146.         /// <summary>
  147.         /// Makes POST request without authentication token.
  148.         /// </summary>
  149.         /// <param name="endpoint"></param>
  150.         /// <param name="inputDto"></param>
  151.         /// <returns></returns>
  152.         public async Task PostAnonymousAsync(string endpoint, object inputDto)
  153.         {
  154.             await PostAsync(endpoint, inputDto, null, null, true);
  155.         }
  156.  
  157.         public async Task PostAsync(string endpoint, object inputDto, object queryParameters)
  158.         {
  159.             await PostAsync(endpoint, inputDto, queryParameters, _accessTokenManager.GetAccessToken(), true);
  160.         }
  161.  
  162.         public async Task PostAsync(string endpoint, object inputDto, object queryParameters, string accessToken,
  163.             bool stripAjaxResponseWrapper)
  164.         {
  165.             await GetClient(accessToken)
  166.                   .Request(endpoint)
  167.                   .SetQueryParams(queryParameters)
  168.                   .PostJsonAsync(inputDto);
  169.         }
  170.  
  171.         #endregion
  172.  
  173.         #region  GetAsync<T>
  174.  
  175.         public async Task<T> GetAsync<T>(string endpoint)
  176.         {
  177.             return await GetAsync<T>(endpoint, null);
  178.         }
  179.  
  180.         /// <summary>
  181.         /// Makes GET request without authentication token.
  182.         /// </summary>
  183.         /// <typeparam name="T"></typeparam>
  184.         /// <param name="endpoint"></param>
  185.         /// <returns></returns>
  186.         public async Task<T> GetAnonymousAsync<T>(string endpoint)
  187.         {
  188.             return await GetAsync<T>(endpoint, null, null, true);
  189.         }
  190.  
  191.         public async Task<T> GetAsync<T>(string endpoint, object queryParameters)
  192.         {
  193.             return await GetAsync<T>(endpoint, queryParameters, _accessTokenManager.GetAccessToken(), true);
  194.         }
  195.  
  196.         public async Task<T> GetAsync<T>(string endpoint, object queryParameters, string accessToken, bool stripAjaxResponseWrapper)
  197.         {
  198.             var httpResponse = GetClient(accessToken)
  199.                 .Request(endpoint)
  200.                 .SetQueryParams(queryParameters);
  201.  
  202.             if (stripAjaxResponseWrapper)
  203.             {
  204.                 var response = await httpResponse.GetJsonAsync<AjaxResponse<T>>();
  205.                 ValidateAbpResponse(response);
  206.                 return response.Result;
  207.             }
  208.  
  209.             return await httpResponse.GetJsonAsync<T>();
  210.         }
  211.  
  212.         #endregion
  213.  
  214.         #region  GetAsync
  215.  
  216.         public async Task GetAsync(string endpoint)
  217.         {
  218.             await GetAsync(endpoint, null);
  219.         }
  220.  
  221.         public async Task GetAsync(string endpoint, object queryParameters)
  222.         {
  223.             await GetAsync(endpoint, queryParameters, _accessTokenManager.GetAccessToken(), true);
  224.         }
  225.  
  226.         public async Task GetAsync(string endpoint, object queryParameters, string accessToken, bool stripAjaxResponseWrapper)
  227.         {
  228.             await GetClient(accessToken)
  229.              .Request(endpoint)
  230.              .SetQueryParams(queryParameters)
  231.              .GetAsync();
  232.         }
  233.  
  234.         #endregion
  235.  
  236.         #region  GetStringAsync
  237.  
  238.         public async Task GetStringAsync(string endpoint)
  239.         {
  240.             await GetStringAsync(endpoint, null);
  241.         }
  242.  
  243.         public async Task GetStringAsync(string endpoint, object queryParameters)
  244.         {
  245.             await GetStringAsync(endpoint, queryParameters, _accessTokenManager.GetAccessToken());
  246.         }
  247.  
  248.         public async Task<string> GetStringAsync(string endpoint, object queryParameters, string accessToken)
  249.         {
  250.             return await GetClient(accessToken)
  251.                     .Request(endpoint)
  252.                     .SetQueryParams(queryParameters)
  253.                     .GetStringAsync();
  254.  
  255.         }
  256.  
  257.         #endregion
  258.  
  259.         #region DeleteAsync
  260.  
  261.         public async Task DeleteAsync(string endpoint)
  262.         {
  263.             await DeleteAsync(endpoint, null, _accessTokenManager.GetAccessToken());
  264.         }
  265.  
  266.         public async Task DeleteAsync(string endpoint, object queryParameters)
  267.         {
  268.             await DeleteAsync(endpoint, queryParameters, _accessTokenManager.GetAccessToken());
  269.         }
  270.  
  271.         public async Task DeleteAsync(string endpoint, object queryParameters, string accessToken)
  272.         {
  273.             await GetClient(accessToken)
  274.                     .Request(endpoint)
  275.                     .SetQueryParams(queryParameters)
  276.                     .DeleteAsync();
  277.         }
  278.  
  279.         #endregion
  280.  
  281.         #region DeleteAsync<T>
  282.  
  283.         public async Task<T> DeleteAsync<T>(string endpoint)
  284.         {
  285.             return await DeleteAsync<T>(endpoint, null);
  286.         }
  287.  
  288.         public async Task<T> DeleteAsync<T>(string endpoint, object queryParameters)
  289.         {
  290.             return await DeleteAsync<T>(endpoint, queryParameters, _accessTokenManager.GetAccessToken(), true);
  291.         }
  292.  
  293.         public async Task<T> DeleteAsync<T>(string endpoint, object queryParameters, string accessToken, bool stripAjaxResponseWrapper)
  294.         {
  295.             var httpResponse = GetClient(accessToken)
  296.                 .Request(endpoint)
  297.                 .SetQueryParams(queryParameters)
  298.                 .DeleteAsync();
  299.  
  300.             if (stripAjaxResponseWrapper)
  301.             {
  302.                 var response = await httpResponse.ReceiveJson<AjaxResponse<T>>();
  303.                 ValidateAbpResponse(response);
  304.                 return response.Result;
  305.             }
  306.  
  307.             return await httpResponse.ReceiveJson<T>();
  308.         }
  309.  
  310.         #endregion
  311.  
  312.         #region PutAsync<T>
  313.  
  314.         public async Task<T> PutAsync<T>(string endpoint)
  315.         {
  316.             return await PutAsync<T>(endpoint, null, null, _accessTokenManager.GetAccessToken(), true);
  317.         }
  318.  
  319.         public async Task<T> PutAsync<T>(string endpoint, object inputDto)
  320.         {
  321.             return await PutAsync<T>(endpoint, inputDto, null, _accessTokenManager.GetAccessToken(), true);
  322.         }
  323.  
  324.         public async Task<T> PutAsync<T>(string endpoint, object inputDto, object queryParameters)
  325.         {
  326.             return await PutAsync<T>(endpoint, inputDto, queryParameters, _accessTokenManager.GetAccessToken(), true);
  327.         }
  328.  
  329.         public async Task<T> PutAsync<T>(string endpoint, object inputDto, object queryParameters, string accessToken, bool stripAjaxResponseWrapper)
  330.         {
  331.             var httpResponse = GetClient(accessToken)
  332.                 .Request(endpoint)
  333.                 .SetQueryParams(queryParameters)
  334.                 .PutJsonAsync(inputDto);
  335.  
  336.             if (stripAjaxResponseWrapper)
  337.             {
  338.                 var response = await httpResponse.ReceiveJson<AjaxResponse<T>>();
  339.                 ValidateAbpResponse(response);
  340.                 return response.Result;
  341.             }
  342.  
  343.             return await httpResponse.ReceiveJson<T>();
  344.         }
  345.         #endregion
  346.  
  347.         #region  PutAsync
  348.  
  349.         public async Task PutAsync(string endpoint)
  350.         {
  351.             await PutAsync(endpoint, null, null, _accessTokenManager.GetAccessToken(), true);
  352.         }
  353.  
  354.         public async Task PutAsync(string endpoint, object inputDto)
  355.         {
  356.             await PutAsync(endpoint, inputDto, null, _accessTokenManager.GetAccessToken(), true);
  357.         }
  358.  
  359.         public async Task PutAsync(string endpoint, object inputDto, object queryParameters)
  360.         {
  361.             await PutAsync(endpoint, inputDto, queryParameters, _accessTokenManager.GetAccessToken(), true);
  362.         }
  363.  
  364.         public async Task PutAsync(string endpoint, object inputDto, object queryParameters, string accessToken,
  365.             bool stripAjaxResponseWrapper)
  366.         {
  367.             await GetClient(accessToken)
  368.                   .Request(endpoint)
  369.                   .SetQueryParams(queryParameters)
  370.                   .PutJsonAsync(inputDto);
  371.         }
  372.  
  373.         #endregion
  374.  
  375.         public FlurlClient GetClient(string accessToken)
  376.         {
  377.             if (_client == null)
  378.             {
  379.                 CreateClient();
  380.             }
  381.  
  382.             AddHeaders(accessToken);
  383.             return _client;
  384.         }
  385.  
  386.         private static void CreateClient()
  387.         {
  388.             _client = new FlurlClient(ApiUrlConfig.BaseUrl);
  389.  
  390.             if (TimeoutSeconds.HasValue)
  391.             {
  392.                 _client.WithTimeout(TimeoutSeconds.Value);
  393.             }
  394.         }
  395.  
  396.         private void AddHeaders(string accessToken)
  397.         {
  398.             _client.HttpClient.DefaultRequestHeaders.Clear();
  399.  
  400.             _client.WithHeader("Accept", "application/json");
  401.             _client.WithHeader("User-Agent", AbpZeroTemplateConsts.AbpApiClientUserAgent);
  402.             /* Disabled due to https://github.com/paulcbetts/ModernHttpClient/issues/198#issuecomment-181263988
  403.                _client.WithHeader("Accept-Encoding", "gzip,deflate");
  404.             */
  405.  
  406.             if (_applicationContext.CurrentLanguage != null)
  407.             {
  408.                 _client.WithHeader(".AspNetCore.Culture", "c=" + _applicationContext.CurrentLanguage.Name + "|uic=" + _applicationContext.CurrentLanguage.Name);
  409.             }
  410.  
  411.             if (_applicationContext.CurrentTenant != null)
  412.             {
  413.                 _client.WithHeader(_multiTenancyConfig.TenantIdResolveKey, _applicationContext.CurrentTenant.TenantId);
  414.             }
  415.  
  416.             if (accessToken != null)
  417.             {
  418.                 _client.WithOAuthBearerToken(accessToken);
  419.             }
  420.         }
  421.  
  422.         private static void ValidateAbpResponse(AjaxResponseBase response)
  423.         {
  424.             if (response == null)
  425.             {
  426.                 return;
  427.             }
  428.  
  429.             if (response.Success)
  430.             {
  431.                 return;
  432.             }
  433.  
  434.             if (response.Error == null)
  435.             {
  436.                 return;
  437.             }
  438.  
  439.             throw new UserFriendlyException(response.Error.GetConsolidatedMessage());
  440.         }
  441.  
  442.         public void Dispose()
  443.         {
  444.             _client?.Dispose();
  445.         }
  446.     }
  447. }
RAW Paste Data