internal ODataRawInputContext(
ODataFormat format,
Stream messageStream,
Encoding encoding,
ODataMessageReaderSettings messageReaderSettings,
bool readingResponse,
bool synchronous,
IEdmModel model,
IODataUrlResolver urlResolver,
ODataPayloadKind readerPayloadKind)
: base(format, messageReaderSettings, readingResponse, synchronous, model, urlResolver)
{
Debug.Assert(messageStream != null, "stream != null");
Debug.Assert(readerPayloadKind != ODataPayloadKind.Unsupported, "readerPayloadKind != ODataPayloadKind.Unsupported");
ExceptionUtils.CheckArgumentNotNull(format, "format");
ExceptionUtils.CheckArgumentNotNull(messageReaderSettings, "messageReaderSettings");
try
{
this.stream = messageStream;
this.encoding = encoding;
this.readerPayloadKind = readerPayloadKind;
}
catch (Exception e)
{
// Dispose the message stream if we failed to create the input context.
if (ExceptionUtils.IsCatchableExceptionType(e) && messageStream != null)
{
messageStream.Dispose();
}
throw;
}
}
public void Read_RoundTrips()
{
// Arrange
IEdmModel model = CreateModel();
var deserializer = new ODataEntityReferenceLinkDeserializer();
MockODataRequestMessage requestMessage = new MockODataRequestMessage();
ODataMessageWriterSettings settings = new ODataMessageWriterSettings()
{
ODataUri = new ODataUri { ServiceRoot = new Uri("http://any/") }
};
settings.SetContentType(ODataFormat.Json);
ODataMessageWriter messageWriter = new ODataMessageWriter(requestMessage, settings);
messageWriter.WriteEntityReferenceLink(new ODataEntityReferenceLink { Url = new Uri("http://localhost/samplelink") });
ODataMessageReaderSettings readSettings = new ODataMessageReaderSettings();
ODataMessageReader messageReader = new ODataMessageReader(new MockODataRequestMessage(requestMessage), readSettings, model);
ODataDeserializerContext context = new ODataDeserializerContext
{
Request = new HttpRequestMessage(),
Path = new ODataPath(new NavigationPathSegment(GetNavigationProperty(model)))
};
// Act
Uri uri = deserializer.Read(messageReader, typeof(Uri), context) as Uri;
// Assert
Assert.NotNull(uri);
Assert.Equal("http://localhost/samplelink", uri.AbsoluteUri);
}
public void PropertyGettersAndSettersTest()
{
Uri baseUri = new Uri("http://odata.org");
Func<ODataEntry, XmlReader, Uri, XmlReader> entryAtomXmlCustomizationCallback = (entry, reader, uri) => reader;
ODataMessageReaderSettings settings = new ODataMessageReaderSettings {
BaseUri = baseUri,
CheckCharacters = true,
DisablePrimitiveTypeConversion = true,
DisableMessageStreamDisposal = true,
EnableAtomMetadataReading = true,
UndeclaredPropertyBehaviorKinds = ODataUndeclaredPropertyBehaviorKinds.IgnoreUndeclaredValueProperty,
MaxProtocolVersion = ODataVersion.V4,
MessageQuotas = new ODataMessageQuotas {
MaxPartsPerBatch = 2,
MaxOperationsPerChangeset = 3,
MaxNestingDepth = 4,
MaxReceivedMessageSize = 5,
},
};
Assert.AreEqual(baseUri, settings.BaseUri, "The BaseUri was not correctly remembered.");
Assert.IsTrue(settings.CheckCharacters, "The CheckCharacters should be on when set.");
Assert.IsTrue(settings.DisablePrimitiveTypeConversion, "DisablePrimitiveTypeConversion was not correctly remembered.");
Assert.IsTrue(settings.DisableMessageStreamDisposal, "DisableMessageStreamDisposal was not correctly remembered.");
Assert.IsTrue(settings.EnableAtomMetadataReading, "EnableAtomMetadataReading was not correctly remembered.");
Assert.AreEqual(ODataUndeclaredPropertyBehaviorKinds.IgnoreUndeclaredValueProperty, settings.UndeclaredPropertyBehaviorKinds, "UndeclaredPropertyBehaviorKinds was not correctly remembered.");
Assert.AreEqual(ODataVersion.V4, settings.MaxProtocolVersion, "The MaxProtocolVersion was not correctly remembered.");
Assert.AreEqual(2, settings.MessageQuotas.MaxPartsPerBatch, "MaxPartsPerBatch should be 2");
Assert.AreEqual(3, settings.MessageQuotas.MaxOperationsPerChangeset, "MaxOperationsPerChangeset should be 3");
Assert.AreEqual(4, settings.MessageQuotas.MaxNestingDepth, "MaxNestingDepth should be 4");
Assert.AreEqual(5, settings.MessageQuotas.MaxReceivedMessageSize, "MaxMessageSize should be 5");
}
/// <summary>
/// Detects the payload kinds supported by this format for the specified message payload.
/// </summary>
/// <param name="messageInfo">The context information for the message.</param>
/// <param name="settings">Configuration settings of the OData reader.</param>
/// <returns>The set of <see cref="ODataPayloadKind"/>s that are supported with the specified payload.</returns>
public override IEnumerable<ODataPayloadKind> DetectPayloadKind(
ODataMessageInfo messageInfo,
ODataMessageReaderSettings settings)
{
ExceptionUtils.CheckArgumentNotNull(messageInfo, "messageInfo");
return DetectPayloadKindImplementation(messageInfo.MediaType);
}
/// <summary>
/// Specifically use to query single entry or multi entries(query with $expand)
/// </summary>
/// <param name="requestUri"></param>
/// <param name="mimeType"></param>
/// <returns></returns>
public List<ODataEntry> QueryEntries(string requestUri, string mimeType)
{
List<ODataEntry> entries = new List<ODataEntry>();
ODataMessageReaderSettings readerSettings = new ODataMessageReaderSettings() { BaseUri = baseUri };
var requestMessage = new HttpWebRequestMessage(new Uri(baseUri.AbsoluteUri + requestUri, UriKind.Absolute));
requestMessage.SetHeader("Accept", mimeType);
var responseMessage = requestMessage.GetResponse();
Assert.AreEqual(200, responseMessage.StatusCode);
if (!mimeType.Contains(MimeTypes.ODataParameterNoMetadata))
{
using (var messageReader = new ODataMessageReader(responseMessage, readerSettings, model))
{
var reader = messageReader.CreateODataEntryReader();
while (reader.Read())
{
if (reader.State == ODataReaderState.EntryEnd)
{
entries.Add(reader.Item as ODataEntry);
}
}
Assert.AreEqual(ODataReaderState.Completed, reader.State);
}
}
return entries;
}
/// <summary>
/// Creates a new the reader for the given response message and settings.
/// </summary>
/// <param name="responseMessage">The response message.</param>
/// <param name="settings">The settings.</param>
/// <returns>Newly created message reader.</returns>
internal ODataMessageReader CreateReader(IODataResponseMessage responseMessage, ODataMessageReaderSettings settings)
{
Debug.Assert(responseMessage != null, "responseMessage != null");
Debug.Assert(settings != null, "settings != null");
this.responseInfo.Context.Format.ValidateCanReadResponseFormat(responseMessage);
return new ODataMessageReader(responseMessage, settings, this.responseInfo.TypeResolver.ReaderModel);
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="format">The format used for the test.</param>
/// <param name="messageReaderSettings">The message reader settings used for the test.</param>
/// <param name="readerRequest">True if the test is reading a request. Otherwise false if it's reading a response.</param>
/// <param name="synchronous">True if the test should be ran using synchronous API. Otherwise false if it should be ran using asynchronous APIs.</param>
/// <param name="version">The OData protocol version to be used for reading the payload.</param>
public ReaderTestConfiguration(ODataFormat format, ODataMessageReaderSettings messageReaderSettings, bool IsRequest, bool synchronous,ODataVersion version = ODataVersion.V4)
:base(format, version, IsRequest, TestODataBehaviorKind.Default)
{
Debug.Assert(messageReaderSettings != null, "readerSettings != null");
this.MessageReaderSettings = messageReaderSettings;
this.Synchronous = synchronous;
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="messageReader">The message reader to wrap.</param>
/// <param name="testConfiguration">The test configuration to use.</param>
/// <remarks>
/// This constructor is used if not special checks against a test message should be performed.
/// Use the constructor overload that takes a <see cref="TestMessage"/> argument to enforce checks
/// around disposal of the message.
/// </remarks>
public ODataMessageReaderTestWrapper(ODataMessageReader messageReader, ODataMessageReaderSettings messageReaderSettings, ReaderTestConfiguration testConfiguration)
{
ExceptionUtilities.CheckArgumentNotNull(messageReader, "messageReader");
ExceptionUtilities.CheckArgumentNotNull(testConfiguration, "testConfiguration");
this.messageReader = messageReader;
this.messageReaderSettings = messageReaderSettings;
this.testConfiguration = testConfiguration;
}
private static ODataProperty ReadStringPropertyUnderServerKnob(string payload)
{
MemoryStream memoryStream = new MemoryStream(Encoding.UTF8.GetBytes(payload));
ODataMessageReaderSettings settings = new ODataMessageReaderSettings();
settings.EnableODataServerBehavior();
ODataAtomInputContext context = new ODataAtomInputContext(ODataFormat.Atom, memoryStream, Encoding.UTF8, settings, false /*readingResponse*/, true /*sync*/, EdmModel, null);
var deserializer = new ODataAtomPropertyAndValueDeserializer(context);
return deserializer.ReadTopLevelProperty(StringProperty, StringProperty.Type);
}
/// <inheritdoc/>
public override async Task<HttpResponseMessage> ProcessBatchAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
if (request == null)
{
throw Error.ArgumentNull("request");
}
ValidateRequest(request);
ODataMessageReaderSettings oDataReaderSettings = new ODataMessageReaderSettings
{
DisableMessageStreamDisposal = true,
MessageQuotas = MessageQuotas,
BaseUri = GetBaseUri(request)
};
ODataMessageReader reader = await request.Content.GetODataMessageReaderAsync(oDataReaderSettings, cancellationToken);
request.RegisterForDispose(reader);
ODataBatchReader batchReader = reader.CreateODataBatchReader();
List<ODataBatchResponseItem> responses = new List<ODataBatchResponseItem>();
Guid batchId = Guid.NewGuid();
List<IDisposable> resourcesToDispose = new List<IDisposable>();
try
{
while (batchReader.Read())
{
ODataBatchResponseItem responseItem = null;
if (batchReader.State == ODataBatchReaderState.ChangesetStart)
{
responseItem = await ExecuteChangeSetAsync(batchReader, batchId, request, cancellationToken);
}
else if (batchReader.State == ODataBatchReaderState.Operation)
{
responseItem = await ExecuteOperationAsync(batchReader, batchId, request, cancellationToken);
}
if (responseItem != null)
{
responses.Add(responseItem);
}
}
}
catch
{
foreach (ODataBatchResponseItem response in responses)
{
if (response != null)
{
response.Dispose();
}
}
throw;
}
return await CreateResponseMessageAsync(responses, request, cancellationToken);
}
public ODataAdapter(ISession session, string protocolVersion, HttpResponseMessage response)
: this(session, protocolVersion)
{
var readerSettings = new ODataMessageReaderSettings
{
MessageQuotas = { MaxReceivedMessageSize = Int32.MaxValue }
};
using (var messageReader = new ODataMessageReader(new ODataResponseMessage(response), readerSettings))
{
Model = messageReader.ReadMetadataDocument();
}
}
public async Task<ODataResponse> GetResponseAsync(IODataResponseMessageAsync responseMessage, bool includeResourceTypeInEntryProperties = false)
{
var readerSettings = new ODataMessageReaderSettings();
readerSettings.MessageQuotas.MaxReceivedMessageSize = Int32.MaxValue;
using (var messageReader = new ODataMessageReader(responseMessage, readerSettings, _model))
{
var payloadKind = messageReader.DetectPayloadKind();
if (payloadKind.Any(x => x.PayloadKind == ODataPayloadKind.Error))
{
return ODataResponse.FromStatusCode(responseMessage.StatusCode);
}
else if (payloadKind.Any(x => x.PayloadKind == ODataPayloadKind.Value))
{
if (payloadKind.Any(x => x.PayloadKind == ODataPayloadKind.Collection))
{
throw new NotImplementedException();
}
else
{
var text = Utils.StreamToString(await responseMessage.GetStreamAsync());
return ODataResponse.FromFeed(new[] { new Dictionary<string, object>()
{
{ FluentCommand.ResultLiteral, text }
} });
}
}
else if (payloadKind.Any(x => x.PayloadKind == ODataPayloadKind.Batch))
{
return await ReadResponse(messageReader.CreateODataBatchReader(), includeResourceTypeInEntryProperties);
}
else if (payloadKind.Any(x => x.PayloadKind == ODataPayloadKind.Feed))
{
return ReadResponse(messageReader.CreateODataFeedReader(), includeResourceTypeInEntryProperties);
}
else if (payloadKind.Any(x => x.PayloadKind == ODataPayloadKind.Collection))
{
return ReadResponse(messageReader.CreateODataCollectionReader(), includeResourceTypeInEntryProperties);
}
else if (payloadKind.Any(x => x.PayloadKind == ODataPayloadKind.Property))
{
var property = messageReader.ReadProperty();
return ODataResponse.FromFeed(new[] { new Dictionary<string, object>()
{
{ property.Name ?? FluentCommand.ResultLiteral, GetPropertyValue(property.Value) }
} });
}
else
{
return ReadResponse(messageReader.CreateODataEntryReader(), includeResourceTypeInEntryProperties);
}
}
}
/// <summary>
/// Asynchronously parses the batch requests.
/// </summary>
/// <param name="request">The HTTP request that contains the batch requests.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>The task object that represents this asynchronous operation.</returns>
public override async Task<IList<ODataBatchRequestItem>> ParseBatchRequestsAsync(
HttpRequestMessage request,
CancellationToken cancellationToken)
{
if (this.ApiFactory == null)
{
throw new InvalidOperationException(Resources.BatchHandlerRequiresApiContextFactory);
}
Ensure.NotNull(request, "request");
ODataMessageReaderSettings readerSettings = new ODataMessageReaderSettings
{
DisableMessageStreamDisposal = true,
MessageQuotas = MessageQuotas,
BaseUri = GetBaseUri(request)
};
ODataMessageReader reader =
await request.Content.GetODataMessageReaderAsync(readerSettings, cancellationToken);
request.RegisterForDispose(reader);
List<ODataBatchRequestItem> requests = new List<ODataBatchRequestItem>();
ODataBatchReader batchReader = reader.CreateODataBatchReader();
Guid batchId = Guid.NewGuid();
while (batchReader.Read())
{
if (batchReader.State == ODataBatchReaderState.ChangesetStart)
{
IList<HttpRequestMessage> changeSetRequests =
await batchReader.ReadChangeSetRequestAsync(batchId, cancellationToken);
foreach (HttpRequestMessage changeSetRequest in changeSetRequests)
{
changeSetRequest.CopyBatchRequestProperties(request);
}
requests.Add(this.CreateChangeSetRequestItem(changeSetRequests));
}
else if (batchReader.State == ODataBatchReaderState.Operation)
{
HttpRequestMessage operationRequest = await batchReader.ReadOperationRequestAsync(
batchId,
bufferContentStream: true,
cancellationToken: cancellationToken);
operationRequest.CopyBatchRequestProperties(request);
requests.Add(new OperationRequestItem(operationRequest));
}
}
return requests;
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="messageReader">The message reader to wrap.</param>
/// <param name="testConfiguration">The test configuration to use.</param>
/// <param name="message">The message to read from.</param>
/// <remarks>
/// This constructor is used if special checks against <paramref name="message"/> should be performed.
/// Use the constructor overload that does not take a <see cref="TestMessage"/> argument to prevent any checks
/// around disposal of the message.
/// </remarks>
public ODataMessageReaderTestWrapper(ODataMessageReader messageReader, ODataMessageReaderSettings messageReaderSettings, ReaderTestConfiguration testConfiguration, TestMessage message)
{
ExceptionUtilities.CheckArgumentNotNull(messageReader, "messageReader");
ExceptionUtilities.CheckArgumentNotNull(testConfiguration, "testConfiguration");
ExceptionUtilities.CheckArgumentNotNull(message, "message");
this.messageReader = messageReader;
this.messageReaderSettings = messageReaderSettings;
this.testConfiguration = testConfiguration;
this.message = message;
ExceptionUtilities.Assert(this.message.TestStream == null || this.message.TestStream.DisposeCount == 0, "If the underlying message stream is a TestStream, its dispose count must be 0.");
ExceptionUtilities.Assert(!this.message.StreamRetrieved, "GetMessage and GetMessageAsync must not be called previously on the given message.");
}
/// <summary>
/// Validates that message reader settings are correct.
/// </summary>
/// <param name="messageReaderSettings">The message reader settings to validate.</param>
/// <param name="readingResponse">true if the settings were specified when reading a response, false when reading a request.</param>
internal static void ValidateMessageReaderSettings(ODataMessageReaderSettings messageReaderSettings, bool readingResponse)
{
Debug.Assert(messageReaderSettings != null, "messageReaderSettings != null");
if (messageReaderSettings.BaseUri != null && !messageReaderSettings.BaseUri.IsAbsoluteUri)
{
throw new ODataException(Strings.ReaderValidationUtils_MessageReaderSettingsBaseUriMustBeNullOrAbsolute(UriUtils.UriToString(messageReaderSettings.BaseUri)));
}
if (!readingResponse && messageReaderSettings.UndeclaredPropertyBehaviorKinds != ODataUndeclaredPropertyBehaviorKinds.None)
{
throw new ODataException(Strings.ReaderValidationUtils_UndeclaredPropertyBehaviorKindSpecifiedOnRequest);
}
}
public DisablePrimitiveTypeConversionTests()
{
this.model = new EdmModel();
this.entityType = new EdmEntityType("FQ.NS", "EntityType", null, false, true);
this.entityType.AddStructuralProperty("String", EdmPrimitiveTypeKind.String);
this.entityType.AddStructuralProperty("Binary", EdmPrimitiveTypeKind.Binary);
this.model.AddElement(this.entityType);
var container = new EdmEntityContainer("FQ.NS", "Container");
this.model.AddElement(container);
container.AddEntitySet("Entities", this.entityType);
this.defaultSettings = new ODataMessageReaderSettings { BaseUri = new Uri("http://serviceRoot/"), EnableAtom = true };
this.settingsWithConversionDisabled = new ODataMessageReaderSettings(this.defaultSettings) { DisablePrimitiveTypeConversion = true, EnableAtom = true };
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="contentType">The parsed content type as <see cref="ODataMediaType"/>.</param>
/// <param name="encoding">The encoding from the content type or the default encoding from <see cref="ODataMediaType" />.</param>
/// <param name="messageReaderSettings">The <see cref="ODataMessageReaderSettings"/> being used for reading the message.</param>
/// <param name="model">The <see cref="IEdmModel"/> for the payload.</param>
internal ODataPayloadKindDetectionInfo(
ODataMediaType contentType,
Encoding encoding,
ODataMessageReaderSettings messageReaderSettings,
IEdmModel model)
{
ExceptionUtils.CheckArgumentNotNull(contentType, "contentType");
ExceptionUtils.CheckArgumentNotNull(messageReaderSettings, "readerSettings");
this.contentType = contentType;
this.encoding = encoding;
this.messageReaderSettings = messageReaderSettings;
this.model = model;
}
public void DefaultValuesTest()
{
ODataMessageReaderSettings settings = new ODataMessageReaderSettings();
Assert.IsNull(settings.BaseUri, "BaseUri should be null by default.");
Assert.IsFalse(settings.CheckCharacters, "The CheckCharacters should be off by default.");
Assert.IsFalse(settings.DisablePrimitiveTypeConversion, "DisablePrimitiveTypeConversion should be false by default.");
Assert.IsFalse(settings.DisableMessageStreamDisposal, "DisableMessageStreamDisposal should be false by default.");
Assert.IsFalse(settings.EnableAtomMetadataReading, "EnableAtomMetadataReading should be false by default.");
Assert.AreEqual(ODataUndeclaredPropertyBehaviorKinds.None, settings.UndeclaredPropertyBehaviorKinds, "UndeclaredPropertyBehaviorKinds should be Default by default.");
Assert.AreEqual(ODataVersion.V4, settings.MaxProtocolVersion, "MaxProtocolVersion should be V3.");
Assert.AreEqual(100, settings.MessageQuotas.MaxPartsPerBatch, "MaxPartsPerBatch should be int.MaxValue.");
Assert.AreEqual(1000, settings.MessageQuotas.MaxOperationsPerChangeset, "MaxOperationsPerChangeset should be int.MaxValue.");
Assert.AreEqual(100, settings.MessageQuotas.MaxNestingDepth, "The MaxNestingDepth should be set to 100 by default.");
Assert.AreEqual(1024 * 1024, settings.MessageQuotas.MaxReceivedMessageSize, "The MaxMessageSize should be set to 1024 * 1024 by default.");
}
/// <summary>
/// Gets the <see cref="ODataMessageReader"/> for the <see cref="HttpContent"/> stream.
/// </summary>
/// <param name="content">The <see cref="HttpContent"/>.</param>
/// <param name="settings">The <see cref="ODataMessageReaderSettings"/>.</param>
/// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
/// <returns>A task object that produces an <see cref="ODataMessageReader"/> when completed.</returns>
public static async Task<ODataMessageReader> GetODataMessageReaderAsync(this HttpContent content,
ODataMessageReaderSettings settings, CancellationToken cancellationToken)
{
if (content == null)
{
throw Error.ArgumentNull("content");
}
cancellationToken.ThrowIfCancellationRequested();
Stream contentStream = await content.ReadAsStreamAsync();
IODataRequestMessage oDataRequestMessage = new ODataMessageWrapper(contentStream, content.Headers);
ODataMessageReader oDataMessageReader = new ODataMessageReader(oDataRequestMessage, settings);
return oDataMessageReader;
}
public VCardInputContext(ODataFormat format,
Stream messageStream,
ODataMediaType contentType,
Encoding encoding,
ODataMessageReaderSettings messageReaderSettings,
bool readingResponse,
bool synchronous,
IEdmModel model,
IODataUrlResolver urlResolver)
: base(format, messageReaderSettings, readingResponse, synchronous, model, urlResolver)
{
this.stream = messageStream;
this.reader = new VCardReader(new StreamReader(messageStream, encoding));
this.throwExceptionOnDuplicatedPropertyNames = false;
}
public override System.Threading.Tasks.Task<ODataInputContext> CreateInputContextAsync(ODataMessageInfo messageInfo, ODataMessageReaderSettings messageReaderSettings)
{
return messageInfo.GetMessageStreamAsync()
.ContinueWith(
(streamTask) => (ODataInputContext) new VCardInputContext(
this,
streamTask.Result,
messageInfo.MediaType,
messageInfo.Encoding,
messageReaderSettings,
messageInfo.IsResponse,
/*sync*/ false,
messageInfo.Model,
messageInfo.UrlResolver),
TaskContinuationOptions.NotOnFaulted);
}
/// <summary>
/// Read the response message and perform given verifications
/// </summary>
/// <param name="isFeed">Whether the response has a feed</param>
/// <param name="responseMessage">The response message</param>
/// <param name="expectedSet">Expected IEdmEntitySet</param>
/// <param name="expectedType">Expected IEdmEntityType</param>
/// <param name="verifyFeed">Action to verify the feed</param>
/// <param name="verifyEntry">Action to verify the entry</param>
/// <param name="verifyNavigation">Action to verify the navigation</param>
public static void ReadAndVerifyFeedEntryMessage(bool isFeed, StreamResponseMessage responseMessage,
IEdmEntitySet expectedSet, IEdmEntityType expectedType,
Action<ODataFeed> verifyFeed, Action<ODataEntry> verifyEntry,
Action<ODataNavigationLink> verifyNavigation)
{
var settings = new ODataMessageReaderSettings() { BaseUri = ServiceUri };
settings.ShouldIncludeAnnotation = s => true;
ODataMessageReader messageReader = new ODataMessageReader(responseMessage, settings, Model);
ODataReader reader = isFeed
? messageReader.CreateODataFeedReader(expectedSet, expectedType)
: messageReader.CreateODataEntryReader(expectedSet, expectedType);
while (reader.Read())
{
switch (reader.State)
{
case ODataReaderState.FeedEnd:
{
if (verifyFeed != null)
{
verifyFeed((ODataFeed)reader.Item);
}
break;
}
case ODataReaderState.EntryEnd:
{
if (verifyEntry != null)
{
verifyEntry((ODataEntry)reader.Item);
}
break;
}
case ODataReaderState.NavigationLinkEnd:
{
if (verifyNavigation != null)
{
verifyNavigation((ODataNavigationLink)reader.Item);
}
break;
}
}
}
Assert.AreEqual(ODataReaderState.Completed, reader.State);
}
/// <summary>
/// Creates an instance of the input context for this format.
/// </summary>
/// <param name="messageInfo">The context information for the message.</param>
/// <param name="messageReaderSettings">Configuration settings of the OData reader.</param>
/// <returns>The newly created input context.</returns>
public override ODataInputContext CreateInputContext(
ODataMessageInfo messageInfo,
ODataMessageReaderSettings messageReaderSettings)
{
ExceptionUtils.CheckArgumentNotNull(messageInfo, "messageInfo");
ExceptionUtils.CheckArgumentNotNull(messageReaderSettings, "messageReaderSettings");
return new ODataMetadataInputContext(
this,
messageInfo.GetMessageStream(),
messageInfo.Encoding,
messageReaderSettings,
messageInfo.IsResponse,
/*synchronous*/ true,
messageInfo.Model,
messageInfo.UrlResolver);
}
/// <summary>
/// Validates a stream reference property.
/// </summary>
/// <param name="streamProperty">The stream property to check.</param>
/// <param name="structuredType">The owning type of the stream property or null if no metadata is available.</param>
/// <param name="streamEdmProperty">The stream property defined by the model.</param>
/// <param name="messageReaderSettings">The message reader settings being used.</param>
internal static void ValidateStreamReferenceProperty(ODataProperty streamProperty, IEdmStructuredType structuredType, IEdmProperty streamEdmProperty, ODataMessageReaderSettings messageReaderSettings)
{
Debug.Assert(streamProperty != null, "streamProperty != null");
ValidationUtils.ValidateStreamReferenceProperty(streamProperty, streamEdmProperty);
if (structuredType != null && structuredType.IsOpen)
{
// If no property match was found in the metadata and an error wasn't raised,
// it is an open property (which is not supported for streams).
if (streamEdmProperty == null && !messageReaderSettings.ReportUndeclaredLinkProperties)
{
// Fails with the correct error message.
ValidationUtils.ValidateOpenPropertyValue(streamProperty.Name, streamProperty.Value);
}
}
}
public void BaseUriGetterAndSetterTest()
{
ODataMessageReaderSettings settings = new ODataMessageReaderSettings
{
BaseUri = new Uri("http://example.org/odata.svc"),
};
var t = settings.BaseUri.ToString();
settings.BaseUri.ToString().Should().BeEquivalentTo("http://example.org/odata.svc/");
settings = new ODataMessageReaderSettings()
{
BaseUri = new Uri("http://example.org/odata.svc/"),
};
settings.BaseUri.ToString().Should().BeEquivalentTo("http://example.org/odata.svc/");
}
/// <summary>
/// Detects the payload kinds supported by this format for the specified message payload.
/// </summary>
/// <param name="messageInfo">The context information for the message.</param>
/// <param name="settings">Configuration settings of the OData reader.</param>
/// <returns>The set of <see cref="ODataPayloadKind"/>s that are supported with the specified payload.</returns>
public override IEnumerable<ODataPayloadKind> DetectPayloadKind(
ODataMessageInfo messageInfo,
ODataMessageReaderSettings settings)
{
ExceptionUtils.CheckArgumentNotNull(messageInfo, "messageInfo");
// Metadata is not supported in requests!
return messageInfo.IsResponse
? DetectPayloadKindImplementation(
messageInfo.GetMessageStream(),
new ODataPayloadKindDetectionInfo(
messageInfo.MediaType,
messageInfo.Encoding,
settings,
messageInfo.Model))
: Enumerable.Empty<ODataPayloadKind>();
}
public async Task<ODataResponse> GetResponseAsync(IODataResponseMessageAsync responseMessage)
{
var readerSettings = new ODataMessageReaderSettings();
readerSettings.MessageQuotas.MaxReceivedMessageSize = Int32.MaxValue;
using (var messageReader = new ODataMessageReader(responseMessage, readerSettings, _model))
{
var payloadKind = messageReader.DetectPayloadKind();
if (payloadKind.Any(x => x.PayloadKind == ODataPayloadKind.Error))
{
return ODataResponse.FromStatusCode(responseMessage.StatusCode);
}
else if (payloadKind.Any(x => x.PayloadKind == ODataPayloadKind.Value))
{
if (payloadKind.Any(x => x.PayloadKind == ODataPayloadKind.Collection))
{
throw new NotImplementedException();
}
else
{
return ODataResponse.FromValueStream(await responseMessage.GetStreamAsync());
}
}
else if (payloadKind.Any(x => x.PayloadKind == ODataPayloadKind.Batch))
{
return await ReadResponse(messageReader.CreateODataBatchReader());
}
else if (payloadKind.Any(x => x.PayloadKind == ODataPayloadKind.Feed))
{
return ReadResponse(messageReader.CreateODataFeedReader());
}
else if (payloadKind.Any(x => x.PayloadKind == ODataPayloadKind.Collection))
{
return ReadResponse(messageReader.CreateODataCollectionReader());
}
else if (payloadKind.Any(x => x.PayloadKind == ODataPayloadKind.Property))
{
var property = messageReader.ReadProperty();
return ODataResponse.FromProperty(property.Name, GetPropertyValue(property.Value));
}
else
{
return ReadResponse(messageReader.CreateODataEntryReader());
}
}
}
/// <summary>Initializes a new instance of the <see cref="T:Microsoft.OData.Core.ODataMessageReaderSettings" /> class.</summary>
/// <param name="other">The other message reader settings.</param>
public ODataMessageReaderSettings(ODataMessageReaderSettings other)
: base(other)
{
ExceptionUtils.CheckArgumentNotNull(other, "other");
this.BaseUri = other.BaseUri;
this.DisableMessageStreamDisposal = other.DisableMessageStreamDisposal;
this.DisablePrimitiveTypeConversion = other.DisablePrimitiveTypeConversion;
this.UndeclaredPropertyBehaviorKinds = other.UndeclaredPropertyBehaviorKinds;
this.MaxProtocolVersion = other.MaxProtocolVersion;
// NOTE: reader behavior is immutable; copy by reference is ok.
this.readerBehavior = other.ReaderBehavior;
this.EnableAtom = other.EnableAtom;
this.EnableFullValidation = other.EnableFullValidation;
this.UseKeyAsSegment = other.UseKeyAsSegment;
this.mediaTypeResolver = other.mediaTypeResolver;
this.ODataSimplified = other.ODataSimplified;
}
internal ODataAvroInputContext(
ODataFormat format,
Stream messageStream,
ODataMediaType contentType,
Encoding encoding,
ODataMessageReaderSettings messageReaderSettings,
bool readingResponse,
bool synchronous,
IEdmModel model,
IODataUrlResolver urlResolver)
: base(format, messageReaderSettings, readingResponse, synchronous, model, urlResolver)
{
this.stream = messageStream;
MemoryStream st = new MemoryStream();
stream.CopyTo(st);
st.Seek(0, SeekOrigin.Begin);
this.AvroReader = new AvroReader(AvroContainer.CreateGenericReader(st));
}
// Simple demo for reading entry
public static void ReadEntry(bool enableFullValidation)
{
var message = new Message()
{
Stream = Payloads.GetStreamFromResource("ODataSamples.Common.Payload.Entry.txt")
};
ODataEntry entry = null;
var setting = new ODataMessageReaderSettings()
{
EnableFullValidation = enableFullValidation,
ShouldIncludeAnnotation = _ => true,
};
using (var messageReader = new ODataMessageReader((IODataResponseMessage)message, setting, ExtModel.Model))
{
var reader = messageReader.CreateODataEntryReader(ExtModel.Person);
while (reader.Read())
{
switch (reader.State)
{
case ODataReaderState.EntryEnd:
entry = (ODataEntry)reader.Item;
break;
}
}
}
Console.WriteLine("Id: {0}", entry.Id);
Console.WriteLine("properties:");
foreach (var property in entry.Properties)
{
Console.WriteLine("{0}:{1}", property.Name, property.Value);
}
Console.WriteLine("Annotations:");
foreach (var annotation in entry.InstanceAnnotations)
{
Console.WriteLine("{0}:{1}", annotation.Name, annotation.Value);
}
}
internal ODataRawInputContext(
ODataFormat format,
Stream messageStream,
Encoding encoding,
ODataMessageReaderSettings messageReaderSettings,
ODataVersion version,
bool readingResponse,
bool synchronous,
IEdmModel model,
IODataUrlResolver urlResolver,
ODataPayloadKind readerPayloadKind)
: base(format, messageReaderSettings, version, readingResponse, synchronous, model, urlResolver)
{
Debug.Assert(messageStream != null, "stream != null");
Debug.Assert(readerPayloadKind != ODataPayloadKind.Unsupported, "readerPayloadKind != ODataPayloadKind.Unsupported");
ExceptionUtils.CheckArgumentNotNull(format, "format");
ExceptionUtils.CheckArgumentNotNull(messageReaderSettings, "messageReaderSettings");
try
{
this.stream = messageStream;
this.encoding = encoding;
this.readerPayloadKind = readerPayloadKind;
}
catch (Exception e)
{
// Dispose the message stream if we failed to create the input context.
if (ExceptionUtils.IsCatchableExceptionType(e) && messageStream != null)
{
messageStream.Dispose();
}
throw;
}
}
/// <summary> /// Asynchronously creates an instance of the input context for this format. /// </summary> /// <param name="messageInfo">The context information for the message.</param> /// <param name="messageReaderSettings">Configuration settings of the OData reader.</param> /// <returns>Task which when completed returned the newly created input context.</returns> public abstract Task <ODataInputContext> CreateInputContextAsync(ODataMessageInfo messageInfo, ODataMessageReaderSettings messageReaderSettings);
/// <summary> /// Asynchronously detects the payload kinds supported by this format for the specified message payload. /// </summary> /// <param name="messageInfo">The context information for the message.</param> /// <param name="settings">Configuration settings of the OData reader.</param> /// <returns>A task that when completed returns the set of <see cref="ODataPayloadKind"/>s /// that are supported with the specified payload.</returns> /// <remarks> /// The stream returned by GetMessageStream of <paramref name="messageInfo"/> could be used for reading for /// payload kind detection. Reading this stream won't affect later reading operations of payload processing. /// </remarks> public abstract Task <IEnumerable <ODataPayloadKind> > DetectPayloadKindAsync(ODataMessageInfo messageInfo, ODataMessageReaderSettings settings);
/// <summary> /// Creates an instance of the input context for this format. /// </summary> /// <param name="messageInfo">The context information for the message.</param> /// <param name="messageReaderSettings">Configuration settings of the OData reader.</param> /// <returns>The newly created input context.</returns> public abstract ODataInputContext CreateInputContext(ODataMessageInfo messageInfo, ODataMessageReaderSettings messageReaderSettings);
/// <summary> /// Detects the payload kinds supported by this format for the specified message payload. /// </summary> /// <param name="messageInfo">The context information for the message.</param> /// <param name="settings">Configuration settings of the OData reader.</param> /// <returns>The set of <see cref="ODataPayloadKind"/>s that are supported with the specified payload.</returns> /// <remarks> /// The stream returned by GetMessageStream of <paramref name="messageInfo"/> could be used for reading for /// payload kind detection. Reading this stream won't affect later reading operations of payload processing. /// </remarks> public abstract IEnumerable <ODataPayloadKind> DetectPayloadKind(ODataMessageInfo messageInfo, ODataMessageReaderSettings settings);