/// <summary>
/// Gets an entity metadata builder for the given entry.
/// </summary>
/// <param name="entryState">Entry state to use as reference for information needed by the builder.</param>
/// <returns>An entity metadata builder.</returns>
public ODataEntityMetadataBuilder GetEntityMetadataBuilderForReader(IODataJsonLightReaderEntryState entryState)
{
Debug.Assert(entryState != null, "entry != null");
// Only apply the conventional template builder on response. On a request we would only report what's on the wire.
if (entryState.MetadataBuilder == null)
{
ODataEntry entry = entryState.Entry;
if (this.isResponse)
{
ODataTypeAnnotation typeAnnotation = entry.GetAnnotation <ODataTypeAnnotation>();
Debug.Assert(typeAnnotation != null, "The JSON light reader should have already set the ODataTypeAnnotation.");
IEdmNavigationSource navigationSource = typeAnnotation.NavigationSource;
IEdmEntityType navigationSourceElementType = this.edmTypeResolver.GetElementType(navigationSource);
IODataFeedAndEntryTypeContext typeContext = ODataFeedAndEntryTypeContext.Create(/*serializationInfo*/ null, navigationSource, navigationSourceElementType, entryState.EntityType, this.model, /*throwIfMissingTypeInfo*/ true);
IODataEntryMetadataContext entryMetadataContext = ODataEntryMetadataContext.Create(entry, typeContext, /*serializationInfo*/ null, (IEdmEntityType)entry.GetEdmType().Definition, this, entryState.SelectedProperties);
UrlConvention urlConvention = UrlConvention.ForUserSettingAndTypeContext(/*keyAsSegment*/ null, typeContext);
ODataConventionalUriBuilder uriBuilder = new ODataConventionalUriBuilder(this.ServiceBaseUri, urlConvention);
entryState.MetadataBuilder = new ODataConventionalEntityMetadataBuilder(entryMetadataContext, this, uriBuilder);
}
else
{
entryState.MetadataBuilder = new NoOpEntityMetadataBuilder(entry);
}
}
return(entryState.MetadataBuilder);
}
public ODataEntityMetadataBuilder GetEntityMetadataBuilderForReader(IODataJsonLightReaderEntryState entryState, bool?useKeyAsSegment)
{
if (this.GetEntityMetadataBuilderFunc != null)
{
return(this.GetEntityMetadataBuilderFunc(entryState.Entry));
}
throw new NotImplementedException();
}
/// <summary>
/// Validates entry metadata.
/// </summary>
/// <param name="entryState">The entry state to use.</param>
internal void ValidateEntryMetadata(IODataJsonLightReaderEntryState entryState)
{
ODataEntry entry = entryState.Entry;
if (entry != null)
{
IEdmEntityType entityType = entryState.EntityType;
// If the entry in the model has a default stream and if no MR related metadata exists in the entry payload, create an empty MediaResource.
// Note that for responses the metadata builder will compute the default stream. For requests we really don't need to add the default stream since the service knows its metadata.
// We leave this here for now so we don't introduce a breaking change.
if (!this.ReadingResponse && entityType.HasStream && entry.MediaResource == null)
{
ODataStreamReferenceValue mediaResource = entry.MediaResource;
ODataJsonLightReaderUtils.EnsureInstance(ref mediaResource);
this.SetEntryMediaResource(entryState, mediaResource);
}
// By default validate media resource
// In WCF DS Server mode, validate media resource in JSON Light (here)
// In WCF DS Client mode, do not validate media resource.
// Client doesn't validate default media resource against metadata.
// Server doesn't validate default media resource when reading Verbose JSON against the model
// So it doesn't fail if the model says the entity should have an MR, but the payload doesn't and vice versa.
bool validateMediaResource = this.UseDefaultFormatBehavior || this.UseServerFormatBehavior;
ValidationUtils.ValidateEntryMetadataResource(entry, entityType, this.Model, validateMediaResource);
}
}
/// <summary>
/// Read the metadata reference property value for the entry being read.
/// </summary>
/// <param name="entryState">The state of the reader for entry to read.</param>
/// <param name="metadataReferencePropertyName">The name of the metadata reference property being read.</param>
/// <remarks>
/// Pre-Condition: JsonNodeType.Property: first node of the metadata reference property's value. Currently
/// actions and functions are the only supported metadata reference property,
/// we will throw if this is not a start object or start array node.
/// Post-Condition: JsonNodeType.Property: the property after the annotation value
/// JsonNodeType.EndObject: the end-object of the entry
/// </remarks>
private void ReadMetadataReferencePropertyValue(IODataJsonLightReaderEntryState entryState, string metadataReferencePropertyName)
{
Debug.Assert(entryState != null, "entryState != null");
Debug.Assert(entryState.Entry != null, "entryState.Entry != null");
Debug.Assert(!string.IsNullOrEmpty(metadataReferencePropertyName), "!string.IsNullOrEmpty(metadataReferencePropertyName)");
Debug.Assert(metadataReferencePropertyName.IndexOf(ODataConstants.ContextUriFragmentIndicator) > -1, "metadataReferencePropertyName.IndexOf(JsonLightConstants.ContextUriFragmentIndicator) > -1");
this.JsonReader.AssertNotBuffering();
this.ValidateCanReadMetadataReferenceProperty();
// Validate that the property name is a valid absolute URI or a valid URI fragment.
ODataJsonLightValidationUtils.ValidateMetadataReferencePropertyName(this.ContextUriParseResult.MetadataDocumentUri, metadataReferencePropertyName);
IODataJsonOperationsDeserializerContext readerContext = new OperationsDeserializerContext(entryState.Entry, this);
bool insideArray = false;
if (readerContext.JsonReader.NodeType == JsonNodeType.StartArray)
{
readerContext.JsonReader.ReadStartArray();
insideArray = true;
}
do
{
this.ReadSingleOperationValue(readerContext, entryState, metadataReferencePropertyName, insideArray);
}
while (insideArray && readerContext.JsonReader.NodeType != JsonNodeType.EndArray);
if (insideArray)
{
readerContext.JsonReader.ReadEndArray();
}
this.JsonReader.AssertNotBuffering();
this.AssertJsonCondition(JsonNodeType.Property, JsonNodeType.EndObject);
}
/// <summary>
/// Sets the metadata builder for the operation.
/// </summary>
/// <param name="entryState">The state of the reader for entry to read.</param>
/// <param name="operation">The operation to set the metadata builder on.</param>
private void SetMetadataBuilder(IODataJsonLightReaderEntryState entryState, ODataOperation operation)
{
ODataEntityMetadataBuilder builder = this.MetadataContext.GetEntityMetadataBuilderForReader(entryState, this.JsonLightInputContext.MessageReaderSettings.UseKeyAsSegment);
operation.SetMetadataBuilder(builder, this.ContextUriParseResult.MetadataDocumentUri);
}
public ODataEntityMetadataBuilder GetEntityMetadataBuilderForReader(IODataJsonLightReaderEntryState entryState, bool? useKeyAsSegment)
{
if (this.GetEntityMetadataBuilderFunc != null)
{
return this.GetEntityMetadataBuilderFunc(entryState.Entry);
}
throw new NotImplementedException();
}
/// <summary>
/// Reads entity reference links for a collection navigation link in request.
/// </summary>
/// <param name="entryState">The state of the reader for entry to read.</param>
/// <param name="navigationProperty">The navigation property for which to read the entity reference links.</param>
/// <param name="isExpanded">true if the navigation link is expanded.</param>
/// <returns>The navigation link info for the entity reference links read.</returns>
/// <remarks>
/// This method doesn't move the reader.
/// </remarks>
private static ODataJsonLightReaderNavigationLinkInfo ReadEntityReferenceLinksForCollectionNavigationLinkInRequest(
IODataJsonLightReaderEntryState entryState,
IEdmNavigationProperty navigationProperty,
bool isExpanded)
{
Debug.Assert(entryState != null, "entryState != null");
Debug.Assert(navigationProperty != null, "navigationProperty != null");
ODataNavigationLink navigationLink = new ODataNavigationLink()
{
Name = navigationProperty.Name,
IsCollection = true
};
Dictionary<string, object> propertyAnnotations = entryState.DuplicatePropertyNamesChecker.GetODataPropertyAnnotations(navigationLink.Name);
LinkedList<ODataEntityReferenceLink> entityReferenceLinksList = null;
if (propertyAnnotations != null)
{
foreach (KeyValuePair<string, object> propertyAnnotation in propertyAnnotations)
{
switch (propertyAnnotation.Key)
{
case ODataAnnotationNames.ODataBind:
ODataEntityReferenceLink entityReferenceLink = propertyAnnotation.Value as ODataEntityReferenceLink;
if (entityReferenceLink != null)
{
throw new ODataException(ODataErrorStrings.ODataJsonLightEntryAndFeedDeserializer_StringValueForCollectionBindPropertyAnnotation(navigationLink.Name, ODataAnnotationNames.ODataBind));
}
Debug.Assert(
propertyAnnotation.Value is LinkedList<ODataEntityReferenceLink> && propertyAnnotation.Value != null,
"The value of odata.bind property annotation must be either ODataEntityReferenceLink or List<ODataEntityReferenceLink>");
entityReferenceLinksList = (LinkedList<ODataEntityReferenceLink>)propertyAnnotation.Value;
break;
default:
throw new ODataException(ODataErrorStrings.ODataJsonLightEntryAndFeedDeserializer_UnexpectedNavigationLinkInRequestPropertyAnnotation(
navigationLink.Name,
propertyAnnotation.Key,
ODataAnnotationNames.ODataBind));
}
}
}
return ODataJsonLightReaderNavigationLinkInfo.CreateCollectionEntityReferenceLinksInfo(navigationLink, navigationProperty, entityReferenceLinksList, isExpanded);
}
/// <summary>
/// Reads expanded feed navigation link.
/// </summary>
/// <param name="entryState">The state of the reader for entry to read.</param>
/// <param name="navigationProperty">The navigation property for which to read the expanded link.</param>
/// <returns>The navigation link info for the expanded link read.</returns>
/// <remarks>
/// This method doesn't move the reader.
/// </remarks>
private static ODataJsonLightReaderNavigationLinkInfo ReadExpandedFeedNavigationLink(IODataJsonLightReaderEntryState entryState, IEdmNavigationProperty navigationProperty)
{
Debug.Assert(entryState != null, "entryState != null");
Debug.Assert(navigationProperty != null, "navigationProperty != null");
ODataNavigationLink navigationLink = new ODataNavigationLink()
{
Name = navigationProperty.Name,
IsCollection = true
};
ODataFeed expandedFeed = new ODataFeed();
Dictionary<string, object> propertyAnnotations = entryState.DuplicatePropertyNamesChecker.GetODataPropertyAnnotations(navigationLink.Name);
if (propertyAnnotations != null)
{
foreach (KeyValuePair<string, object> propertyAnnotation in propertyAnnotations)
{
switch (propertyAnnotation.Key)
{
case ODataAnnotationNames.ODataNavigationLinkUrl:
Debug.Assert(propertyAnnotation.Value is Uri && propertyAnnotation.Value != null, "The odata.navigationLinkUrl annotation should have been parsed as a non-null Uri.");
navigationLink.Url = (Uri)propertyAnnotation.Value;
break;
case ODataAnnotationNames.ODataAssociationLinkUrl:
Debug.Assert(propertyAnnotation.Value is Uri && propertyAnnotation.Value != null, "The odata.associationLinkUrl annotation should have been parsed as a non-null Uri.");
navigationLink.AssociationLinkUrl = (Uri)propertyAnnotation.Value;
break;
case ODataAnnotationNames.ODataNextLink:
Debug.Assert(propertyAnnotation.Value is Uri && propertyAnnotation.Value != null, "The odata.nextLink annotation should have been parsed as a non-null Uri.");
expandedFeed.NextPageLink = (Uri)propertyAnnotation.Value;
break;
case ODataAnnotationNames.ODataCount:
Debug.Assert(propertyAnnotation.Value is long && propertyAnnotation.Value != null, "The odata.count annotation should have been parsed as a non-null long.");
expandedFeed.Count = (long?)propertyAnnotation.Value;
break;
case ODataAnnotationNames.ODataContext:
Debug.Assert(propertyAnnotation.Value is Uri && propertyAnnotation.Value != null, "The odata.context annotation should have been parsed as a non-null Uri.");
navigationLink.ContextUrl = (Uri)propertyAnnotation.Value;
break;
case ODataAnnotationNames.ODataDeltaLink: // Delta links are not supported on expanded feeds.
default:
throw new ODataException(ODataErrorStrings.ODataJsonLightEntryAndFeedDeserializer_UnexpectedExpandedCollectionNavigationLinkPropertyAnnotation(navigationLink.Name, propertyAnnotation.Key));
}
}
}
return ODataJsonLightReaderNavigationLinkInfo.CreateExpandedFeedLinkInfo(navigationLink, navigationProperty, expandedFeed);
}
/// <summary>
/// Reads the information of a deferred link.
/// </summary>
/// <param name="entryState">The state of the reader for entry to read.</param>
/// <param name="navigationPropertyName">The name of the navigation property for which to read the deferred link.</param>
/// <param name="navigationProperty">The navigation property for which to read the deferred link. This can be null.</param>
/// <returns>Returns the navigation link info for the deferred navigation link read.</returns>
/// <remarks>
/// This method doesn't move the reader.
/// </remarks>
private static ODataJsonLightReaderNavigationLinkInfo ReadDeferredNavigationLink(IODataJsonLightReaderEntryState entryState, string navigationPropertyName, IEdmNavigationProperty navigationProperty)
{
Debug.Assert(entryState != null, "entryState != null");
Debug.Assert(!string.IsNullOrEmpty(navigationPropertyName), "!string.IsNullOrEmpty(navigationPropertyName)");
Debug.Assert(navigationProperty == null || navigationPropertyName == navigationProperty.Name, "navigationProperty == null || navigationPropertyName == navigationProperty.Name");
ODataNavigationLink navigationLink = new ODataNavigationLink()
{
Name = navigationPropertyName,
IsCollection = navigationProperty == null ? null : (bool?)navigationProperty.Type.IsCollection()
};
Dictionary<string, object> propertyAnnotations = entryState.DuplicatePropertyNamesChecker.GetODataPropertyAnnotations(navigationLink.Name);
if (propertyAnnotations != null)
{
foreach (KeyValuePair<string, object> propertyAnnotation in propertyAnnotations)
{
switch (propertyAnnotation.Key)
{
case ODataAnnotationNames.ODataNavigationLinkUrl:
Debug.Assert(propertyAnnotation.Value is Uri && propertyAnnotation.Value != null, "The odata.navigationLinkUrl annotation should have been parsed as a non-null Uri.");
navigationLink.Url = (Uri)propertyAnnotation.Value;
break;
case ODataAnnotationNames.ODataAssociationLinkUrl:
Debug.Assert(propertyAnnotation.Value is Uri && propertyAnnotation.Value != null, "The odata.associationLinkUrl annotation should have been parsed as a non-null Uri.");
navigationLink.AssociationLinkUrl = (Uri)propertyAnnotation.Value;
break;
default:
throw new ODataException(ODataErrorStrings.ODataJsonLightEntryAndFeedDeserializer_UnexpectedDeferredLinkPropertyAnnotation(navigationLink.Name, propertyAnnotation.Key));
}
}
}
return ODataJsonLightReaderNavigationLinkInfo.CreateDeferredLinkInfo(navigationLink, navigationProperty);
}
/// <summary>
/// Read an open property.
/// </summary>
/// <param name="entryState">The state of the reader for entry to read.</param>
/// <param name="propertyName">The name of the open property to read.</param>
/// <param name="propertyWithValue">true if the property has a value, false if it doesn't.</param>
/// <remarks>
/// Pre-Condition: The reader is positioned on the first node of the property value
/// Post-Condition: JsonNodeType.Property: the next property of the entry
/// JsonNodeType.EndObject: the end-object node of the entry
/// </remarks>
private void ReadOpenProperty(IODataJsonLightReaderEntryState entryState, string propertyName, bool propertyWithValue)
{
Debug.Assert(entryState != null, "entryState != null");
Debug.Assert(!string.IsNullOrEmpty(propertyName), "!string.IsNullOrEmpty(propertyName)");
this.JsonReader.AssertNotBuffering();
// Property without a value can't be ignored if we don't know what it is.
if (!propertyWithValue)
{
throw new ODataException(ODataErrorStrings.ODataJsonLightEntryAndFeedDeserializer_OpenPropertyWithoutValue(propertyName));
}
string propertyTypeName = ValidateDataPropertyTypeNameAnnotation(entryState.DuplicatePropertyNamesChecker, propertyName);
object propertyValue = this.ReadNonEntityValue(
propertyTypeName,
/*expectedValueTypeReference*/ null,
/*duplicatePropertyNamesChecker*/ null,
/*collectionValidator*/ null,
/*validateNullValue*/ true,
/*isTopLevelPropertyValue*/ false,
/*insideComplexValue*/ false,
propertyName,
true);
ValidationUtils.ValidateOpenPropertyValue(propertyName, propertyValue);
AddEntryProperty(entryState, propertyName, propertyValue);
this.JsonReader.AssertNotBuffering();
Debug.Assert(
this.JsonReader.NodeType == JsonNodeType.Property || this.JsonReader.NodeType == JsonNodeType.EndObject,
"Post-Condition: expected JsonNodeType.Property or JsonNodeType.EndObject");
}
/// <summary>
/// Read an entry-level data property and check its version compliance.
/// </summary>
/// <param name="entryState">The state of the reader for entry to read.</param>
/// <param name="edmProperty">The EDM property of the property being read, or null if the property is an open property.</param>
/// <param name="propertyTypeName">The type name specified for the property in property annotation, or null if no such type name is available.</param>
/// <remarks>
/// Pre-Condition: The reader is positioned on the first node of the property value
/// Post-Condition: JsonNodeType.Property: the next property of the entry
/// JsonNodeType.EndObject: the end-object node of the entry
/// </remarks>
private void ReadEntryDataProperty(IODataJsonLightReaderEntryState entryState, IEdmProperty edmProperty, string propertyTypeName)
{
Debug.Assert(entryState != null, "entryState != null");
Debug.Assert(edmProperty != null, "edmProperty != null");
this.JsonReader.AssertNotBuffering();
// EdmLib bridge marks all key properties as non-nullable, but Astoria allows them to be nullable.
// If the property has an annotation to ignore null values, we need to omit the property in requests.
ODataNullValueBehaviorKind nullValueReadBehaviorKind = this.ReadingResponse
? ODataNullValueBehaviorKind.Default
: this.Model.NullValueReadBehaviorKind(edmProperty);
object propertyValue = this.ReadNonEntityValue(
propertyTypeName,
edmProperty.Type,
/*duplicatePropertyNamesChecker*/ null,
/*collectionValidator*/ null,
nullValueReadBehaviorKind == ODataNullValueBehaviorKind.Default,
/*isTopLevelPropertyValue*/ false,
/*insideComplexValue*/ false,
edmProperty.Name);
if (nullValueReadBehaviorKind != ODataNullValueBehaviorKind.IgnoreValue || propertyValue != null)
{
AddEntryProperty(entryState, edmProperty.Name, propertyValue);
}
this.JsonReader.AssertNotBuffering();
Debug.Assert(
this.JsonReader.NodeType == JsonNodeType.Property || this.JsonReader.NodeType == JsonNodeType.EndObject,
"Post-Condition: expected JsonNodeType.Property or JsonNodeType.EndObject");
}
/// <summary>
/// Reads entry property (which is neither instance nor property annotation) which has a value.
/// </summary>
/// <param name="entryState">The state of the reader for entry to read.</param>
/// <param name="propertyName">The name of the property read.</param>
/// <returns>A reader navigation link info representing the navigation link detected while reading the entry contents; null if no navigation link was detected.</returns>
/// <remarks>
/// Pre-Condition: JsonNodeType.PrimitiveValue The value of the property
/// JsonNodeType.StartObject
/// JsonNodeType.StartArray
/// Post-Condition: JsonNodeType.EndObject The end of the entry object
/// JsonNodeType.Property The next property after the property
/// JsonNodeType.StartObject Expanded entry
/// JsonNodeType.StartArray Expanded feed
/// JsonNodeType.PrimitiveValue (null) Expanded null entry
/// </remarks>
private ODataJsonLightReaderNavigationLinkInfo ReadEntryPropertyWithValue(IODataJsonLightReaderEntryState entryState, string propertyName)
{
Debug.Assert(entryState != null, "entryState != null");
Debug.Assert(!string.IsNullOrEmpty(propertyName), "!string.IsNullOrEmpty(propertyName)");
this.AssertJsonCondition(JsonNodeType.PrimitiveValue, JsonNodeType.StartObject, JsonNodeType.StartArray);
ODataJsonLightReaderNavigationLinkInfo navigationLinkInfo = null;
IEdmEntityType entityType = entryState.EntityType;
IEdmProperty edmProperty = ReaderValidationUtils.FindDefinedProperty(propertyName, entityType);
if (edmProperty != null)
{
// Declared property - read it.
IEdmNavigationProperty navigationProperty = edmProperty as IEdmNavigationProperty;
if (navigationProperty != null)
{
// Expanded link
bool isCollection = navigationProperty.Type.IsCollection();
this.ValidateExpandedNavigationLinkPropertyValue(isCollection, navigationProperty.Name);
if (isCollection)
{
navigationLinkInfo = this.ReadingResponse
? ReadExpandedFeedNavigationLink(entryState, navigationProperty)
: ReadEntityReferenceLinksForCollectionNavigationLinkInRequest(entryState, navigationProperty, /*isExpanded*/ true);
}
else
{
navigationLinkInfo = this.ReadingResponse
? ReadExpandedEntryNavigationLink(entryState, navigationProperty)
: ReadEntityReferenceLinkForSingletonNavigationLinkInRequest(entryState, navigationProperty, /*isExpanded*/ true);
}
entryState.DuplicatePropertyNamesChecker.CheckForDuplicatePropertyNamesOnNavigationLinkStart(navigationLinkInfo.NavigationLink);
}
else
{
IEdmTypeReference propertyTypeReference = edmProperty.Type;
if (propertyTypeReference.IsStream())
{
throw new ODataException(ODataErrorStrings.ODataJsonLightEntryAndFeedDeserializer_StreamPropertyWithValue(propertyName));
}
// NOTE: we currently do not check whether the property should be skipped
// here because this can only happen for navigation properties and open properties.
this.ReadEntryDataProperty(entryState, edmProperty, ValidateDataPropertyTypeNameAnnotation(entryState.DuplicatePropertyNamesChecker, propertyName));
}
}
else
{
// Undeclared property - we need to run detection alogorithm here.
navigationLinkInfo = this.ReadUndeclaredProperty(entryState, propertyName, /*propertyWithValue*/ true);
// Note that if navigation link is returned it's already validated, so we just report it here.
}
this.AssertJsonCondition(JsonNodeType.Property, JsonNodeType.EndObject, JsonNodeType.StartObject, JsonNodeType.StartArray, JsonNodeType.PrimitiveValue);
return navigationLinkInfo;
}
/// <summary>
/// Sets specified media resource on an entry and hooks up metadata builder.
/// </summary>
/// <param name="entryState">The entry state to use.</param>
/// <param name="mediaResource">The media resource to set.</param>
private void SetEntryMediaResource(IODataJsonLightReaderEntryState entryState, ODataStreamReferenceValue mediaResource)
{
Debug.Assert(entryState != null, "entryState != null");
Debug.Assert(mediaResource != null, "mediaResource != null");
ODataEntry entry = entryState.Entry;
Debug.Assert(entry != null, "entry != null");
ODataEntityMetadataBuilder builder = this.MetadataContext.GetEntityMetadataBuilderForReader(entryState, this.JsonLightInputContext.MessageReaderSettings.UseKeyAsSegment);
mediaResource.SetMetadataBuilder(builder, /*propertyName*/ null);
entry.MediaResource = mediaResource;
}
/// <summary>
/// Adds a new property to an entry.
/// </summary>
/// <param name="entryState">The entry state for the entry to add the property to.</param>
/// <param name="propertyName">The name of the property to add.</param>
/// <param name="propertyValue">The value of the property to add.</param>
private static void AddEntryProperty(IODataJsonLightReaderEntryState entryState, string propertyName, object propertyValue)
{
Debug.Assert(entryState != null, "entryState != null");
Debug.Assert(!string.IsNullOrEmpty(propertyName), "!string.IsNullOrEmpty(propertyName)");
ODataProperty property = new ODataProperty { Name = propertyName, Value = propertyValue };
var propertyAnnotations = entryState.DuplicatePropertyNamesChecker.GetCustomPropertyAnnotations(propertyName);
if (propertyAnnotations != null)
{
foreach (var annotation in propertyAnnotations)
{
if (annotation.Value != null)
{
// annotation.Value == null indicates that this annotation should be skipped.
property.InstanceAnnotations.Add(new ODataInstanceAnnotation(annotation.Key, annotation.Value.ToODataValue()));
}
}
}
entryState.DuplicatePropertyNamesChecker.CheckForDuplicatePropertyNames(property);
ODataEntry entry = entryState.Entry;
Debug.Assert(entry != null, "entry != null");
entry.Properties = entry.Properties.ConcatToReadOnlyEnumerable("Properties", property);
}
internal void ApplyEntryInstanceAnnotation(IODataJsonLightReaderEntryState entryState, string annotationName, object annotationValue)
{
Debug.Assert(entryState != null, "entryState != null");
Debug.Assert(!string.IsNullOrEmpty(annotationName), "!string.IsNullOrEmpty(annotationName)");
ODataEntry entry = entryState.Entry;
ODataStreamReferenceValue mediaResource = entry.MediaResource;
switch (annotationName)
{
case ODataAnnotationNames.ODataType: // 'odata.type'
entry.TypeName = ReaderUtils.AddEdmPrefixOfTypeName(ReaderUtils.RemovePrefixOfTypeName((string)annotationValue));
break;
case ODataAnnotationNames.ODataId: // 'odata.id'
if (annotationValue == null)
{
entry.IsTransient = true;
}
else
{
entry.Id = (Uri)annotationValue;
}
break;
case ODataAnnotationNames.ODataETag: // 'odata.etag'
entry.ETag = (string)annotationValue;
break;
case ODataAnnotationNames.ODataEditLink: // 'odata.editLink'
entry.EditLink = (Uri)annotationValue;
break;
case ODataAnnotationNames.ODataReadLink: // 'odata.readLink'
entry.ReadLink = (Uri)annotationValue;
break;
case ODataAnnotationNames.ODataMediaEditLink: // 'odata.mediaEditLink'
ODataJsonLightReaderUtils.EnsureInstance(ref mediaResource);
mediaResource.EditLink = (Uri)annotationValue;
break;
case ODataAnnotationNames.ODataMediaReadLink: // 'odata.mediaReadLink'
ODataJsonLightReaderUtils.EnsureInstance(ref mediaResource);
mediaResource.ReadLink = (Uri)annotationValue;
break;
case ODataAnnotationNames.ODataMediaContentType: // 'odata.mediaContentType'
ODataJsonLightReaderUtils.EnsureInstance(ref mediaResource);
mediaResource.ContentType = (string)annotationValue;
break;
case ODataAnnotationNames.ODataMediaETag: // 'odata.mediaEtag'
ODataJsonLightReaderUtils.EnsureInstance(ref mediaResource);
mediaResource.ETag = (string)annotationValue;
break;
default:
ODataAnnotationNames.ValidateIsCustomAnnotationName(annotationName);
Debug.Assert(
!this.MessageReaderSettings.ShouldSkipAnnotation(annotationName),
"!this.MessageReaderSettings.ShouldReadAndValidateAnnotation(annotationName) -- otherwise we should have already skipped the custom annotation and won't see it here.");
entry.InstanceAnnotations.Add(new ODataInstanceAnnotation(annotationName, annotationValue.ToODataValue()));
break;
}
if (mediaResource != null && entry.MediaResource == null)
{
this.SetEntryMediaResource(entryState, mediaResource);
}
}
/// <summary>
/// Reads entry property which doesn't have value, just annotations.
/// </summary>
/// <param name="entryState">The state of the reader for entry to read.</param>
/// <param name="propertyName">The name of the property read.</param>
/// <returns>A reader navigation link info representing the navigation link detected while reading the entry contents; null if no navigation link was detected.</returns>
/// <remarks>
/// Pre-Condition: JsonNodeType.EndObject The end of the entry object.
/// JsonNodeType.Property The property after the one we're to read.
/// Post-Condition: JsonNodeType.EndObject This method doesn't move the reader.
/// JsonNodeType.Property
/// </remarks>
internal ODataJsonLightReaderNavigationLinkInfo ReadEntryPropertyWithoutValue(IODataJsonLightReaderEntryState entryState, string propertyName)
{
Debug.Assert(entryState != null, "entryState != null");
Debug.Assert(!string.IsNullOrEmpty(propertyName), "!string.IsNullOrEmpty(propertyName)");
this.AssertJsonCondition(JsonNodeType.Property, JsonNodeType.EndObject);
ODataJsonLightReaderNavigationLinkInfo navigationLinkInfo = null;
IEdmEntityType entityType = entryState.EntityType;
IEdmProperty edmProperty = ReaderValidationUtils.FindDefinedProperty(propertyName, entityType);
if (edmProperty != null)
{
// Declared property - read it.
IEdmNavigationProperty navigationProperty = edmProperty as IEdmNavigationProperty;
if (navigationProperty != null)
{
if (this.ReadingResponse)
{
// Deferred link
navigationLinkInfo = ReadDeferredNavigationLink(entryState, propertyName, navigationProperty);
}
else
{
// Entity reference link or links
navigationLinkInfo = navigationProperty.Type.IsCollection()
? ReadEntityReferenceLinksForCollectionNavigationLinkInRequest(entryState, navigationProperty, /*isExpanded*/ false)
: ReadEntityReferenceLinkForSingletonNavigationLinkInRequest(entryState, navigationProperty, /*isExpanded*/ false);
if (!navigationLinkInfo.HasEntityReferenceLink)
{
throw new ODataException(ODataErrorStrings.ODataJsonLightEntryAndFeedDeserializer_NavigationPropertyWithoutValueAndEntityReferenceLink(propertyName, ODataAnnotationNames.ODataBind));
}
}
entryState.DuplicatePropertyNamesChecker.CheckForDuplicatePropertyNamesOnNavigationLinkStart(navigationLinkInfo.NavigationLink);
}
else
{
IEdmTypeReference propertyTypeReference = edmProperty.Type;
if (propertyTypeReference.IsStream())
{
Debug.Assert(propertyName == edmProperty.Name, "propertyName == edmProperty.Name");
ODataStreamReferenceValue streamPropertyValue = this.ReadStreamPropertyValue(entryState, propertyName);
AddEntryProperty(entryState, edmProperty.Name, streamPropertyValue);
}
else
{
throw new ODataException(ODataErrorStrings.ODataJsonLightEntryAndFeedDeserializer_PropertyWithoutValueWithWrongType(propertyName, propertyTypeReference.ODataFullName()));
}
}
}
else
{
// Undeclared property - we need to run detection alogorithm here.
navigationLinkInfo = this.ReadUndeclaredProperty(entryState, propertyName, /*propertyWithValue*/ false);
}
this.AssertJsonCondition(JsonNodeType.Property, JsonNodeType.EndObject);
return navigationLinkInfo;
}
/// <summary>
/// Reads the content of an entry until a navigation link is detected.
/// </summary>
/// <param name="entryState">The state of the reader for entry to read.</param>
/// <returns>A reader navigation link info representing the navigation link detected while reading the entry contents; null if no navigation link was detected.</returns>
/// <remarks>
/// Pre-Condition: JsonNodeType.Property The property to read
/// JsonNodeType.EndObject If no (more) properties exist in the entry's content
/// Post-Condition: JsonNodeType.EndObject If no (more) properties exist in the entry's content
/// JsonNodeType.Property If we've read a deferred link (this is the property after the deferred link)
/// JsonNodeType.StartObject Expanded entry
/// JsonNodeType.StartArray Expanded feed
/// JsonNodeType.PrimitiveValue (null) Expanded null
/// </remarks>
internal ODataJsonLightReaderNavigationLinkInfo ReadEntryContent(IODataJsonLightReaderEntryState entryState)
{
Debug.Assert(entryState != null, "entryState != null");
Debug.Assert(entryState.EntityType != null && this.Model.IsUserModel(), "A non-null entity type and non-null model are required.");
Debug.Assert(
this.JsonReader.NodeType == JsonNodeType.Property || this.JsonReader.NodeType == JsonNodeType.EndObject,
"Pre-Condition: JsonNodeType.Property or JsonNodeType.EndObject");
this.JsonReader.AssertNotBuffering();
ODataJsonLightReaderNavigationLinkInfo navigationLinkInfo = null;
Debug.Assert(entryState.EntityType != null, "In JSON we must always have an entity type when reading entity.");
// Figure out whether we have more properties for this entry
// read all the properties until we hit a link
while (this.JsonReader.NodeType == JsonNodeType.Property)
{
this.ReadPropertyCustomAnnotationValue = this.ReadCustomInstanceAnnotationValue;
this.ProcessProperty(
entryState.DuplicatePropertyNamesChecker,
this.ReadEntryPropertyAnnotationValue,
(propertyParsingResult, propertyName) =>
{
switch (propertyParsingResult)
{
case PropertyParsingResult.ODataInstanceAnnotation:
case PropertyParsingResult.CustomInstanceAnnotation:
object value = this.ReadEntryInstanceAnnotation(propertyName, entryState.AnyPropertyFound, /*typeAnnotationFound*/ true, entryState.DuplicatePropertyNamesChecker);
this.ApplyEntryInstanceAnnotation(entryState, propertyName, value);
break;
case PropertyParsingResult.PropertyWithoutValue:
entryState.AnyPropertyFound = true;
navigationLinkInfo = this.ReadEntryPropertyWithoutValue(entryState, propertyName);
break;
case PropertyParsingResult.PropertyWithValue:
entryState.AnyPropertyFound = true;
navigationLinkInfo = this.ReadEntryPropertyWithValue(entryState, propertyName);
break;
case PropertyParsingResult.MetadataReferenceProperty:
this.ReadMetadataReferencePropertyValue(entryState, propertyName);
break;
case PropertyParsingResult.EndOfObject:
break;
}
});
if (navigationLinkInfo != null)
{
// we found a navigation link
// stop parsing the entry content and return to the caller
break;
}
Debug.Assert(
this.JsonReader.NodeType == JsonNodeType.Property || this.JsonReader.NodeType == JsonNodeType.EndObject,
"After reading a property the reader should be positioned on another property or have hit the end of the object.");
}
this.JsonReader.AssertNotBuffering();
// The reader can be either on
// - StartObject - if it's an expanded entry
// - StartArray - if it's an expanded feed
// - Property - if it's a deferred link
// - PrimitiveValue (null) - if it's an expanded null entry
// - EndObject - end of the entry
Debug.Assert(
navigationLinkInfo != null && this.JsonReader.NodeType == JsonNodeType.StartObject ||
navigationLinkInfo != null && this.JsonReader.NodeType == JsonNodeType.StartArray ||
navigationLinkInfo != null && this.JsonReader.NodeType == JsonNodeType.Property ||
navigationLinkInfo != null && this.JsonReader.NodeType == JsonNodeType.PrimitiveValue && this.JsonReader.Value == null ||
this.JsonReader.NodeType == JsonNodeType.EndObject,
"Post-Condition: expected JsonNodeType.StartObject or JsonNodeType.StartArray or JsonNodeType.Property or JsonNodeType.EndObject or JsonNodeType.Primitive (with null value)");
return navigationLinkInfo;
}
/// <summary>
/// Reads expanded entry navigation link.
/// </summary>
/// <param name="entryState">The state of the reader for entry to read.</param>
/// <param name="navigationProperty">The navigation property for which to read the expanded link.</param>
/// <returns>The navigation link info for the expanded link read.</returns>
/// <remarks>
/// This method doesn't move the reader.
/// </remarks>
private static ODataJsonLightReaderNavigationLinkInfo ReadExpandedEntryNavigationLink(IODataJsonLightReaderEntryState entryState, IEdmNavigationProperty navigationProperty)
{
Debug.Assert(entryState != null, "entryState != null");
Debug.Assert(navigationProperty != null, "navigationProperty != null");
ODataNavigationLink navigationLink = new ODataNavigationLink()
{
Name = navigationProperty.Name,
IsCollection = false
};
Dictionary<string, object> propertyAnnotations = entryState.DuplicatePropertyNamesChecker.GetODataPropertyAnnotations(navigationLink.Name);
if (propertyAnnotations != null)
{
foreach (KeyValuePair<string, object> propertyAnnotation in propertyAnnotations)
{
switch (propertyAnnotation.Key)
{
case ODataAnnotationNames.ODataNavigationLinkUrl:
Debug.Assert(propertyAnnotation.Value is Uri && propertyAnnotation.Value != null, "The odata.navigationLinkUrl annotation should have been parsed as a non-null Uri.");
navigationLink.Url = (Uri)propertyAnnotation.Value;
break;
case ODataAnnotationNames.ODataAssociationLinkUrl:
Debug.Assert(propertyAnnotation.Value is Uri && propertyAnnotation.Value != null, "The odata.associationLinkUrl annotation should have been parsed as a non-null Uri.");
navigationLink.AssociationLinkUrl = (Uri)propertyAnnotation.Value;
break;
case ODataAnnotationNames.ODataContext:
Debug.Assert(propertyAnnotation.Value is Uri && propertyAnnotation.Value != null, "The odata.context annotation should have been parsed as a non-null Uri.");
navigationLink.ContextUrl = (Uri)propertyAnnotation.Value;
break;
default:
throw new ODataException(ODataErrorStrings.ODataJsonLightEntryAndFeedDeserializer_UnexpectedExpandedSingletonNavigationLinkPropertyAnnotation(navigationLink.Name, propertyAnnotation.Key));
}
}
}
return ODataJsonLightReaderNavigationLinkInfo.CreateExpandedEntryLinkInfo(navigationLink, navigationProperty);
}
/// <summary>
/// Read an undeclared property. That is a property which is not declared by the model, but the owning type is not an open type.
/// </summary>
/// <param name="entryState">The state of the reader for entry to read.</param>
/// <param name="propertyName">The name of the open property to read.</param>
/// <param name="propertyWithValue">true if the property has a value, false if it doesn't.</param>
/// <remarks>
/// Pre-Condition: JsonNodeType.PrimitiveValue: propertyWithValue is true and the reader is positioned on the first node of the property value.
/// JsonNodeType.StartObject:
/// JsonNodeType.StartArray:
/// JsonNodeType.Property: propertyWithValue is false and the reader is positioned on the node after the property.
/// JsonNodeType.EndObject:
/// Post-Condition: JsonNodeType.Property: the next property of the entry
/// JsonNodeType.EndObject: the end-object node of the entry
/// </remarks>
/// <returns>A navigation link info instance if the propery read is a navigation link which should be reported to the caller.
/// Otherwise null if the property was either ignored or read and added to the list of properties on the entry.</returns>
private ODataJsonLightReaderNavigationLinkInfo ReadUndeclaredProperty(IODataJsonLightReaderEntryState entryState, string propertyName, bool propertyWithValue)
{
Debug.Assert(entryState != null, "entryState != null");
Debug.Assert(!string.IsNullOrEmpty(propertyName), "!string.IsNullOrEmpty(propertyName)");
#if DEBUG
if (propertyWithValue)
{
this.AssertJsonCondition(JsonNodeType.PrimitiveValue, JsonNodeType.StartObject, JsonNodeType.StartArray);
}
else
{
this.AssertJsonCondition(JsonNodeType.Property, JsonNodeType.EndObject);
}
#endif
// to preserve error messages, if we're not going to report undeclared links, then read open properties first.
if (!this.MessageReaderSettings.ReportUndeclaredLinkProperties)
{
if (entryState.EntityType.IsOpen)
{
// Open property - read it as such.
this.ReadOpenProperty(entryState, propertyName, propertyWithValue);
return null;
}
}
// Undeclared property
// Detect whether it's a link property or value property.
// Link properties are stream properties and deferred links.
Dictionary<string, object> odataPropertyAnnotations = entryState.DuplicatePropertyNamesChecker.GetODataPropertyAnnotations(propertyName);
if (odataPropertyAnnotations != null)
{
object propertyAnnotationValue;
// If the property has 'odata.navigationLink' or 'odata.associationLink' annotation, read it as a navigation property
if (odataPropertyAnnotations.TryGetValue(ODataAnnotationNames.ODataNavigationLinkUrl, out propertyAnnotationValue) ||
odataPropertyAnnotations.TryGetValue(ODataAnnotationNames.ODataAssociationLinkUrl, out propertyAnnotationValue))
{
// Undeclared link properties are reported if the right flag is used, otherwise we need to fail.
if (!this.MessageReaderSettings.ReportUndeclaredLinkProperties)
{
throw new ODataException(ODataErrorStrings.ValidationUtils_PropertyDoesNotExistOnType(propertyName, entryState.EntityType.ODataFullName()));
}
// Read it as a deferred link - we never read the expanded content.
ODataJsonLightReaderNavigationLinkInfo navigationLinkInfo = ReadDeferredNavigationLink(entryState, propertyName, /*navigationProperty*/ null);
entryState.DuplicatePropertyNamesChecker.CheckForDuplicatePropertyNamesOnNavigationLinkStart(navigationLinkInfo.NavigationLink);
// If the property is expanded, ignore the content if we're asked to do so.
if (propertyWithValue)
{
if (!this.MessageReaderSettings.IgnoreUndeclaredValueProperties)
{
throw new ODataException(ODataErrorStrings.ValidationUtils_PropertyDoesNotExistOnType(propertyName, entryState.EntityType.ODataFullName()));
}
this.ValidateExpandedNavigationLinkPropertyValue(null, propertyName);
// Since we marked the navigation link as deffered the reader will not try to read its content
// instead it will behave as if it was a real deferred link (without a property value).
// So skip the value here to move to the next property in the payload, which will look exactly the same
// as if the navigation link was deferred.
this.JsonReader.SkipValue();
}
return navigationLinkInfo;
}
// If the property has 'odata.mediaEditLink', 'odata.mediaReadLink', 'odata.mediaContentType' or 'odata.mediaEtag' annotation, read it as a stream property
if (odataPropertyAnnotations.TryGetValue(ODataAnnotationNames.ODataMediaEditLink, out propertyAnnotationValue) ||
odataPropertyAnnotations.TryGetValue(ODataAnnotationNames.ODataMediaReadLink, out propertyAnnotationValue) ||
odataPropertyAnnotations.TryGetValue(ODataAnnotationNames.ODataMediaContentType, out propertyAnnotationValue) ||
odataPropertyAnnotations.TryGetValue(ODataAnnotationNames.ODataMediaETag, out propertyAnnotationValue))
{
// Undeclared link properties are reported if the right flag is used, otherwise we need to fail.
if (!this.MessageReaderSettings.ReportUndeclaredLinkProperties)
{
throw new ODataException(ODataErrorStrings.ValidationUtils_PropertyDoesNotExistOnType(propertyName, entryState.EntityType.ODataFullName()));
}
// Stream properties can't have a value
if (propertyWithValue)
{
throw new ODataException(ODataErrorStrings.ODataJsonLightEntryAndFeedDeserializer_StreamPropertyWithValue(propertyName));
}
ODataStreamReferenceValue streamPropertyValue = this.ReadStreamPropertyValue(entryState, propertyName);
AddEntryProperty(entryState, propertyName, streamPropertyValue);
return null;
}
}
if (entryState.EntityType.IsOpen)
{
// Open property - read it as such.
this.ReadOpenProperty(entryState, propertyName, propertyWithValue);
return null;
}
// Property without a value can't be ignored if we don't know what it is.
if (!propertyWithValue)
{
throw new ODataException(ODataErrorStrings.ODataJsonLightEntryAndFeedDeserializer_PropertyWithoutValueWithUnknownType(propertyName));
}
// Property with value can only be ignored if we're asked to do so.
if (!this.MessageReaderSettings.IgnoreUndeclaredValueProperties)
{
throw new ODataException(ODataErrorStrings.ValidationUtils_PropertyDoesNotExistOnType(propertyName, entryState.EntityType.ODataFullName()));
}
// Validate that the property doesn't have unrecognized annotations
// We ignore the type name since we might not have the full model and thus might not be able to resolve it correctly.
ValidateDataPropertyTypeNameAnnotation(entryState.DuplicatePropertyNamesChecker, propertyName);
// Read it as such.
this.ReadOpenProperty(entryState, propertyName, propertyWithValue);
return null;
}
/// <summary>
/// Reads the entry type name annotation (odata.type)
/// </summary>
/// <param name="entryState">The state of the reader for entry to read.</param>
/// <remarks>
/// Pre-Condition: JsonNodeType.Property The first property after the odata.context in the entry object.
/// JsonNodeType.EndObject End of the entry object.
/// Post-Condition: JsonNodeType.Property The property after the odata.type (if there was any), or the property on which the method was called.
/// JsonNodeType.EndObject End of the entry object.
///
/// This method fills the ODataEntry.TypeName property if the type name is found in the payload.
/// </remarks>
internal void ReadEntryTypeName(IODataJsonLightReaderEntryState entryState)
{
Debug.Assert(entryState != null, "entryState != null");
this.AssertJsonCondition(JsonNodeType.Property, JsonNodeType.EndObject);
// If the current node is the odata.type property - read it.
if (this.JsonReader.NodeType == JsonNodeType.Property &&
string.CompareOrdinal(JsonLightConstants.ODataPropertyAnnotationSeparatorChar + ODataAnnotationNames.ODataType, this.JsonReader.GetPropertyName()) == 0)
{
Debug.Assert(entryState.Entry.TypeName == null, "type name should not have already been set");
// Read over the property to move to its value.
this.JsonReader.Read();
// Read the annotation value.
entryState.Entry.TypeName = this.ReadODataTypeAnnotationValue();
}
this.AssertJsonCondition(JsonNodeType.Property, JsonNodeType.EndObject);
}
/// <summary>
/// Reads a stream property value from the property annotations.
/// </summary>
/// <param name="entryState">The state of the reader for entry to read.</param>
/// <param name="streamPropertyName">The name of the stream property to read the value for.</param>
/// <returns>The newly created stream reference value.</returns>
private ODataStreamReferenceValue ReadStreamPropertyValue(IODataJsonLightReaderEntryState entryState, string streamPropertyName)
{
Debug.Assert(entryState != null, "entryState != null");
Debug.Assert(!string.IsNullOrEmpty(streamPropertyName), "!string.IsNullOrEmpty(streamPropertyName)");
// Fail on stream properties in requests as they cannot appear there.
if (!this.ReadingResponse)
{
throw new ODataException(ODataErrorStrings.ODataJsonLightEntryAndFeedDeserializer_StreamPropertyInRequest);
}
ODataStreamReferenceValue streamReferenceValue = new ODataStreamReferenceValue();
Dictionary<string, object> propertyAnnotations = entryState.DuplicatePropertyNamesChecker.GetODataPropertyAnnotations(streamPropertyName);
if (propertyAnnotations != null)
{
foreach (KeyValuePair<string, object> propertyAnnotation in propertyAnnotations)
{
switch (propertyAnnotation.Key)
{
case ODataAnnotationNames.ODataMediaEditLink:
Debug.Assert(propertyAnnotation.Value is Uri && propertyAnnotation.Value != null, "The odata.mediaEditLink annotation should have been parsed as a non-null Uri.");
streamReferenceValue.EditLink = (Uri)propertyAnnotation.Value;
break;
case ODataAnnotationNames.ODataMediaReadLink:
Debug.Assert(propertyAnnotation.Value is Uri && propertyAnnotation.Value != null, "The odata.mediaReadLink annotation should have been parsed as a non-null Uri.");
streamReferenceValue.ReadLink = (Uri)propertyAnnotation.Value;
break;
case ODataAnnotationNames.ODataMediaETag:
Debug.Assert(propertyAnnotation.Value is string && propertyAnnotation.Value != null, "The odata.mediaEtag annotation should have been parsed as a non-null string.");
streamReferenceValue.ETag = (string)propertyAnnotation.Value;
break;
case ODataAnnotationNames.ODataMediaContentType:
Debug.Assert(propertyAnnotation.Value is string && propertyAnnotation.Value != null, "The odata.mediaContentType annotation should have been parsed as a non-null string.");
streamReferenceValue.ContentType = (string)propertyAnnotation.Value;
break;
default:
throw new ODataException(ODataErrorStrings.ODataJsonLightEntryAndFeedDeserializer_UnexpectedStreamPropertyAnnotation(streamPropertyName, propertyAnnotation.Key));
}
}
}
ODataEntityMetadataBuilder builder = this.MetadataContext.GetEntityMetadataBuilderForReader(entryState, this.JsonLightInputContext.MessageReaderSettings.UseKeyAsSegment);
// Note that we set the metadata builder even when streamProperty is null, which is the case when the stream property is undeclared.
// For undeclared stream properties, we will apply conventional metadata evaluation just as declared stream properties.
streamReferenceValue.SetMetadataBuilder(builder, streamPropertyName);
return streamReferenceValue;
}
/// <summary>
/// Reads one operation for the entry being read.
/// </summary>
/// <param name="readerContext">The Json operation deserializer context.</param>
/// <param name="entryState">The state of the reader for entry to read.</param>
/// <param name="metadataReferencePropertyName">The name of the metadata reference property being read.</param>
/// <param name="insideArray">true if the operation value is inside an array, i.e. multiple targets for the operation; false otherwise.</param>
/// <remarks>
/// Pre-Condition: JsonNodeType.StartObject: first node of the operation value.
/// Post-Condition: JsonNodeType.Property: the property after the current operation being read when there is one target for the operation.
/// JsonNodeType.StartObject: the first node of the next operation value when there are multiple targets for the operation.
/// JsonNodeType.EndArray: the end-array of the operation values when there are multiple target for the operation.
/// </remarks>
private void ReadSingleOperationValue(IODataJsonOperationsDeserializerContext readerContext, IODataJsonLightReaderEntryState entryState, string metadataReferencePropertyName, bool insideArray)
{
Debug.Assert(readerContext != null, "readerContext != null");
Debug.Assert(!string.IsNullOrEmpty(metadataReferencePropertyName), "!string.IsNullOrEmpty(metadataReferencePropertyName)");
Debug.Assert(ODataJsonLightUtils.IsMetadataReferenceProperty(metadataReferencePropertyName), "ODataJsonLightReaderUtils.IsMetadataReferenceProperty(metadataReferencePropertyName)");
if (readerContext.JsonReader.NodeType != JsonNodeType.StartObject)
{
throw new ODataException(ODataErrorStrings.ODataJsonOperationsDeserializerUtils_OperationsPropertyMustHaveObjectValue(metadataReferencePropertyName, readerContext.JsonReader.NodeType));
}
// read over the start-object node of the metadata object for the operations
readerContext.JsonReader.ReadStartObject();
var operation = this.CreateODataOperationAndAddToEntry(readerContext, metadataReferencePropertyName);
// Ignore the unrecognized operation.
if (operation == null)
{
while (readerContext.JsonReader.NodeType == JsonNodeType.Property)
{
readerContext.JsonReader.ReadPropertyName();
readerContext.JsonReader.SkipValue();
}
readerContext.JsonReader.ReadEndObject();
return;
}
Debug.Assert(operation.Metadata != null, "operation.Metadata != null");
while (readerContext.JsonReader.NodeType == JsonNodeType.Property)
{
string operationPropertyName = ODataAnnotationNames.RemoveAnnotationPrefix(readerContext.JsonReader.ReadPropertyName());
switch (operationPropertyName)
{
case JsonConstants.ODataOperationTitleName:
if (operation.Title != null)
{
throw new ODataException(ODataErrorStrings.ODataJsonLightEntryAndFeedDeserializer_MultipleOptionalPropertiesInOperation(operationPropertyName, metadataReferencePropertyName));
}
string titleString = readerContext.JsonReader.ReadStringValue(JsonConstants.ODataOperationTitleName);
ODataJsonLightValidationUtils.ValidateOperationPropertyValueIsNotNull(titleString, operationPropertyName, metadataReferencePropertyName);
operation.Title = titleString;
break;
case JsonConstants.ODataOperationTargetName:
if (operation.Target != null)
{
throw new ODataException(ODataErrorStrings.ODataJsonLightEntryAndFeedDeserializer_MultipleOptionalPropertiesInOperation(operationPropertyName, metadataReferencePropertyName));
}
string targetString = readerContext.JsonReader.ReadStringValue(JsonConstants.ODataOperationTargetName);
ODataJsonLightValidationUtils.ValidateOperationPropertyValueIsNotNull(targetString, operationPropertyName, metadataReferencePropertyName);
operation.Target = readerContext.ProcessUriFromPayload(targetString);
break;
default:
// skip over all unknown properties and read the next property or
// the end of the metadata for the current propertyName
readerContext.JsonReader.SkipValue();
break;
}
}
if (operation.Target == null && insideArray)
{
throw new ODataException(ODataErrorStrings.ODataJsonLightEntryAndFeedDeserializer_OperationMissingTargetProperty(metadataReferencePropertyName));
}
// read the end-object node of the target / title pair
readerContext.JsonReader.ReadEndObject();
// Sets the metadata builder to evaluate by convention any operation property that's not on the wire.
// Note we must only set this after the operation is read from the wire since we lose the ability to tell
// what was on the wire and what is being dynamically computed.
this.SetMetadataBuilder(entryState, operation);
}
/// <summary>
/// Gets an entity metadata builder for the given entry.
/// </summary>
/// <param name="entryState">Entry state to use as reference for information needed by the builder.</param>
/// <param name="useKeyAsSegment">true if keys should go in seperate segments in auto-generated URIs, false if they should go in parentheses.
/// A null value means the user hasn't specified a preference and we should look for an annotation in the entity container, if available.</param>
/// <returns>An entity metadata builder.</returns>
public ODataEntityMetadataBuilder GetEntityMetadataBuilderForReader(IODataJsonLightReaderEntryState entryState, bool? useKeyAsSegment)
{
Debug.Assert(entryState != null, "entry != null");
// Only apply the conventional template builder on response. On a request we would only report what's on the wire.
if (entryState.MetadataBuilder == null)
{
ODataEntry entry = entryState.Entry;
if (this.isResponse)
{
ODataTypeAnnotation typeAnnotation = entry.GetAnnotation<ODataTypeAnnotation>();
Debug.Assert(typeAnnotation != null, "The JSON light reader should have already set the ODataTypeAnnotation.");
IEdmNavigationSource navigationSource = typeAnnotation.NavigationSource;
IEdmEntityType navigationSourceElementType = this.edmTypeResolver.GetElementType(navigationSource);
IODataFeedAndEntryTypeContext typeContext = ODataFeedAndEntryTypeContext.Create(/*serializationInfo*/ null, navigationSource, navigationSourceElementType, entryState.EntityType, this.model, /*throwIfMissingTypeInfo*/ true);
IODataEntryMetadataContext entryMetadataContext = ODataEntryMetadataContext.Create(entry, typeContext, /*serializationInfo*/null, (IEdmEntityType)entry.GetEdmType().Definition, this, entryState.SelectedProperties);
UrlConvention urlConvention = UrlConvention.ForUserSettingAndTypeContext(useKeyAsSegment, typeContext);
ODataConventionalUriBuilder uriBuilder = new ODataConventionalUriBuilder(this.ServiceBaseUri, urlConvention);
entryState.MetadataBuilder = new ODataConventionalEntityMetadataBuilder(entryMetadataContext, this, uriBuilder);
}
else
{
entryState.MetadataBuilder = new NoOpEntityMetadataBuilder(entry);
}
}
return entryState.MetadataBuilder;
}
