private static void AddBody(RequestOption request, HttpRequestMessage requestMessage)
{
if (!string.IsNullOrWhiteSpace(request.Body))
{
requestMessage.Content = new StringContent(request.Body);
AddContentHeaders(request, requestMessage);
}
}
public Task <IActionResult> Post([FromBody] RequestOption request)
{
if (request is null)
{
throw new ArgumentNullException(nameof(request));
}
return(this.HandlePostRequest(request));
}
/// <summary>
/// Post data to service.
/// </summary>
/// <param name="request">The request data.</param>
/// <returns><see cref="HttpResponseMessage"/> class.</returns>
public Task <HttpResponseMessage> SendAsync(RequestOption request)
{
if (request is null)
{
throw new ArgumentNullException(nameof(request));
}
return(this.ExecuteAsync(request));
}
private static void AddHeaders(RequestOption request, HttpRequestMessage requestMessage)
{
if (request.Headers != null && request.Headers.Count > 0)
{
var headers = request.Headers;
foreach (var header in headers)
{
requestMessage.Headers.Add(header.Key, header.Value);
}
}
}
private static HttpRequestMessage CreateRequestMessage(RequestOption request)
{
var requestMessage = new HttpRequestMessage
{
RequestUri = request.RequestUri,
Method = new HttpMethod(request.Method),
};
AddHeaders(request, requestMessage);
AddBody(request, requestMessage);
return(requestMessage);
}
private async Task <IActionResult> HandlePostRequest(RequestOption request)
{
Console.WriteLine($"Request {request.Id} received");
await Semaphore.WaitAsync().ConfigureAwait(false);
// Critical code to ensure only single request goes in asynchrously.
try
{
int numberOfRequestAllowed = this.cache.Get <int>(RequestAllowedKey);
if (numberOfRequestAllowed == 0)
{
var res = new ObjectResult(new Response()
{
Id = request.Id
})
{
StatusCode = 429,
};
this.HttpContext.Response.Headers.Add("Retry-After", new StringValues(TimeSpan.FromSeconds(5).ToString()));
Console.WriteLine($"Request {request.Id} rejected with 429");
return(res);
}
else
{
this.cache.Set(RequestAllowedKey, numberOfRequestAllowed - 1);
}
}
finally
{
Semaphore.Release();
}
await Task.Delay(TimeSpan.FromSeconds(1)).ConfigureAwait(false);
this.cache.Set(RequestAllowedKey, this.cache.Get <int>(RequestAllowedKey) + 1);
Console.WriteLine($"Request {request.Id} completed with 200");
return(new OkObjectResult(new Response()
{
Id = request.Id
}));
}
public async Task <ResponseContext <TResponse> > PostAsync <TRequest, TResponse>(string url, RequestContext <TRequest> requestContext, RequestOption option = null)
where TRequest : IRequestData
where TResponse : IResponseData
{
var req = new RestRequest(CallTo(url));
if (option == null)
{
req.Method = Method.POST;
}
else
{
switch (option.Method)
{
case RequestMethod.Delete:
req.Method = Method.DELETE;
break;
case RequestMethod.Patch:
req.Method = Method.PATCH;
break;
case RequestMethod.Put:
req.Method = Method.PUT;
break;
default:
req.Method = Method.POST;
break;
}
}
req.AddParameter("application/json; charset=utf-8", JsonConvert.SerializeObject(requestContext), ParameterType.RequestBody);
if (!option?.SkipAuth ?? false)
{
AddAuthenticationToken(requestContext.AuthToken);
}
var res = await Client.ExecuteTaskAsync <ResponseContext <TResponse> >(req);
return(ProcessResult(res));
}
public async Task <ResponseContext <TResponse> > GetAsync <TResponse>(string url, RequestOption option = null)
where TResponse : IResponseData
{
var req = new RestRequest(CallTo(url));
if (option?.RequestParams?.Keys?.Count > 0)
{
foreach (var pair in option.RequestParams)
{
req.AddQueryParameter(pair.Key, pair.Value.ToString(), true);
}
}
var res = await Client.ExecuteTaskAsync <ResponseContext <TResponse> >(req);
return(ProcessResult(res));
}
private Task <HttpResponseMessage> ExecuteAsync(RequestOption request)
{
var requestMessage = CreateRequestMessage(request);
return(this.client.SendAsync(requestMessage));
}
public RequestOptionAbility(RequestOption requestOption, IAbility ability)
{
RequestOption = requestOption;
Ability = ability;
}
