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); }
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; }