private void StartRead(ODataReader reader, ODataWriter writer)
{
ExceptionUtilities.Assert(reader.State == ODataReaderState.Start, "Reader is expected to be in state Start at StartRead.");
while (reader.Read())
{
switch (reader.State)
{
case ODataReaderState.EntryStart:
writer.WriteStart((ODataEntry)reader.Item);
break;
case ODataReaderState.FeedStart:
writer.WriteStart((ODataFeed)reader.Item);
break;
case ODataReaderState.NavigationLinkStart:
writer.WriteStart((ODataNavigationLink)reader.Item);
break;
case ODataReaderState.EntryEnd:
case ODataReaderState.FeedEnd:
case ODataReaderState.NavigationLinkEnd:
writer.WriteEnd();
break;
default:
throw new NotSupportedException();
}
;
}
}
/// <summary>
/// Read the resource set.
/// </summary>
/// <param name="reader">The OData reader.</param>
/// <param name="itemsStack">The item stack.</param>
/// <param name="topLevelItem">The top level item.</param>
private static void ReadResourceSet(ODataReader reader, Stack <ODataItemWrapper> itemsStack, ref ODataItemWrapper topLevelItem)
{
Contract.Assert(reader != null);
Contract.Assert(itemsStack != null);
Contract.Assert(ODataReaderState.ResourceSetStart == reader.State);
ODataResourceSet resourceSet = (ODataResourceSet)reader.Item;
Contract.Assert(resourceSet != null, "ResourceSet should never be null.");
ODataResourceSetWrapper resourceSetWrapper = new ODataResourceSetWrapper(resourceSet);
if (itemsStack.Count > 0)
{
ODataNestedResourceInfoWrapper parentNestedResourceInfo = (ODataNestedResourceInfoWrapper)itemsStack.Peek();
Contract.Assert(parentNestedResourceInfo != null, "this has to be an inner resource set. inner resource sets always have a nested resource info.");
Contract.Assert(parentNestedResourceInfo.NestedResourceInfo.IsCollection == true, "Only collection nested properties can contain resource set as their child.");
Contract.Assert(parentNestedResourceInfo.NestedLinks == null, "collection single nested property can not contain reference link as its direct child.");
Contract.Assert(parentNestedResourceInfo.NestedResource == null, "collection nested properties can not contain other resource as their child.");
Contract.Assert(parentNestedResourceInfo.NestedResourceSet == null, "collection nested properties can not contain multiple resource set as their child.");
parentNestedResourceInfo.NestedResourceSet = resourceSetWrapper;
}
else
{
topLevelItem = resourceSetWrapper;
}
itemsStack.Push(resourceSetWrapper);
}
private void StartRead(ODataReader reader, ODataWriter writer)
{
ExceptionUtilities.Assert(reader.State == ODataReaderState.Start, "Reader is expected to be in state Start at StartRead.");
while (reader.Read())
{
switch (reader.State)
{
case ODataReaderState.ResourceStart:
writer.WriteStart((ODataResource)reader.Item);
break;
case ODataReaderState.ResourceSetStart:
writer.WriteStart((ODataResourceSet)reader.Item);
break;
case ODataReaderState.NestedResourceInfoStart:
writer.WriteStart((ODataNestedResourceInfo)reader.Item);
break;
case ODataReaderState.ResourceEnd:
case ODataReaderState.ResourceSetEnd:
case ODataReaderState.NestedResourceInfoEnd:
writer.WriteEnd();
break;
default:
throw new NotSupportedException();
}
;
}
}
private void ParseDataFromFeedOrEntry(IInventoryCollection dataCollection, ODataReader reader)
{
while (reader.Read())
{
if (reader.State == ODataReaderState.EntryEnd)
{
{
var entry = reader.Item as ODataEntry;
if (entry != null)
{
if (entry.MediaResource != null)
{
WriteValue(null, "OData_MediaResource", entry.Properties);
}
var item = WriteProperties(entry.Properties);
if (item.IsValid)
{
dataCollection.AddItem(item);
}
}
}
}
}
}
private static void ReadOdataEntity(TableResult result, TableOperation operation, IODataResponseMessage respMsg, OperationContext ctx, ODataMessageReaderSettings readerSettings, string accountName, TableRequestOptions options)
{
using (ODataMessageReader messageReader = new ODataMessageReader(respMsg, readerSettings, new TableStorageModel(accountName)))
{
// create a reader
ODataReader reader = messageReader.CreateODataEntryReader();
while (reader.Read())
{
if (reader.State == ODataReaderState.EntryEnd)
{
ODataEntry entry = (ODataEntry)reader.Item;
if (operation.OperationType == TableOperationType.Retrieve)
{
result.Result = ReadAndResolve(entry, operation.RetrieveResolver, options);
result.Etag = entry.ETag;
}
else
{
result.Etag = ReadAndUpdateTableEntity(
operation.Entity,
entry,
EntityReadFlags.Timestamp | EntityReadFlags.Etag,
ctx);
}
}
}
DrainODataReader(reader);
}
}
public void ReadResourceOrResourceSet_ThrowsArgumentNull_EdmType()
{
// Arrange & Act & Assert
ODataReader reader = null;
ExceptionAssert.ThrowsArgumentNull(() => reader.ReadResourceOrResourceSet(), "reader");
}
/// <summary>
/// Read the deleted resource.
/// </summary>
/// <param name="reader">The OData reader.</param>
/// <param name="itemsStack">The item stack.</param>
private static void ReadDeletedResource(ODataReader reader, Stack <ODataItemWrapper> itemsStack)
{
Contract.Assert(reader != null);
Contract.Assert(itemsStack != null);
Contract.Assert(ODataReaderState.DeletedResourceStart == reader.State);
ODataDeletedResource deletedResource = (ODataDeletedResource)reader.Item;
Contract.Assert(deletedResource != null, "Deleted resource should not be null");
ODataResourceWrapper deletedResourceWrapper = new ODataResourceWrapper(deletedResource);
// top-level resource should never be deleted.
Contract.Assert(itemsStack.Count != 0, "Deleted Resource should not be top level item");
ODataItemWrapper parentItem = itemsStack.Peek();
ODataDeltaResourceSetWrapper parentDeletaResourceSet = parentItem as ODataDeltaResourceSetWrapper;
if (parentDeletaResourceSet != null)
{
parentDeletaResourceSet.DeltaItems.Add(deletedResourceWrapper);
}
else
{
ODataNestedResourceInfoWrapper parentNestedResource = (ODataNestedResourceInfoWrapper)itemsStack.Peek();
Contract.Assert(parentNestedResource.NestedResourceInfo.IsCollection == false, "Only singleton nested properties can contain resource as their child.");
Contract.Assert(parentNestedResource.NestedItems.Count == 0, "Each nested property can contain only one deleted resource as its direct child.");
parentNestedResource.NestedItems.Add(deletedResourceWrapper);
}
itemsStack.Push(deletedResourceWrapper);
}
private OeEntityItem ReadEntityFromStream(OeMessageContext context, Stream content)
{
var parser = new ODataUriParser(context.Model, context.BaseUri, RequestUrl);
IEdmEntitySet entitySet;
IEdmEntityTypeReference entityTypeRef = GetEdmEntityTypeRef(parser.ParsePath(), out entitySet);
var entityType = (IEdmEntityType)entityTypeRef.Definition;
ODataResource entry = null;
IODataRequestMessage requestMessage = new OeInMemoryMessage(content, ContentType);
var settings = new ODataMessageReaderSettings {
EnableMessageStreamDisposal = false
};
using (var messageReader = new ODataMessageReader(requestMessage, settings, context.Model))
{
ODataReader reader = messageReader.CreateODataResourceReader(entitySet, entityType);
while (reader.Read())
{
if (reader.State == ODataReaderState.ResourceEnd)
{
entry = (ODataResource)reader.Item;
}
}
if (entry == null)
{
throw new InvalidOperationException("operation not contain entry");
}
}
Db.OeEntitySetMetaAdapter entitySetMetaAdapter = context.EntitySetMetaAdapters.FindByEntitySetName(entitySet.Name);
return(new OeEntityItem(entitySet, entityType, entitySetMetaAdapter.EntityType, entry));
}
internal static MaterializerEntry ParseSingleEntityPayload(IODataResponseMessage message, ResponseInfo responseInfo, Type expectedType)
{
ODataPayloadKind payloadKind = ODataPayloadKind.Entry;
using (ODataMessageReader reader = ODataMaterializer.CreateODataMessageReader(message, responseInfo, false, ref payloadKind))
{
IEdmType orCreateEdmType = ClientEdmModel.GetModel(responseInfo.MaxProtocolVersion).GetOrCreateEdmType(expectedType);
ODataReader reader2 = ODataMaterializer.CreateODataReader(reader, payloadKind, orCreateEdmType, responseInfo.MaxProtocolVersion);
ODataFeedOrEntryReader reader3 = new ODataFeedOrEntryReader(reader2, responseInfo);
ODataEntry currentEntry = null;
bool flag = false;
while (reader3.Read())
{
flag |= reader3.CurrentFeed != null;
if (reader3.CurrentEntry != null)
{
if (currentEntry != null)
{
throw new InvalidOperationException(System.Data.Services.Client.Strings.AtomParser_SingleEntry_MultipleFound);
}
currentEntry = reader3.CurrentEntry;
}
}
if (currentEntry == null)
{
if (flag)
{
throw new InvalidOperationException(System.Data.Services.Client.Strings.AtomParser_SingleEntry_NoneFound);
}
throw new InvalidOperationException(System.Data.Services.Client.Strings.AtomParser_SingleEntry_ExpectedFeedOrEntry);
}
return(MaterializerEntry.GetEntry(currentEntry));
}
}
private static object ConvertResource(ODataMessageReader oDataMessageReader, IEdmTypeReference edmTypeReference,
ODataDeserializerContext readContext)
{
EdmEntitySet tempEntitySet = null;
if (edmTypeReference.IsEntity())
{
IEdmEntityTypeReference entityType = edmTypeReference.AsEntity();
tempEntitySet = new EdmEntitySet(readContext.Model.EntityContainer, "temp",
entityType.EntityDefinition());
}
// TODO: Sam xu, can we use the parameter-less overload
ODataReader resourceReader = oDataMessageReader.CreateODataUriParameterResourceReader(tempEntitySet,
edmTypeReference.ToStructuredType());
object item = resourceReader.ReadResourceOrResourceSet();
ODataResourceWrapper topLevelResource = item as ODataResourceWrapper;
Contract.Assert(topLevelResource != null);
ODataDeserializerProvider deserializerProvider = readContext.Request.GetDeserializerProvider();
ODataResourceDeserializer entityDeserializer =
(ODataResourceDeserializer)deserializerProvider.GetEdmTypeDeserializer(edmTypeReference);
return(entityDeserializer.ReadInline(topLevelResource, edmTypeReference, readContext));
}
private static ODataResource ReadEntityFromStream(IEdmModel edmModel, Uri baseUri, Stream content, Uri requestUrl, String contentType, out IEdmEntitySet entitySet)
{
var parser = new ODataUriParser(edmModel, baseUri, requestUrl);
IEdmEntityTypeReference entityTypeRef = GetEdmEntityTypeRef(parser.ParsePath(), out entitySet);
ODataResource entry = null;
IODataRequestMessage requestMessage = new OeInMemoryMessage(content, contentType);
var settings = new ODataMessageReaderSettings {
EnableMessageStreamDisposal = false
};
using (var messageReader = new ODataMessageReader(requestMessage, settings, edmModel))
{
ODataReader reader = messageReader.CreateODataResourceReader(entitySet, entitySet.EntityType());
while (reader.Read())
{
if (reader.State == ODataReaderState.ResourceEnd)
{
entry = (ODataResource)reader.Item;
}
}
if (entry == null)
{
throw new InvalidOperationException("operation not contain entry");
}
}
return(entry);
}
/// <inheritdoc />
public override async Task <object> ReadAsync(ODataMessageReader messageReader, Type type, ODataDeserializerContext readContext)
{
if (messageReader == null)
{
throw Error.ArgumentNull(nameof(messageReader));
}
if (readContext == null)
{
throw Error.ArgumentNull(nameof(readContext));
}
IEdmTypeReference edmType = readContext.GetEdmType(type);
Contract.Assert(edmType != null);
// TODO: is it ok to read the top level collection of entity?
if (!(edmType.IsCollection() && edmType.AsCollection().ElementType().IsStructured()))
{
throw Error.Argument("edmType", SRResources.ArgumentMustBeOfType, EdmTypeKind.Complex + " or " + EdmTypeKind.Entity);
}
ODataReader resourceSetReader = await messageReader.CreateODataResourceSetReaderAsync().ConfigureAwait(false);
object resourceSet = await resourceSetReader.ReadResourceOrResourceSetAsync().ConfigureAwait(false);
return(ReadInline(resourceSet, edmType, readContext));
}
/// <inheritdoc />
public override object Read(ODataMessageReader messageReader, ODataDeserializerContext readContext)
{
if (messageReader == null)
{
throw Error.ArgumentNull("messageReader");
}
if (readContext == null)
{
throw Error.ArgumentNull("readContext");
}
if (readContext.Path == null)
{
throw Error.Argument("readContext", SRResources.ODataPathMissing);
}
IEdmEntitySet entitySet = GetEntitySet(readContext.Path);
if (entitySet == null)
{
throw new SerializationException(SRResources.EntitySetMissingDuringDeserialization);
}
ODataReader odataReader = messageReader.CreateODataEntryReader(entitySet, EntityType.EntityDefinition());
ODataEntryWithNavigationLinks topLevelEntry = ReadEntryOrFeed(odataReader) as ODataEntryWithNavigationLinks;
Contract.Assert(topLevelEntry != null);
return(ReadInline(topLevelEntry, readContext));
}
protected override object Read(System.Data.Services.SegmentInfo segmentInfo)
{
ODataEntry entry;
ResourceType targetResourceType = segmentInfo.TargetResourceType;
IEdmEntityType schemaType = (IEdmEntityType)base.GetSchemaType(targetResourceType);
ODataReader odataReader = base.MessageReader.CreateODataEntryReader(schemaType);
try
{
entry = this.ReadEntry(odataReader, segmentInfo);
}
catch (UriFormatException exception)
{
if (this.ContentFormat == ContentFormat.Atom)
{
throw DataServiceException.CreateBadRequestError(System.Data.Services.Strings.Syndication_ErrorReadingEntry(exception.Message), exception);
}
throw;
}
ODataEntryAnnotation entryAnnotation = entry.GetAnnotation <ODataEntryAnnotation>();
base.RecurseEnter();
this.ApplyEntityProperties(segmentInfo, entry, entryAnnotation);
base.RecurseLeave();
return(entryAnnotation.EntityResource);
}
/// <summary>
/// Creates an OData reader to read OData feed download response.
/// </summary>
/// <param name="reader">The message reader containing current OData feed download response.</param>
/// <returns>an OData reader to read OData feed download response</returns>
private ODataReader CreateReader(ODataMessageReader reader)
{
ODataReader resultReader = null;
resultReader = reader.CreateODataFeedReader();
return(resultReader);
}
private ODataResource ReadEntityFromStream(Stream content, Uri requestUrl, String contentType, out IEdmEntitySet entitySet)
{
ODataUri odataUri = OeParser.ParseUri(_edmModel, _baseUri, requestUrl);
entitySet = ((EntitySetSegment)odataUri.Path.FirstSegment).EntitySet;
_edmEntityType = entitySet.EntityType();
IEdmModel edmModel = _edmModel.GetEdmModel(entitySet);
ODataResource entry = null;
IODataRequestMessage requestMessage = new Infrastructure.OeInMemoryMessage(content, contentType, _serviceProvider);
var settings = new ODataMessageReaderSettings
{
ClientCustomTypeResolver = ClientCustomTypeResolver,
EnableMessageStreamDisposal = false
};
using (var messageReader = new ODataMessageReader(requestMessage, settings, edmModel))
{
ODataReader reader = messageReader.CreateODataResourceReader(entitySet, entitySet.EntityType());
while (reader.Read())
{
if (reader.State == ODataReaderState.ResourceEnd)
{
entry = (ODataResource)reader.Item;
}
}
if (entry == null)
{
throw new InvalidOperationException("operation not contain entry");
}
}
return(entry);
}
/// <summary>
/// Read the delta resource set.
/// </summary>
/// <param name="reader">The OData reader.</param>
/// <param name="itemsStack">The item stack.</param>
/// <param name="topLevelItem">The top level item.</param>
private static void ReadDeltaResourceSet(ODataReader reader, Stack <ODataItemWrapper> itemsStack, ref ODataItemWrapper topLevelItem)
{
Contract.Assert(reader != null);
Contract.Assert(itemsStack != null);
Contract.Assert(ODataReaderState.DeltaResourceSetStart == reader.State);
ODataDeltaResourceSet deltaResourceSet = (ODataDeltaResourceSet)reader.Item;
Contract.Assert(deltaResourceSet != null, "Delta ResourceSet should never be null.");
ODataDeltaResourceSetWrapper deltaResourceSetWrapper = new ODataDeltaResourceSetWrapper(deltaResourceSet);
if (itemsStack.Count > 0)
{
ODataNestedResourceInfoWrapper parentNestedResourceInfo = (ODataNestedResourceInfoWrapper)itemsStack.Peek();
Contract.Assert(parentNestedResourceInfo != null, "this has to be an inner delta resource set. inner delta resource sets always have a nested resource info.");
Contract.Assert(parentNestedResourceInfo.NestedResourceInfo.IsCollection == true, "Only collection nested properties can contain delta resource set as their child.");
Contract.Assert(parentNestedResourceInfo.NestedItems.Count == 0, "Each nested property can contain only one delta resource set as its direct child.");
parentNestedResourceInfo.NestedItems.Add(deltaResourceSetWrapper);
}
else
{
topLevelItem = deltaResourceSetWrapper;
}
itemsStack.Push(deltaResourceSetWrapper);
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="reader">The reader to wrap.</param>
/// <param name="testConfiguration">The test configuration to use.</param>
public ODataReaderTestWrapper(ODataReader reader, ReaderTestConfiguration testConfiguration)
{
ExceptionUtilities.CheckArgumentNotNull(reader, "reader");
ExceptionUtilities.CheckArgumentNotNull(testConfiguration, "testConfiguration");
this.reader = reader;
this.testConfiguration = testConfiguration;
}
public ODataFeedOrEntryReader(ODataReader reader, ResponseInfo responseInfo)
{
this.reader = reader;
this.responseInfo = responseInfo;
this.currentEntry = null;
this.currentFeed = null;
this.feedEntries = null;
}
private static void FillParameters(IEdmModel edmModel, List <KeyValuePair <String, Object> > parameters, Stream requestStream, IEdmOperation operation, String contentType)
{
if (!operation.Parameters.Any())
{
return;
}
IODataRequestMessage requestMessage = new Infrastructure.OeInMemoryMessage(requestStream, contentType);
var settings = new ODataMessageReaderSettings()
{
EnableMessageStreamDisposal = false
};
using (var messageReader = new ODataMessageReader(requestMessage, settings, edmModel))
{
ODataParameterReader parameterReader = messageReader.CreateODataParameterReader(operation);
while (parameterReader.Read())
{
Object value;
switch (parameterReader.State)
{
case ODataParameterReaderState.Value:
{
value = OeEdmClrHelper.GetValue(edmModel, parameterReader.Value);
break;
}
case ODataParameterReaderState.Collection:
{
ODataCollectionReader collectionReader = parameterReader.CreateCollectionReader();
value = OeEdmClrHelper.GetValue(edmModel, ReadCollection(collectionReader));
break;
}
case ODataParameterReaderState.Resource:
{
ODataReader reader = parameterReader.CreateResourceReader();
value = OeEdmClrHelper.GetValue(edmModel, ReadResource(reader));
break;
}
case ODataParameterReaderState.ResourceSet:
{
ODataReader reader = parameterReader.CreateResourceSetReader();
value = OeEdmClrHelper.GetValue(edmModel, ReadResourceSet(reader));
break;
}
default:
continue;
}
parameters.Add(new KeyValuePair <String, Object>(parameterReader.Name, value));
}
}
}
public void RunReadFeedTest(bool isFullValidation)
{
using (var messageReader = ODataMessageHelper.CreateMessageReader(_stream, Model, ODataMessageKind.Response, isFullValidation))
{
ODataReader feedReader = messageReader.CreateODataResourceSetReader(TestEntitySet, TestEntityType);
while (feedReader.Read())
{
}
}
}
internal static ResultSegment <TElement> TableQueryPostProcessGeneric <TElement, TQueryType>(Stream responseStream, Func <string, string, DateTimeOffset, IDictionary <string, EntityProperty>, string, TElement> resolver, HttpWebResponse resp, TableRequestOptions options, OperationContext ctx, string accountName)
{
ResultSegment <TElement> retSeg = new ResultSegment <TElement>(new List <TElement>());
retSeg.ContinuationToken = ContinuationFromResponse(resp);
if (resp.ContentType.Contains(Constants.JsonNoMetadataAcceptHeaderValue))
{
ReadQueryResponseUsingJsonParser(retSeg, responseStream, resp.Headers[Constants.HeaderConstants.EtagHeader], resolver, options.PropertyResolver, typeof(TQueryType), null, options);
}
else
{
ODataMessageReaderSettings readerSettings = new ODataMessageReaderSettings();
readerSettings.MessageQuotas = new ODataMessageQuotas()
{
MaxPartsPerBatch = TableConstants.TableServiceMaxResults, MaxReceivedMessageSize = TableConstants.TableServiceMaxPayload
};
using (ODataMessageReader responseReader = new ODataMessageReader(new HttpResponseAdapterMessage(resp, responseStream), readerSettings, new TableStorageModel(accountName)))
{
// create a reader
ODataReader reader = responseReader.CreateODataFeedReader();
// Start => FeedStart
if (reader.State == ODataReaderState.Start)
{
reader.Read();
}
// Feedstart
if (reader.State == ODataReaderState.FeedStart)
{
reader.Read();
}
while (reader.State == ODataReaderState.EntryStart)
{
// EntryStart => EntryEnd
reader.Read();
ODataEntry entry = (ODataEntry)reader.Item;
retSeg.Results.Add(ReadAndResolve(entry, resolver, options));
// Entry End => ?
reader.Read();
}
DrainODataReader(reader);
}
}
Logger.LogInformational(ctx, SR.RetrieveWithContinuationToken, retSeg.Results.Count, retSeg.ContinuationToken);
return(retSeg);
}
private static object ConvertResourceSet(ODataMessageReader oDataMessageReader,
IEdmTypeReference edmTypeReference, ODataDeserializerContext readContext)
{
IEdmCollectionTypeReference collectionType = edmTypeReference.AsCollection();
EdmEntitySet tempEntitySet = null;
if (collectionType.ElementType().IsEntity())
{
tempEntitySet = new EdmEntitySet(readContext.Model.EntityContainer, "temp",
collectionType.ElementType().AsEntity().EntityDefinition());
}
// TODO: Sam xu, can we use the parameter-less overload
ODataReader odataReader = oDataMessageReader.CreateODataUriParameterResourceSetReader(tempEntitySet,
collectionType.ElementType().AsStructured().StructuredDefinition());
ODataResourceSetWrapper resourceSet =
odataReader.ReadResourceOrResourceSet() as ODataResourceSetWrapper;
ODataDeserializerProvider deserializerProvider = readContext.Request.GetDeserializerProvider();
ODataResourceSetDeserializer resourceSetDeserializer =
(ODataResourceSetDeserializer)deserializerProvider.GetEdmTypeDeserializer(collectionType);
object result = resourceSetDeserializer.ReadInline(resourceSet, collectionType, readContext);
IEnumerable enumerable = result as IEnumerable;
if (enumerable != null)
{
IEnumerable newEnumerable = enumerable;
if (collectionType.ElementType().IsEntity())
{
newEnumerable = CovertResourceSetIds(enumerable, resourceSet, collectionType, readContext);
}
if (readContext.IsUntyped)
{
return(newEnumerable.ConvertToEdmObject(collectionType));
}
else
{
IEdmTypeReference elementTypeReference = collectionType.ElementType();
Type elementClrType = EdmLibHelpers.GetClrType(elementTypeReference,
readContext.Model);
IEnumerable castedResult =
CastMethodInfo.MakeGenericMethod(elementClrType)
.Invoke(null, new object[] { newEnumerable }) as IEnumerable;
return(castedResult);
}
}
return(null);
}
/// <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 <ODataResourceSet> verifyFeed, Action <ODataResource> verifyEntry,
Action <ODataNestedResourceInfo> verifyNavigation)
{
var settings = new ODataMessageReaderSettings()
{
BaseUri = ServiceUri
};
settings.ShouldIncludeAnnotation = s => true;
ODataMessageReader messageReader = new ODataMessageReader(responseMessage, settings, Model);
ODataReader reader = isFeed
? messageReader.CreateODataResourceSetReader(expectedSet, expectedType)
: messageReader.CreateODataResourceReader(expectedSet, expectedType);
while (reader.Read())
{
switch (reader.State)
{
case ODataReaderState.ResourceSetEnd:
{
if (verifyFeed != null)
{
verifyFeed((ODataResourceSet)reader.Item);
}
break;
}
case ODataReaderState.ResourceEnd:
{
if (verifyEntry != null && reader.Item != null)
{
verifyEntry((ODataResource)reader.Item);
}
break;
}
case ODataReaderState.NestedResourceInfoEnd:
{
if (verifyNavigation != null)
{
verifyNavigation((ODataNestedResourceInfo)reader.Item);
}
break;
}
}
}
Assert.AreEqual(ODataReaderState.Completed, reader.State);
}
/// <summary>
/// Reads feed from stream
/// </summary>
/// <param name="readStream"></param>
/// <param name="edmModel"></param>
/// <param name="entitySet"></param>
/// <param name="expectedBaseEntityType"></param>
protected void ReadFeed(Stream readStream, IEdmModel edmModel, IEdmEntitySetBase entitySet, IEdmEntityType expectedBaseEntityType)
{
readStream.Seek(0, SeekOrigin.Begin);
using (var messageReader = ODataMessageHelper.CreateMessageReader(readStream, edmModel))
{
ODataReader feedReader = messageReader.CreateODataFeedReader(entitySet, expectedBaseEntityType);
while (feedReader.Read())
{
}
}
}
internal static Task <TableQuerySegment> TableQueryPostProcess(Stream responseStream, HttpResponseMessage resp, Exception ex, OperationContext ctx)
{
return(Task.Run(() =>
{
TableQuerySegment retSeg = new TableQuerySegment();
retSeg.ContinuationToken = ContinuationFromResponse(resp);
ODataMessageReaderSettings readerSettings = new ODataMessageReaderSettings()
{
DisablePrimitiveTypeConversion = true
};
readerSettings.MessageQuotas = new ODataMessageQuotas()
{
MaxPartsPerBatch = TableConstants.TableServiceMaxResults, MaxReceivedMessageSize = TableConstants.TableServiceMaxPayload
};
using (ODataMessageReader responseReader = new ODataMessageReader(new HttpResponseAdapterMessage(resp, responseStream), readerSettings))
{
// create a reader
ODataReader reader = responseReader.CreateODataFeedReader();
// Start => FeedStart
if (reader.State == ODataReaderState.Start)
{
reader.Read();
}
// Feedstart
if (reader.State == ODataReaderState.FeedStart)
{
reader.Read();
}
while (reader.State == ODataReaderState.EntryStart)
{
// EntryStart => EntryEnd
reader.Read();
ODataEntry entry = (ODataEntry)reader.Item;
DynamicTableEntity retEntity = new DynamicTableEntity();
ReadAndUpdateTableEntity(retEntity, entry, EntityReadFlags.All, ctx);
retSeg.Results.Add(retEntity);
// Entry End => ?
reader.Read();
}
DrainODataReader(reader);
}
return retSeg;
}));
}
private static ODataResource ReadResource(ODataReader reader)
{
while (reader.Read())
{
if (reader.State == ODataReaderState.ResourceEnd)
{
return((ODataResource)reader.Item);
}
}
throw new InvalidOperationException("ResourceEnd not found");
}
private static void DrainODataReader(ODataReader reader)
{
if (reader.State == ODataReaderState.FeedEnd)
{
reader.Read();
}
if (reader.State != ODataReaderState.Completed)
{
throw new InvalidOperationException(string.Format(CultureInfo.InvariantCulture, SR.ODataReaderNotInCompletedState, reader.State));
}
}
private void ReadEntry(ODataReader reader, ref List <ODataResource> entries)
{
switch (reader.State)
{
case ODataReaderState.ResourceStart:
entries.Add(reader.Item as ODataResource);
break;
default:
break;
}
}
/// <summary>
/// Reads the input request payload and returns the WCF DS value representation of it.
/// </summary>
/// <param name="segmentInfo">Info about the request to read.</param>
/// <returns>The WCF DS representation of the value read.</returns>
protected override object Read(SegmentInfo segmentInfo)
{
Debug.Assert(segmentInfo != null, "segmentInfo != null");
Debug.Assert(segmentInfo.TargetKind == RequestTargetKind.Resource, "The EntityDeserializer only supports Resource target kinds.");
ResourceType expectedResourceType = segmentInfo.TargetResourceType;
Debug.Assert(expectedResourceType != null, "To read an entity we must know the expected resource type of the entity to read.");
Debug.Assert(expectedResourceType.ResourceTypeKind == ResourceTypeKind.EntityType, "Only entity types can be used as types for entities.");
IEdmEntityType expectedEntityType = (IEdmEntityType)this.GetSchemaType(expectedResourceType);
MetadataProviderEdmModel metadataProviderEdmModel = this.Service.Provider.GetMetadataProviderEdmModel();
Debug.Assert(metadataProviderEdmModel.Mode == MetadataProviderEdmModelMode.Serialization, "Model expected to be in serialization mode.");
IEdmEntitySet expectedEntitySet = WebUtil.GetEntitySet(this.Service.Provider, metadataProviderEdmModel, segmentInfo.TargetResourceSet);
ODataReader odataReader = this.MessageReader.CreateODataEntryReader(expectedEntitySet, expectedEntityType);
#pragma warning disable 618
AssertReaderFormatIsExpected(this.MessageReader, ODataFormat.Atom, ODataFormat.Json);
#pragma warning restore 618
// Read the entry and all its children into a tree. We use annotation to connect the items into the tree.
// Note that we must cache the entire payload to preserve call order for navigation properties.
// Due to the fact that the payload order on the wire is arbitrary, but we always set all non-navigation properties first
// and then apply all navigation properties, we must cache the entire tree.
ODataEntry topLevelEntry;
try
{
topLevelEntry = this.ReadEntry(odataReader, segmentInfo);
}
catch (UriFormatException exception)
{
// For backward compatibility with previous released when reading ATOM we need to catch UriFormatExceptions and wrap them
// in a bad request exception so that a 400 is reported back. In JSON we used to not do this and thus we need to continue
// throwing the original exception which will cause a 500.
if (this.IsAtomRequest)
{
throw DataServiceException.CreateBadRequestError(Microsoft.OData.Service.Strings.Syndication_ErrorReadingEntry(exception.Message), exception);
}
throw;
}
ODataEntryAnnotation topLevelEntryAnnotation = topLevelEntry.GetAnnotation <ODataEntryAnnotation>();
Debug.Assert(topLevelEntryAnnotation != null, "Each entry we read must have the entry annotation.");
this.RecurseEnter();
this.ApplyEntityProperties(segmentInfo, topLevelEntry, topLevelEntryAnnotation);
this.RecurseLeave();
return(topLevelEntryAnnotation);
}
