private void PreExecute(HttpClient httpClient, ODataRequest request)
{
if (request.Accept != null)
{
foreach (var accept in request.Accept)
{
request.RequestMessage.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue(accept));
}
}
if (request.CheckOptimisticConcurrency &&
(request.Method == RestVerbs.Put ||
request.Method == RestVerbs.Patch ||
request.Method == RestVerbs.Delete))
{
request.RequestMessage.Headers.IfMatch.Add(EntityTagHeaderValue.Any);
}
foreach (var header in request.Headers)
{
request.RequestMessage.Headers.TryAddWithoutValidation(header.Key, header.Value);
}
if (_session.Settings.BeforeRequest != null)
_session.Settings.BeforeRequest(request.RequestMessage);
}
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(request.EntryData != null && request.EntryData.Count > 0)
{
_session.Trace("Payload: {0}", JsonConvert.SerializeObject(request.EntryData));
}
if (request.RequestMessage.Content != null && (_session.Settings.TraceFilter & ODataTrace.RequestContent) != 0)
{
var content = await request.RequestMessage.Content.ReadAsStringAsync();
_session.Trace("Request content:{0}{1}", Environment.NewLine, content);
}
var response = await httpConnection.HttpClient.SendAsync(request.RequestMessage, cancellationToken);
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();
_session.Trace("Response content:{0}{1}", Environment.NewLine, content);
}
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
{
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<ODataRequest> CreatePutRequestAsync(string commandText, Stream stream, string mediaType = null, bool optimisticConcurrency = false)
{
var entryContent = await WriteStreamContentAsync(stream, IsTextMediaType(mediaType));
var request = new ODataRequest(RestVerbs.Put, _session, commandText, null, entryContent, mediaType);
request.CheckOptimisticConcurrency = optimisticConcurrency;
AssignHeaders(request);
return request;
}
public async Task<ODataRequest> CreateGetRequestAsync(string commandText, bool scalarResult)
{
await WriteEntryContentAsync(
RestVerbs.Get, Utils.ExtractCollectionName(commandText), commandText, null, false);
var request = new ODataRequest(RestVerbs.Get, _session, commandText)
{
ReturnsScalarResult = scalarResult,
};
AssignHeaders(request);
return request;
}
public async Task<ODataRequest> CreateInsertRequestAsync(string collection, string commandText, IDictionary<string, object> entryData, bool resultRequired)
{
var segments = commandText.Split('/');
if (segments.Count() > 1 && segments.Last().Contains("."))
{
commandText = commandText.Substring(0, commandText.Length - segments.Last().Length - 1);
}
var entryContent = await WriteEntryContentAsync(
RestVerbs.Post, collection, commandText, entryData, resultRequired);
var request = new ODataRequest(RestVerbs.Post, _session, commandText, entryData, entryContent)
{
ResultRequired = resultRequired,
};
AssignHeaders(request);
return request;
}
public async Task<ODataRequest> CreateUpdateRequestAsync(string collection, string entryIdent, IDictionary<string, object> entryKey, IDictionary<string, object> entryData, bool resultRequired)
{
var entityCollection = _session.Metadata.GetEntityCollection(collection);
var entryDetails = _session.Metadata.ParseEntryDetails(entityCollection.Name, entryData);
var hasPropertiesToUpdate = entryDetails.Properties.Count > 0;
var merge = !hasPropertiesToUpdate || CanUseMerge(collection, entryKey, entryData);
var entryContent = await WriteEntryContentAsync(
merge ? RestVerbs.Patch : RestVerbs.Put, collection, entryIdent, entryData);
var updateMethod = merge ? RestVerbs.Patch : RestVerbs.Put;
var checkOptimisticConcurrency = _session.Metadata.EntityCollectionRequiresOptimisticConcurrencyCheck(collection);
var request = new ODataRequest(updateMethod, _session, entryIdent, entryData, entryContent)
{
ResultRequired = resultRequired,
CheckOptimisticConcurrency = checkOptimisticConcurrency
};
AssignHeaders(request);
return request;
}
protected abstract void AssignHeaders(ODataRequest request);
internal async Task<HttpResponseMessage> SendMetadataRequestAsync(CancellationToken cancellationToken)
{
var request = new ODataRequest(RestVerbs.Get, _session, ODataLiteral.Metadata);
var requestRunner = new RequestRunner(_session);
return await requestRunner.ExecuteRequestAsync(request, cancellationToken);
}
public async Task<ODataRequest> CreateSetStreamRequestAsync(string commandText, string streamName, Stream stream)
{
string streamRequestCommandText;
if (string.IsNullOrEmpty(streamName))
streamRequestCommandText = commandText.EndsWith("/" + ODataLiteral.Value) ? commandText : commandText + "/" + ODataLiteral.Value;
else
streamRequestCommandText = commandText + "/" + streamName;
var entryContent = await WriteStreamContentAsync(stream);
var request = new ODataRequest(RestVerbs.Put, _session, streamRequestCommandText, null, entryContent);
AssignHeaders(request);
return request;
}
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 async Task<HttpResponseMessage> SendMetadataRequestAsync(CancellationToken cancellationToken)
{
var request = new ODataRequest(RestVerbs.Get, this, ODataLiteral.Metadata);
return await new RequestRunner(this).ExecuteRequestAsync(request, cancellationToken);
}
public ClientWithResponse(ISession session, ODataRequest request, HttpResponseMessage responseMessage)
{
_session = session;
_request = request;
_responseMessage = responseMessage;
}
private async Task <HttpResponseMessage> SendMetadataRequestAsync(CancellationToken cancellationToken)
{
var request = new ODataRequest(RestVerbs.Get, this, ODataLiteral.Metadata);
return(await new RequestRunner(this).ExecuteRequestAsync(request, cancellationToken).ConfigureAwait(false));
}
public async Task<ODataRequest> CreateLinkRequestAsync(string collection, string linkName, string entryIdent, string linkIdent)
{
var associationName = _session.Metadata.GetNavigationPropertyExactName(collection, linkName);
var linkMethod = _session.Metadata.IsNavigationPropertyCollection(collection, associationName) ?
RestVerbs.Post :
RestVerbs.Put;
var commandText = FormatLinkPath(entryIdent, associationName);
var linkContent = await WriteLinkContentAsync(linkMethod, commandText, linkIdent);
var request = new ODataRequest(linkMethod, _session, commandText, null, linkContent)
{
IsLink = true,
};
AssignHeaders(request);
return request;
}
public async Task<ODataRequest> CreateDeleteRequestAsync(string collection, string entryIdent)
{
await WriteEntryContentAsync(
RestVerbs.Delete, collection, entryIdent, null, false);
var request = new ODataRequest(RestVerbs.Delete, _session, entryIdent)
{
CheckOptimisticConcurrency = _session.Metadata.EntityCollectionRequiresOptimisticConcurrencyCheck(collection)
};
AssignHeaders(request);
return request;
}
public ClientWithRequest(ODataRequest request, ISession session)
{
_request = request;
_session = session;
_requestRunner = new RequestRunner(_session);
}
protected abstract void AssignHeaders(ODataRequest request);
public async Task<ODataRequest> CreateActionRequestAsync(string commandText, string actionName, IDictionary<string, object> parameters, bool resultRequired)
{
var verb = RestVerbs.Post;
Stream entryContent = null;
if (parameters != null && parameters.Any())
{
entryContent = await WriteActionContentAsync(RestVerbs.Post, commandText, actionName, parameters);
}
else
{
await WriteFunctionContentAsync(verb, commandText);
}
var request = new ODataRequest(verb, _session, commandText, parameters, entryContent)
{
ResultRequired = resultRequired,
};
AssignHeaders(request);
return request;
}
public async Task<ODataRequest> CreateFunctionRequestAsync(string commandText, string functionName)
{
var verb = _session.Metadata.GetFunctionVerb(functionName);
await WriteFunctionContentAsync(verb, commandText);
var request = new ODataRequest(verb, _session, commandText);
AssignHeaders(request);
return request;
}
public async Task<ODataRequest> CreateUnlinkRequestAsync(string collection, string linkName, string entryIdent, string linkIdent)
{
var associationName = _session.Metadata.GetNavigationPropertyExactName(collection, linkName);
await WriteEntryContentAsync(RestVerbs.Delete, collection, entryIdent, null, false);
var commandText = FormatLinkPath(entryIdent, associationName, linkIdent);
var request = new ODataRequest(RestVerbs.Delete, _session, commandText)
{
IsLink = true,
};
AssignHeaders(request);
return request;
}
