public async Task AssignBatchActionResultsAsync(IODataClient client,
ODataResponse batchResponse, IList <Func <IODataClient, Task> > actions, IList <int> responseIndexes)
{
var exceptions = new List <Exception>();
for (var actionIndex = 0; actionIndex < actions.Count && !exceptions.Any(); actionIndex++)
{
var responseIndex = responseIndexes[actionIndex];
if (responseIndex >= 0 && responseIndex < batchResponse.Batch.Count)
{
var actionResponse = batchResponse.Batch[responseIndex];
if (actionResponse.Exception != null)
{
exceptions.Add(actionResponse.Exception);
}
else if (actionResponse.StatusCode >= (int)HttpStatusCode.BadRequest)
{
exceptions.Add(WebRequestException.CreateFromStatusCode((HttpStatusCode)actionResponse.StatusCode));
}
else
{
await actions[actionIndex](new ODataClient(client as ODataClient, actionResponse)).ConfigureAwait(false);
}
}
}
if (exceptions.Any())
{
throw exceptions.First();
}
}
/// <summary>
/// Transforms and throws the <see cref="IBusinessException"/> equivalent for an <see cref="Soc.WebRequestException"/>.
/// </summary>
/// <param name="wrex">The <see cref="Soc.WebRequestException"/>.</param>
public static void ThrowTransformedODataException(Soc.WebRequestException wrex)
{
if (wrex == null)
{
throw new ArgumentNullException(nameof(wrex));
}
}
private void WriteFeed(Edm edm, string absolutUri, string entitySetName, IList <IDictionary <string, object> > dataList)
{
ODataClient client = new ODataClient(new System.Uri(url));
ODataBatch batch = new ODataBatch(client);
foreach (IDictionary <string, object> data in dataList)
{
batch += c => client.For("Entry").Set(data).InsertEntryAsync();
}
System.Threading.Tasks.Task task = batch.ExecuteAsync();
WaitForTaskToComplete(task);
Exception e = task.Exception;
if (e != null)
{
if (e.InnerException is Simple.OData.Client.WebRequestException)
{
// this means we got a response from the server with a specific message.
Simple.OData.Client.WebRequestException inner = (Simple.OData.Client.WebRequestException)e.InnerException;
throw new System.Exception(inner.Message + " : " + inner.Response);
}
throw e;
}
}
private ODataEntry WriteEntity(Edm edm, string url, string entitySetName, IDictionary <string, object> data)
{
ODataClient client = new ODataClient(new System.Uri(url));
System.Threading.Tasks.Task <IDictionary <string, object> > task = client.For(entitySetName).Set(data).InsertEntryAsync();
WaitForTaskToComplete(task);
Exception e = task.Exception;
if (e != null)
{
if (e.InnerException is Simple.OData.Client.WebRequestException)
{
// this means we got a response from the server with a specific message.
Simple.OData.Client.WebRequestException inner = (Simple.OData.Client.WebRequestException)e.InnerException;
NeotysAPIException napie = NeotysAPIException.Parse(inner.Response);
if (napie != null)
{
throw napie;
}
throw inner;
}
throw e;
}
IDictionary <string, object> result = task.Result;
ODataEntry returnValue = new ODataEntry(result);
return(returnValue);
}
private async Task ExecuteBatchActionsAsync(IList <Func <IODataClient, Task> > actions, CancellationToken cancellationToken)
{
if (!actions.Any())
{
return;
}
var responseIndexes = new List <int>();
// Write batch operations into a batch content
var lastOperationId = 0;
foreach (var action in actions)
{
await action(this);
var responseIndex = -1;
if (_lazyBatchWriter.Value.LastOperationId > lastOperationId)
{
lastOperationId = _lazyBatchWriter.Value.LastOperationId;
responseIndex = lastOperationId - 1;
}
responseIndexes.Add(responseIndex);
}
if (_lazyBatchWriter.Value.HasOperations)
{
// Create batch request message
var requestMessage = await _lazyBatchWriter.Value.EndBatchAsync();
var request = new ODataRequest(RestVerbs.Post, _session, ODataLiteral.Batch, requestMessage);
// Execute batch and get response
ODataResponse batchResponse;
using (var response = await _requestRunner.ExecuteRequestAsync(request, cancellationToken))
{
var responseReader = _session.Adapter.GetResponseReader();
batchResponse = await responseReader.GetResponseAsync(response);
}
// Replay batch operations to assign results
for (int actionIndex = 0; actionIndex < actions.Count; actionIndex++)
{
var responseIndex = responseIndexes[actionIndex];
if (responseIndex >= 0)
{
var actionResponse = batchResponse.Batch[responseIndex];
if (actionResponse.StatusCode >= 400)
{
throw WebRequestException.CreateFromStatusCode((HttpStatusCode)actionResponse.StatusCode);
}
var client = new ODataClient(this, actionResponse);
await actions[actionIndex](client);
}
}
}
}
public async Task <HttpResponseMessage> ExecuteRequestAsync(ODataRequest request, CancellationToken cancellationToken)
{
try
{
var messageHandler = CreateMessageHandler(request);
using (var httpClient = CreateHttpClient(messageHandler))
{
PreExecute(httpClient, request);
_session.Trace("{0} request: {1}", request.Method, request.RequestMessage.RequestUri.AbsoluteUri);
#if TRACE_REQUEST_CONTENT
if (request.RequestMessage.Content != null)
{
var content = await request.RequestMessage.Content.ReadAsStringAsync();
_session.Trace("Request content:{0}{1}", Environment.NewLine, content);
}
#endif
var response = await httpClient.SendAsync(request.RequestMessage, cancellationToken);
if (cancellationToken.IsCancellationRequested)
{
cancellationToken.ThrowIfCancellationRequested();
}
_session.Trace("Request completed: {0}", response.StatusCode);
#if TRACE_RESPONSE_CONTENT
if (response.Content != null)
{
var content = await response.Content.ReadAsStringAsync();
_session.Trace("Response content:{0}{1}", Environment.NewLine, content);
}
#endif
PostExecute(response);
return(response);
}
}
catch (WebException ex)
{
throw WebRequestException.CreateFromWebException(ex);
}
catch (AggregateException ex)
{
if (ex.InnerException is WebException)
{
throw WebRequestException.CreateFromWebException(ex.InnerException as WebException);
}
else
{
throw;
}
}
}
public HttpWebResponse TryRequest(HttpWebRequest request)
{
try
{
return((HttpWebResponse)request.GetResponse());
}
catch (WebException ex)
{
throw WebRequestException.CreateFromWebException(ex);
}
}
private async Task PostExecute(HttpResponseMessage responseMessage)
{
if (_session.Settings.AfterResponse != null)
{
_session.Settings.AfterResponse(responseMessage);
}
if (!responseMessage.IsSuccessStatusCode)
{
throw await WebRequestException.CreateFromResponseMessageAsync(responseMessage);
}
}
private async Task PostExecute(HttpResponseMessage responseMessage)
{
_session.Settings.AfterResponse?.Invoke(responseMessage);
if (_session.Settings.AfterResponseAsync != null)
{
await _session.Settings.AfterResponseAsync(responseMessage).ConfigureAwait(false);
}
if (!responseMessage.IsSuccessStatusCode)
{
throw await WebRequestException.CreateFromResponseMessageAsync(responseMessage, _session.Settings.WebRequestExceptionMessageSource).ConfigureAwait(false);
}
}
public static ODataResponse FromStatusCode(int statusCode, Stream responseStream)
{
if (statusCode >= (int)HttpStatusCode.BadRequest)
{
var responseContent = Utils.StreamToString(responseStream, true);
return(new ODataResponse
{
StatusCode = statusCode,
Exception = WebRequestException.CreateFromStatusCode((HttpStatusCode)statusCode, responseContent),
});
}
else
{
return(new ODataResponse
{
StatusCode = statusCode,
});
}
}
internal static ODataResponse FromStatusCode(ITypeCache typeCache, int statusCode, IEnumerable <KeyValuePair <string, string> > headers, Stream responseStream, WebRequestExceptionMessageSource exceptionMessageSource)
{
if (statusCode >= (int)HttpStatusCode.BadRequest)
{
var responseContent = Utils.StreamToString(responseStream, true);
return(new ODataResponse(typeCache)
{
StatusCode = statusCode,
Exception = WebRequestException.CreateFromStatusCode((HttpStatusCode)statusCode, exceptionMessageSource, responseContent),
Headers = headers
});
}
else
{
return(new ODataResponse(typeCache)
{
StatusCode = statusCode,
Headers = headers
});
}
}
private bool IsResourceNotFoundException(WebRequestException ex)
{
var innerException = ex.InnerException as WebException;
if (innerException != null)
{
var statusCode = (innerException.Response as HttpWebResponse).StatusCode;
return statusCode == HttpStatusCode.NotFound;
}
return false;
}
public async Task <HttpResponseMessage> ExecuteRequestAsync(ODataRequest request, CancellationToken cancellationToken)
{
HttpConnection httpConnection = null;
try
{
httpConnection = _session.Settings.RenewHttpConnection
? new HttpConnection(_session.Settings)
: _session.GetHttpConnection();
PreExecute(httpConnection.HttpClient, request);
_session.Trace("{0} request: {1}", request.Method, request.RequestMessage.RequestUri.AbsoluteUri);
#if TRACE_REQUEST_CONTENT
if (request.RequestMessage.Content != null)
{
var content = await request.RequestMessage.Content.ReadAsStringAsync();
_session.Trace("Request content:{0}{1}", Environment.NewLine, content);
}
#endif
var response = await httpConnection.HttpClient.SendAsync(request.RequestMessage, cancellationToken);
if (cancellationToken.IsCancellationRequested)
{
cancellationToken.ThrowIfCancellationRequested();
}
_session.Trace("Request completed: {0}", response.StatusCode);
#if TRACE_RESPONSE_CONTENT
if (response.Content != null)
{
var content = await response.Content.ReadAsStringAsync();
_session.Trace("Response content:{0}{1}", Environment.NewLine, content);
}
#endif
await PostExecute(response);
return(response);
}
catch (WebException ex)
{
throw WebRequestException.CreateFromWebException(ex);
}
catch (AggregateException ex)
{
if (ex.InnerException is WebException)
{
throw WebRequestException.CreateFromWebException(ex.InnerException as WebException);
}
else
{
throw;
}
}
finally
{
if (httpConnection != null && _session.Settings.RenewHttpConnection)
{
httpConnection.Dispose();
}
}
}
public async Task <HttpResponseMessage> ExecuteRequestAsync(ODataRequest request, CancellationToken cancellationToken)
{
HttpConnection httpConnection = null;
try
{
await PreExecuteAsync(request).ConfigureAwait(false);
_session.Trace("{0} request: {1}", request.Method, request.RequestMessage.RequestUri.AbsoluteUri);
if (request.RequestMessage.Content != null && (_session.Settings.TraceFilter & ODataTrace.RequestContent) != 0)
{
var content = await request.RequestMessage.Content.ReadAsStringAsync().ConfigureAwait(false);
_session.Trace("Request content:{0}{1}", Environment.NewLine, content);
}
HttpResponseMessage response;
if (_session.Settings.RequestExecutor != null)
{
response = await _session.Settings.RequestExecutor(request.RequestMessage);
}
else
{
httpConnection = _session.Settings.RenewHttpConnection
? new HttpConnection(_session.Settings)
: _session.GetHttpConnection();
response = await httpConnection.HttpClient.SendAsync(request.RequestMessage, cancellationToken).ConfigureAwait(false);
if (cancellationToken.IsCancellationRequested)
{
cancellationToken.ThrowIfCancellationRequested();
}
}
_session.Trace("Request completed: {0}", response.StatusCode);
if (response.Content != null && (_session.Settings.TraceFilter & ODataTrace.ResponseContent) != 0)
{
var content = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
_session.Trace("Response content:{0}{1}", Environment.NewLine, content);
}
await PostExecute(response).ConfigureAwait(false);
return(response);
}
catch (WebException ex)
{
throw WebRequestException.CreateFromWebException(ex);
}
catch (AggregateException ex)
{
if (ex.InnerException is WebException)
{
throw WebRequestException.CreateFromWebException(ex.InnerException as WebException);
}
else
{
throw;
}
}
finally
{
if (httpConnection != null && _session.Settings.RenewHttpConnection)
{
httpConnection.Dispose();
}
}
}
private bool IsResourceNotFoundException(WebRequestException ex)
{
return ex.Code == HttpStatusCode.NotFound;
}
