/// <summary>
/// constructor, create new instance of HttpSender
/// </summary>
/// <param name="client">System.Net.Http.HttpClient</param>
/// <param name="options"></param>
/// <param name="logger">Microsoft.Extensions.Logging.ILogger</param>
/// <param name="responseFactory"></param>
///
protected HttpSenderBase(HttpClient client, HttpSenderOptions options, IResponseFactory responseFactory, ILogger logger)
{
_client = client;
_options = options;
_logger = logger;
ResponseFactory = responseFactory;
}
/// <inheritdoc/>
protected override HttpContent CreateContent <T>(T body, HttpSenderOptions options)
{
if (body is byte[] bytes)
{
return(HttpSenderHelper.CreateByteArrayContent(bytes));
}
return(HttpSenderHelper.CreateStringContent(Serialize(body, options), true));
}
/// <inheritdoc/>
protected override string Serialize <T>(T obj, HttpSenderOptions options)
{
if (obj == null)
{
return(string.Empty);
}
if (obj is string s)
{
return(s);
}
return(JsonConvert.SerializeObject(obj, options.JsonParseSettings.Serializing));
}
/// <inheritdoc/>
protected override IResponse <T> Deserialize <T>(string str, HttpSenderOptions options)
{
var jBody = JToken.Parse(str);
if (options.ValidateErrorsInResponse && TryExtractErrorFromBody(jBody, out var err))
{
return(ResponseFactory.CreateFault <T>(err));
}
var result = jBody.ToObject <T>(JsonSerializer.Create(options.JsonParseSettings.Deserializing));
return(ResponseFactory.CreateSuccess(result));
}
private IResponse <T> DoDeserialize <T>(string str, HttpSenderOptions options)
where T : new()
{
if (string.IsNullOrEmpty(str))
{
return(ResponseFactory.CreateSuccess(new T()));
}
if (typeof(T).IsValueType || typeof(T) == typeof(string))
{
return(ResponseFactory.CreateSuccess((T)Convert.ChangeType(str, typeof(T))));
}
return(Deserialize <T>(str, options));
}
/// <inheritdoc/>
protected override IResponse <T> Deserialize <T>(string str, HttpSenderOptions options)
{
var doc = XDocument.Parse(str);
if (options.ValidateErrorsInResponse && TryExtractErrorFromBody(doc, out var err))
{
return(ResponseFactory.CreateFault <T>(err));
}
if (options.XmlParseSettings.Deserialize.RemoveEmptyElements)
{
XmlUtils.RemoveEmptyElementsFrom(doc);
}
if (options.XmlParseSettings.Deserialize.RemoveNilElements)
{
doc.RemoveNilElements();
}
return(ResponseFactory.CreateSuccess(XmlUtils.CastXDocumentToObj <T>(doc)));
}
/// <summary>
///
/// </summary>
/// <param name="requestType"></param>
/// <param name="apiMethod"></param>
/// <param name="body"></param>
/// <param name="cancel"></param>
/// <param name="cfgAction"></param>
/// <typeparam name="TReq"></typeparam>
/// <typeparam name="TResp"></typeparam>
/// <returns></returns>
public async Task <IResponse <TResp> > SendHttpRequest <TReq, TResp>(HttpMethod requestType, string apiMethod, TReq body, CancellationToken cancel = default,
Action <HttpSenderOptions, CustomHttpHeaders> cfgAction = default)
where TResp : new()
{
HttpSenderOptions options;
var headers = new CustomHttpHeaders();
if (cfgAction == default)
{
options = _options;
}
else
{
options = new HttpSenderOptions();
cfgAction.Invoke(options, headers);
}
var content = DoCreateContent(body, options);
return(await SendHttpRequest <TResp>(requestType, apiMethod, content, cancel, options, headers));
}
/// <inheritdoc/>
protected override string Serialize <T>(T obj, HttpSenderOptions options)
{
if (obj == null)
{
return(string.Empty);
}
if (obj is string s)
{
return(s);
}
var doc = XmlUtils.CastObjToXDocument(obj);
if (options.XmlParseSettings.Serialize.RemoveEmptyElements)
{
XmlUtils.RemoveEmptyElementsFrom(doc);
}
if (options.XmlParseSettings.Serialize.RemoveNilElements)
{
doc.RemoveNilElements();
}
return(doc.ToString());
}
/// <summary>
/// constructor, create new instance of HttpSender
/// </summary>
/// <param name="client">System.Net.Http.HttpClient</param>
/// <param name="options">http sender ext params</param>
/// <param name="responseFactory"></param>
/// <param name="logger">Microsoft.Extensions.Logging.ILogger</param>
protected HttpSenderXml(HttpClient client, HttpSenderOptions options, IResponseFactory responseFactory, ILogger <HttpSenderXml> logger)
: base(client, options, responseFactory, logger)
{
}
internal static void PutHttpSenderOptionsInPool <T>(this IServiceCollection services, HttpSenderOptions options)
{
services.TryAddSingleton <IHttpSenderOptionsPool>(HttpSenderOptionsPool.CreateInstance());
var pool = services.BuildServiceProvider().GetService <IHttpSenderOptionsPool>();
if (pool == null)
{
throw new ArgumentNullException();
}
pool.Put <T>(options);
}
/// <summary> /// create request content by body type /// <param name="body">object query</param> /// <param name="options">options</param> /// </summary> /// <returns>stringr</returns> protected abstract HttpContent CreateContent <T>(T body, HttpSenderOptions options);
/// <summary> /// serialize http request class to string /// <param name="obj">object to serializing</param> /// <param name="options">serialize options</param> /// </summary> /// <returns>stringr</returns> protected abstract string Serialize <T>(T obj, HttpSenderOptions options);
// where TOut : IFail, new();
/// <summary>
/// deserialize http response body to class
/// <param name="str">string to deserializing</param>
/// <param name="options">deserialize options</param>
/// </summary>
/// <returns>T resolver</returns>
protected abstract IResponse <T> Deserialize <T>(string str, HttpSenderOptions options)
where T : new();
private HttpContent DoCreateContent <T>(T body, HttpSenderOptions options)
{
return(body == null ? null : CreateContent(body, options));
}
/// <summary>
///
/// </summary>
/// <param name="requestType"></param>
/// <param name="apiMethod"></param>
/// <param name="content"></param>
/// <param name="cancel"></param>
/// <param name="options"></param>
/// <param name="headers"></param>
/// <typeparam name="TResp"></typeparam>
/// <returns></returns>
public async Task <IResponse <TResp> > SendHttpRequest <TResp>(HttpMethod requestType, string apiMethod, HttpContent content,
CancellationToken cancel = default, HttpSenderOptions options = default, CustomHttpHeaders headers = default)
where TResp : new()
{
var uri = new Uri(_client.BaseAddress, apiMethod);
var senderOptions = options ?? _options ?? new HttpSenderOptions();
var senderHeaders = headers ?? new CustomHttpHeaders();
using (var request = new HttpRequestMessage(requestType, uri))
{
request.Content = content;
request.AppendHeaders(senderHeaders);
using (var cts = HttpSenderHelper.CreateCancellationTokenSource(senderOptions.RequestTimeout, cancel))
{
try
{
_logger.LogDebug($"Request: [{requestType.ToString().ToUpper()}] {uri.AbsoluteUri}");
_logger.LogDebug(await content.ReadAsStringAsync());
var response = await _client.SendAsync(request, cts?.Token ?? cancel);
var bodyAsStr = await HttpSenderHelper.ExtractBodyAsync(response.Content);
_logger.LogDebug("Response: " + bodyAsStr);
return(HasNotOkStatusCode(response)
? ResponseFactory.CreateFault <TResp>(new HttpFail(response.StatusCode, response.ReasonPhrase))
: DoDeserialize <TResp>(bodyAsStr, senderOptions));
}
catch (OperationCanceledException oex)
{
var errMsg = cancel.IsCancellationRequested
? $"Client cancel task: {oex.Message}"
: $"Connection timeout: {oex.Message}";
return(ResponseFactory.CreateFault <TResp>(new HttpFail(errMsg)));
}
catch (Exception ex)
{
return(ResponseFactory.CreateFault <TResp>(new HttpFail(ex.Message, ex.InnerException)));
}
}
}
}
