private GetResultsResponse GetSearchResultsResponse(WebClientResponseMessage responseMessage)
{
var responseJson = Encoding.UTF8.GetString(responseMessage.Data);
var response = JsonConvert.DeserializeObject <GetResultsResponse>(responseJson);
return(response);
}
public async Task <IResponse <T> > GetAsync <T>(WebGetRequest request)
{
WebClientResponseMessage postResponse = null;
WebResponse <T> response = default(WebResponse <T>);
var serializeSettings = GetSerializerSettings(request.SerializerSettings);
var startTimestamp = DateTime.UtcNow;
var watch = new Stopwatch();
var clientSettings = GetClientSettings(request.ClientSetting);
try
{
new RequestValidator().Validate(request);
try
{
var webClientRequest = new WebClientRequestMessage()
{
Url = request.EndPoint.Url
};
foreach (var headerName in clientSettings.Headers.AllKeys)
{
webClientRequest.RequestHeaders.Add(headerName, clientSettings.Headers[headerName]);
}
webClientRequest.ContentHeaders.Add("content-type", clientSettings.ContentType);
watch.Start();
postResponse = await _client.GetAsync(webClientRequest, clientSettings, new CancellationToken());
watch.Stop();
}
catch (Exception exception)
{
if (watch.IsRunning)
{
watch.Stop();
}
throw new ClientCommunicationException(request.EndPoint, exception);
}
response = GetResponse <T>(postResponse, serializeSettings);
}
finally
{
if (watch.IsRunning)
{
watch.Stop();
}
var url = string.Empty;
if (request.EndPoint != null)
{
url = request.EndPoint.Url;
}
await Log(postResponse, null, url, response, watch.ElapsedMilliseconds, clientSettings, url, startTimestamp);
}
return(response);
}
private Type GetErrorPayloadType(WebClientResponseMessage webClientResponseMessage)
{
Type selectedPayloadType = DefaultCallerSettings.DefaultErrorPayloadType;
if (_errorPayloadType != null)
{
selectedPayloadType = _errorPayloadType;
}
else if (Settings.ErrorPayloadType != null)
{
selectedPayloadType = Settings.ErrorPayloadType;
}
if (_errorPayloadTypeSelector != null)
{
return(_errorPayloadTypeSelector.GetReturnObjectType(webClientResponseMessage, selectedPayloadType));
}
return(selectedPayloadType);
}
private async Task Log(WebClientResponseMessage postResponse, object request, string postRequest, object response, double timeTakenInMiliseconds, ClientSetting clientSetting, string url, DateTime startTimestamp)
{
try
{
if (_logger != null)
{
var strResponse = string.Empty;
if (postResponse?.Data != null)
{
strResponse = clientSetting.Encoding.GetString(postResponse.Data);
}
await _logger.RaiseLogEvent(request, response, postRequest, strResponse, timeTakenInMiliseconds / 1000, postResponse, clientSetting.Headers, url, startTimestamp);
}
}
catch (Exception exception)
{
throw new LoggingException("Exception occurred at the time of logging", exception);
}
}
private WebResponse <T> GetResponse <T>(WebClientResponseMessage response, object serializerSettings)
{
try
{
if (response != null)
{
var type = GetErrorPayloadType(response);
if (response.HttpStatusCode == HttpStatusCode.OK || type == typeof(T))
{
return new WebResponse <T>()
{
ReturnObject = _serializer.Deserialize <T>(response.Data, serializerSettings),
IsSuccess = true,
HttpStatusCode = response.HttpStatusCode
}
}
;
MethodInfo method = _serializer.GetType().GetMethod("Deserialize").MakeGenericMethod(type);
var errorPayload = method.Invoke(_serializer, new[] { response.Data, serializerSettings });
return(new WebResponse <T>()
{
ErrorPayLoad = errorPayload,
IsSuccess = false,
HttpStatusCode = response.HttpStatusCode
});
}
}
catch (Exception exception)
{
throw new SerializationException("Exception occurred at the time of desrialization", exception);
}
return(new WebResponse <T>()
{
IsSuccess = false
});
}
public async Task RaiseLogEvent(object request, object response, string requestString, string responseString, double timeTakenInSeconds, WebClientResponseMessage webClientResponseMessage, NameValueCollection requestHeaders, string url, DateTime startTimestamp)
{
if (OnLogging != null)
{
var eventArgs = new LogEventArgs()
{
RequestString = requestString,
Request = request,
ResponseString = responseString,
Response = response,
TimeTakenInSeconds = timeTakenInSeconds,
RequestHeaders = requestHeaders,
Url = url,
Timestamp = startTimestamp
};
if (webClientResponseMessage != null)
{
eventArgs.HttpStatusCode = webClientResponseMessage.HttpStatusCode;
eventArgs.ContentHeaders = webClientResponseMessage.ContentHeaders;
eventArgs.ResponseHeaders = webClientResponseMessage.ResponseHeaders;
}
await OnLogging(null, eventArgs);
}
}
public Type GetReturnObjectType(WebClientResponseMessage webClientResponseMessage, Type selectedType)
{
return(_errorPayloadtype.Invoke(webClientResponseMessage, selectedType));
}
