/// <summary>
/// Writes a single OData batch response.
/// </summary>
/// <param name="writer">The <see cref="ODataBatchWriter"/>.</param>
/// <param name="context">The message context.</param>
public static async Task WriteMessageAsync(ODataBatchWriter writer, HttpContext context)
{
if (writer == null)
{
throw Error.ArgumentNull("writer");
}
if (context == null)
{
throw Error.ArgumentNull("context");
}
string contentId = (context.Request != null) ? context.Request.GetODataContentId() : String.Empty;
ODataBatchOperationResponseMessage batchResponse = writer.CreateOperationResponseMessage(contentId);
batchResponse.StatusCode = context.Response.StatusCode;
foreach (KeyValuePair <string, StringValues> header in context.Response.Headers)
{
batchResponse.SetHeader(header.Key, String.Join(",", header.Value.ToArray()));
}
if (context.Response.Body != null && context.Response.Body.Length != 0)
{
using (Stream stream = batchResponse.GetStream())
{
context.RequestAborted.ThrowIfCancellationRequested();
context.Response.Body.Seek(0L, SeekOrigin.Begin);
await context.Response.Body.CopyToAsync(stream);
}
}
}
private void createDeleteOperationRequestMessage(ref ODataBatchWriter writer, Change change, string tableName)
{
string id = this.getKeyType(tableName).IsString() ? "'" + change.id + "'" : change.id;
Uri uri = new Uri(tableName + "(" + id + ")", UriKind.Relative);
writer.CreateOperationRequestMessage("DELETE", uri);
}
public async Task WriteMessageAsync_AsynchronouslyWritesResponseMessage()
{
// Arrange
HeaderDictionary headers = new HeaderDictionary
{
{ "Content-Type", $"multipart/mixed;charset=utf-8;boundary={Guid.NewGuid()}" },
};
MemoryStream ms = new MemoryStream();
IODataResponseMessage odataResponse = ODataMessageWrapperHelper.Create(ms, headers);
HeaderDictionary responseHeaders = new HeaderDictionary
{
{ "customHeader", "bar" }
};
HttpResponse response = CreateResponse("example content", responseHeaders, "text/example");
// Act
ODataBatchWriter batchWriter = await new ODataMessageWriter(odataResponse).CreateODataBatchWriterAsync();
await batchWriter.WriteStartBatchAsync();
await ODataBatchResponseItem.WriteMessageAsync(batchWriter, response.HttpContext);
await batchWriter.WriteEndBatchAsync();
ms.Position = 0;
string result = new StreamReader(ms).ReadToEnd();
// Assert
Assert.Contains("example content", result);
Assert.Contains("text/example", result);
Assert.Contains("customHeader", result);
Assert.Contains("bar", result);
}
/// <summary>
/// Writes a single OData batch response.
/// </summary>
/// <param name="writer">The <see cref="ODataBatchWriter"/>.</param>
/// <param name="response">The response message.</param>
/// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
/// <returns>A task object representing writing the given batch response using the given writer.</returns>
public static async Task WriteMessageAsync(ODataBatchWriter writer, HttpResponseMessage response,
CancellationToken cancellationToken)
{
if (writer == null)
{
throw Error.ArgumentNull("writer");
}
if (response == null)
{
throw Error.ArgumentNull("response");
}
ODataBatchOperationResponseMessage batchResponse = writer.CreateOperationResponseMessage();
batchResponse.StatusCode = (int)response.StatusCode;
foreach (KeyValuePair <string, IEnumerable <string> > header in response.Headers)
{
batchResponse.SetHeader(header.Key, String.Join(",", header.Value));
}
if (response.Content != null)
{
foreach (KeyValuePair <string, IEnumerable <string> > header in response.Content.Headers)
{
batchResponse.SetHeader(header.Key, String.Join(",", header.Value));
}
using (Stream stream = batchResponse.GetStream())
{
cancellationToken.ThrowIfCancellationRequested();
await response.Content.CopyToAsync(stream);
}
}
}
internal static ODataRequestMessageWrapper CreateBatchPartRequestMessage(ODataBatchWriter batchWriter, string method, Uri requestUrl, RequestInfo requestInfo)
{
return(new ODataRequestMessageWrapper(batchWriter.CreateOperationRequestMessage(method, requestUrl), requestInfo)
{
IsBatchPartRequest = true
});
}
/// <summary>
/// Create a request message for a batch part from the batch writer. This method copies request headers
/// from <paramref name="requestMessageArgs"/> in addition to the method and Uri.
/// </summary>
/// <param name="batchWriter">ODataBatchWriter instance to build operation message from.</param>
/// <param name="requestMessageArgs">RequestMessageArgs for the request.</param>
/// <param name="requestInfo">RequestInfo instance.</param>
/// <param name="contentId">The Content-ID value to write in ChangeSet head.</param>
/// <param name="isRelativeUri">If the request is using a relative uri.</param>
/// <returns>an instance of ODataRequestMessageWrapper.</returns>
internal static ODataRequestMessageWrapper CreateBatchPartRequestMessage(
ODataBatchWriter batchWriter,
BuildingRequestEventArgs requestMessageArgs,
RequestInfo requestInfo,
string contentId,
bool isRelativeUri)
{
IODataRequestMessage requestMessage;
requestMessage = batchWriter.CreateOperationRequestMessage(
requestMessageArgs.Method,
requestMessageArgs.RequestUri,
contentId,
isRelativeUri ? BatchPayloadUriOption.RelativeUri : BatchPayloadUriOption.AbsoluteUri);
foreach (var h in requestMessageArgs.Headers)
{
requestMessage.SetHeader(h.Key, h.Value);
}
var clientRequestMessage = new InternalODataRequestMessage(requestMessage, false /*allowGetStream*/);
ODataRequestMessageWrapper messageWrapper = new InnerBatchRequestMessageWrapper(clientRequestMessage, requestMessage, requestInfo, requestMessageArgs.Descriptor);
return(messageWrapper);
}
public async Task WriteResponse_SynchronouslyWritesChangeSet()
{
HttpResponseMessage[] responses = new HttpResponseMessage[]
{
new HttpResponseMessage(HttpStatusCode.Accepted),
new HttpResponseMessage(HttpStatusCode.NoContent)
};
ChangeSetResponseItem responseItem = new ChangeSetResponseItem(responses);
MemoryStream memoryStream = new MemoryStream();
IODataResponseMessage responseMessage = new ODataMessageWrapper(memoryStream);
ODataMessageWriter writer = new ODataMessageWriter(responseMessage);
ODataBatchWriter batchWriter = writer.CreateODataBatchWriter();
batchWriter.WriteStartBatch();
// For backward compatibility, default is to assume a synchronous batch writer
await responseItem.WriteResponseAsync(batchWriter, CancellationToken.None);
batchWriter.WriteEndBatch();
memoryStream.Position = 0;
string responseString = new StreamReader(memoryStream).ReadToEnd();
Assert.Contains("changesetresponse", responseString);
Assert.Contains("Accepted", responseString);
Assert.Contains("No Content", responseString);
}
public void WriteResponseAsync_WritesChangeSet()
{
HttpResponseMessage[] responses = new HttpResponseMessage[]
{
new HttpResponseMessage(HttpStatusCode.Accepted),
new HttpResponseMessage(HttpStatusCode.NoContent)
};
ChangeSetResponseItem responseItem = new ChangeSetResponseItem(responses);
MemoryStream memoryStream = new MemoryStream();
IODataResponseMessage responseMessage = new ODataMessageWrapper(memoryStream);
ODataMessageWriter writer = new ODataMessageWriter(responseMessage);
ODataBatchWriter batchWriter = writer.CreateODataBatchWriter();
batchWriter.WriteStartBatch();
responseItem.WriteResponseAsync(batchWriter, CancellationToken.None).Wait();
batchWriter.WriteEndBatch();
memoryStream.Position = 0;
string responseString = new StreamReader(memoryStream).ReadToEnd();
Assert.Contains("changesetresponse", responseString);
Assert.Contains("Accepted", responseString);
Assert.Contains("No Content", responseString);
}
public async Task WriteResponseAsync_WritesChangeSet()
{
// Arrange
HttpContext context1 = HttpContextHelper.Create(StatusCodes.Status202Accepted);
HttpContext context2 = HttpContextHelper.Create(StatusCodes.Status204NoContent);
ChangeSetResponseItem responseItem = new ChangeSetResponseItem(new[] { context1, context2 });
MemoryStream memoryStream = new MemoryStream();
IODataResponseMessage responseMessage = new ODataMessageWrapper(memoryStream);
ODataMessageWriter writer = new ODataMessageWriter(responseMessage);
// Act
ODataBatchWriter batchWriter = await writer.CreateODataBatchWriterAsync();
await batchWriter.WriteStartBatchAsync();
await responseItem.WriteResponseAsync(batchWriter);
await batchWriter.WriteEndBatchAsync();
memoryStream.Position = 0;
string responseString = new StreamReader(memoryStream).ReadToEnd();
// Assert
Assert.Contains("changesetresponse", responseString);
Assert.Contains("Accepted", responseString);
Assert.Contains("No Content", responseString);
}
/// <summary>
/// Writes the responses as a ChangeSet.
/// </summary>
/// <param name="writer">The <see cref="ODataBatchWriter"/>.</param>
/// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
/// <param name="asyncWriter">Whether or not the writer is writing asynchronously.</param>
public override async Task WriteResponseAsync(ODataBatchWriter writer, CancellationToken cancellationToken, bool asyncWriter)
{
if (writer == null)
{
throw Error.ArgumentNull("writer");
}
if (asyncWriter)
{
await writer.WriteStartChangesetAsync();
foreach (HttpResponseMessage responseMessage in Responses)
{
await WriteMessageAsync(writer, responseMessage, cancellationToken, asyncWriter);
}
await writer.WriteEndChangesetAsync();
}
else
{
writer.WriteStartChangeset();
foreach (HttpResponseMessage responseMessage in Responses)
{
await WriteMessageAsync(writer, responseMessage, cancellationToken, asyncWriter);
}
writer.WriteEndChangeset();
}
}
public async Task WriteResponseAsync_AsynchronouslyWritesOperation()
{
// Arrange
HttpContext context = HttpContextHelper.Create(StatusCodes.Status202Accepted);
OperationResponseItem responseItem = new OperationResponseItem(context);
MemoryStream memoryStream = new MemoryStream();
IODataResponseMessage responseMessage = new ODataMessageWrapper(memoryStream);
ODataMessageWriter writer = new ODataMessageWriter(responseMessage);
// Act
ODataBatchWriter batchWriter = await writer.CreateODataBatchWriterAsync();
await batchWriter.WriteStartBatchAsync();
await responseItem.WriteResponseAsync(batchWriter);
await batchWriter.WriteEndBatchAsync();
memoryStream.Position = 0;
string responseString = new StreamReader(memoryStream).ReadToEnd();
// Assert
Assert.Contains("Accepted", responseString);
}
/// <summary>
/// Writes the responses as a ChangeSet.
/// </summary>
/// <param name="writer">The <see cref="ODataBatchWriter"/>.</param>
/// <param name="asyncWriter">Whether or not the writer is in async mode. </param>
public override async Task WriteResponseAsync(ODataBatchWriter writer, bool asyncWriter)
{
if (writer == null)
{
throw Error.ArgumentNull("writer");
}
if (asyncWriter)
{
await writer.WriteStartChangesetAsync();
foreach (HttpContext context in Contexts)
{
await WriteMessageAsync(writer, context, asyncWriter);
}
await writer.WriteEndChangesetAsync();
}
else
{
writer.WriteStartChangeset();
foreach (HttpContext context in Contexts)
{
await WriteMessageAsync(writer, context, asyncWriter);
}
writer.WriteEndChangeset();
}
}
/// <summary>
/// Private constructor code that is common between normal and error construction code.
/// </summary>
/// <param name='writer'>ODataBatchWriter instance.</param>
private BatchServiceHost(ODataBatchWriter writer)
{
Debug.Assert(writer != null, "writer != null");
this.writer = writer;
this.requestHeaders = new WebHeaderCollection();
this.responseHeaders = new WebHeaderCollection();
}
/// <summary>
/// Creates a batch writer.
/// </summary>
/// <param name="batchBoundary">The boundary string for the batch structure itself.</param>
/// <returns>The newly created batch writer.</returns>
private ODataBatchWriter CreateODataBatchWriterImplementation(string batchBoundary)
{
// Batch writer needs the default encoding to not use the preamble.
this.encoding = this.encoding ?? MediaTypeUtils.EncodingUtf8NoPreamble;
ODataBatchWriter batchWriter = new ODataBatchWriter(this, batchBoundary);
this.outputInStreamErrorListener = batchWriter;
return(batchWriter);
}
private void WriteChangeset(ODataBatchWriter writer, IReadOnlyList <OeOperationMessage> changeset)
{
writer.WriteStartChangeset();
foreach (OeOperationMessage operation in changeset)
{
WriteOperation(writer, operation);
}
writer.WriteEndChangeset();
}
internal static BatchServiceHost CreateBatchServiceHostForError(ODataBatchWriter writer)
{
BatchServiceHost host = new BatchServiceHost(writer)
{
queryParameters = new NameValueCollection()
};
return(host);
}
/// <summary>
/// Writes the response as an Operation.
/// </summary>
/// <param name="writer">The <see cref="ODataBatchWriter"/>.</param>
/// <param name="asyncWriter">Whether or not the writer is in async mode. </param>
public override Task WriteResponseAsync(ODataBatchWriter writer, bool asyncWriter)
{
if (writer == null)
{
throw Error.ArgumentNull("writer");
}
return(WriteMessageAsync(writer, Context, asyncWriter));
}
/// <summary>
/// Writes the response as an Operation.
/// </summary>
/// <param name="writer">The <see cref="ODataBatchWriter"/>.</param>
public override Task WriteResponseAsync(ODataBatchWriter writer)
{
if (writer == null)
{
throw new ArgumentNullException(nameof(writer));
}
return(WriteMessageAsync(writer, Context));
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="batchWriter">The writer to wrap.</param>
/// <param name="testConfiguration">The test configuration to use.</param>
public ODataBatchWriterTestWrapper(ODataBatchWriter batchWriter, WriterTestConfiguration testConfiguration)
{
ExceptionUtilities.CheckArgumentNotNull(batchWriter, "batchWriter");
ExceptionUtilities.CheckArgumentNotNull(testConfiguration, "testConfiguration");
this.batchWriter = batchWriter;
this.testConfiguration = testConfiguration;
this.contentId = 100;
}
/// <summary>
/// Writes the response as an Operation.
/// </summary>
/// <param name="writer">The <see cref="ODataBatchWriter"/>.</param>
/// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
public override Task WriteResponseAsync(ODataBatchWriter writer, CancellationToken cancellationToken)
{
if (writer == null)
{
throw Error.ArgumentNull("writer");
}
return(WriteMessageAsync(writer, Response, cancellationToken));
}
private async Task WriteChangeset(ODataBatchWriter writer, IReadOnlyList <OeOperationMessage> changeset)
{
await writer.WriteStartChangesetAsync();
foreach (OeOperationMessage operation in changeset)
{
await WriteOperation(writer, operation);
}
await writer.WriteEndChangesetAsync();
}
private async ValueTask WriteChangesetAsync(ODataBatchWriter writer, IReadOnlyList <OeOperationMessage> changeset)
{
await writer.WriteStartChangesetAsync().ConfigureAwait(false);
foreach (OeOperationMessage operation in changeset)
{
await WriteBatchOperationAsync(writer, operation).ConfigureAwait(false);
}
await writer.WriteEndChangesetAsync().ConfigureAwait(false);
}
private void WriteBatch(ODataBatchWriter writer, OeBatchMessage batchMessage)
{
if (batchMessage.Changeset != null)
{
WriteChangeset(writer, batchMessage.Changeset);
}
if (batchMessage.Operation != null)
{
WriteOperation(writer, batchMessage.Operation);
}
}
private async Task WriteBatch(ODataBatchWriter writer, OeBatchMessage batchMessage)
{
if (batchMessage.Changeset == null)
{
await WriteOperation(writer, batchMessage.Operation);
}
else
{
await WriteChangeset(writer, batchMessage.Changeset);
}
}
private async ValueTask WriteBatchAsync(ODataBatchWriter writer, OeBatchMessage batchMessage)
{
if (batchMessage.Changeset == null)
{
await WriteBatchOperationAsync(writer, batchMessage.Operation).ConfigureAwait(false);
}
else
{
await WriteChangesetAsync(writer, batchMessage.Changeset).ConfigureAwait(false);
}
}
public override async Task StartBatchAsync()
{
_requestMessage = new ODataRequestMessage()
{
Url = new Uri(_session.Settings.UrlBase)
};
_messageWriter = new ODataMessageWriter(_requestMessage);
_batchWriter = await _messageWriter.CreateODataBatchWriterAsync();
await _batchWriter.WriteStartBatchAsync();
}
public override async Task StartBatchAsync()
{
_requestMessage = new ODataRequestMessage()
{
Url = _session.Settings.BaseUri
};
_messageWriter = new ODataMessageWriter(_requestMessage);
_batchWriter = await _messageWriter.CreateODataBatchWriterAsync();
await _batchWriter.WriteStartBatchAsync();
this.HasOperations = true;
}
private async Task WriteOperation(ODataBatchWriter writer, OeOperationMessage operation)
{
ODataBatchOperationResponseMessage operationMessage = await writer.CreateOperationResponseMessageAsync(operation.ContentId);
operationMessage.SetHeader("Location", operation.RequestUrl.AbsoluteUri);
operationMessage.SetHeader(ODataConstants.ContentTypeHeader, operation.ContentType);
operationMessage.StatusCode = (int)operation.StatusCode;
if (operation.StatusCode != HttpStatusCode.NoContent)
{
using (Stream stream = await operationMessage.GetStreamAsync())
await WriteEntity(operation.EntitySet, operation.Entry, stream);
}
}
public async Task Write(Stream stream, OeBatchMessage batchMessage)
{
IODataResponseMessage responseMessage = new Infrastructure.OeInMemoryMessage(stream, batchMessage.ContentType);
using (var messageWriter = new ODataMessageWriter(responseMessage, _settings))
{
ODataBatchWriter writer = await messageWriter.CreateODataBatchWriterAsync().ConfigureAwait(false);
await writer.WriteStartBatchAsync().ConfigureAwait(false);
await WriteBatch(writer, batchMessage).ConfigureAwait(false);
await writer.WriteEndBatchAsync().ConfigureAwait(false);
}
}
private void WriteOperation(ODataBatchWriter writer, OeOperationMessage operation)
{
ODataBatchOperationResponseMessage operationMessage = writer.CreateOperationResponseMessage(operation.ContentId);
operationMessage.SetHeader("Location", operation.RequestUrl.AbsoluteUri);
operationMessage.SetHeader(ODataConstants.ContentTypeHeader, operation.ContentType);
operationMessage.StatusCode = (int)operation.StatusCode;
if (operation.StatusCode != HttpStatusCode.NoContent)
{
using (Stream stream = operationMessage.GetStream())
WriteEntity(stream, operation.EntityItem);
}
}