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