private MaterializerEntry(ODataEntry entry, DataServiceProtocolVersion maxProtocolVersion)
{
this.entry = entry;
this.entityDescriptor = new System.Data.Services.Client.EntityDescriptor(maxProtocolVersion);
SerializationTypeNameAnnotation annotation = entry.GetAnnotation<SerializationTypeNameAnnotation>();
this.entityDescriptor.ServerTypeName = (annotation != null) ? annotation.TypeName : (this.entityDescriptor.ServerTypeName = this.Entry.TypeName);
}
protected override void EndEntry(ODataEntry entry)
{
if (entry != null)
{
ProjectedPropertiesAnnotation projectedProperties = entry.GetAnnotation<ProjectedPropertiesAnnotation>();
this.jsonEntryAndFeedSerializer.WriteProperties(base.EntryEntityType, entry.Properties, false, base.DuplicatePropertyNamesChecker, projectedProperties);
this.jsonOutputContext.JsonWriter.EndObjectScope();
}
}
internal string GetEntryTypeNameForWriting(ODataEntry entry)
{
DebugUtils.CheckNoExternalCallers();
Debug.Assert(entry != null, "entry != null");
SerializationTypeNameAnnotation typeNameAnnotation = entry.GetAnnotation <SerializationTypeNameAnnotation>();
if (typeNameAnnotation != null)
{
return(typeNameAnnotation.TypeName);
}
return(entry.TypeName);
}
protected override void EndEntry(ODataEntry entry)
{
Debug.Assert(
this.ParentNavigationLink == null || !this.ParentNavigationLink.IsCollection.Value,
"We should have already verified that the IsCollection matches the actual content of the link (feed/entry).");
if (entry == null)
{
Debug.Assert(this.ParentNavigationLink != null, "When entry == null, it has to be an expanded single entry navigation.");
// this is a null expanded single entry and it is null, an empty <m:inline /> will be written.
this.CheckAndWriteParentNavigationLinkEndForInlineElement();
return;
}
IEdmEntityType entryType = this.EntryEntityType;
// Initialize the property value cache and cache the entry properties.
EntryPropertiesValueCache propertyValueCache = new EntryPropertiesValueCache(entry);
// NOTE: when writing, we assume the model has been validated already and thus pass int.MaxValue for the maxMappingCount.
ODataEntityPropertyMappingCache epmCache = this.atomOutputContext.Model.EnsureEpmCache(entryType, /*maxMappingCount*/ int.MaxValue);
// Populate the property value cache based on the EPM source tree information.
// We do this since we need to write custom EPM after the properties below and don't
// want to cache all properties just for the case that they are used in a custom EPM.
if (epmCache != null)
{
EpmWriterUtils.CacheEpmProperties(propertyValueCache, epmCache.EpmSourceTree);
}
// Get the projected properties annotation
ProjectedPropertiesAnnotation projectedProperties = entry.GetAnnotation<ProjectedPropertiesAnnotation>();
AtomEntryScope currentEntryScope = this.CurrentEntryScope;
AtomEntryMetadata entryMetadata = entry.Atom();
if (!currentEntryScope.IsElementWritten(AtomElement.Id))
{
// NOTE: We write even null id, in that case we generate an empty atom:id element.
this.atomEntryAndFeedSerializer.WriteEntryId(entry.Id);
}
Uri editLink = entry.EditLink;
if (editLink != null && !currentEntryScope.IsElementWritten(AtomElement.EditLink))
{
this.atomEntryAndFeedSerializer.WriteEntryEditLink(editLink, entryMetadata);
}
Uri readLink = entry.ReadLink;
if (readLink != null && !currentEntryScope.IsElementWritten(AtomElement.ReadLink))
{
this.atomEntryAndFeedSerializer.WriteEntryReadLink(readLink, entryMetadata);
}
// write entry metadata including syndication EPM
AtomEntryMetadata epmEntryMetadata = null;
if (epmCache != null)
{
ODataVersionChecker.CheckEntityPropertyMapping(this.atomOutputContext.Version, entryType, this.atomOutputContext.Model);
epmEntryMetadata = EpmSyndicationWriter.WriteEntryEpm(
epmCache.EpmTargetTree,
propertyValueCache,
entryType.ToTypeReference().AsEntity(),
this.atomOutputContext);
}
this.atomEntryAndFeedSerializer.WriteEntryMetadata(entryMetadata, epmEntryMetadata, this.updatedTime);
// stream properties
IEnumerable<ODataProperty> streamProperties = propertyValueCache.EntryStreamProperties;
if (streamProperties != null)
{
foreach (ODataProperty streamProperty in streamProperties)
{
this.atomEntryAndFeedSerializer.WriteStreamProperty(
streamProperty,
entryType,
this.DuplicatePropertyNamesChecker,
projectedProperties);
}
}
// association links
IEnumerable<ODataAssociationLink> associationLinks = entry.AssociationLinks;
if (associationLinks != null)
{
foreach (ODataAssociationLink associationLink in associationLinks)
{
this.atomEntryAndFeedSerializer.WriteAssociationLink(
associationLink,
entryType,
this.DuplicatePropertyNamesChecker,
projectedProperties);
}
}
// actions
IEnumerable<ODataAction> actions = entry.Actions;
if (actions != null)
{
foreach (ODataAction action in actions)
{
ValidationUtils.ValidateOperationNotNull(action, true);
this.atomEntryAndFeedSerializer.WriteOperation(action);
}
}
// functions
IEnumerable<ODataFunction> functions = entry.Functions;
if (functions != null)
{
foreach (ODataFunction function in functions)
{
ValidationUtils.ValidateOperationNotNull(function, false);
this.atomEntryAndFeedSerializer.WriteOperation(function);
}
}
// write the content
this.WriteEntryContent(
entry,
entryType,
propertyValueCache,
epmCache == null ? null : epmCache.EpmSourceTree.Root,
projectedProperties);
// write custom EPM
if (epmCache != null)
{
EpmCustomWriter.WriteEntryEpm(
this.atomOutputContext.XmlWriter,
epmCache.EpmTargetTree,
propertyValueCache,
entryType.ToTypeReference().AsEntity(),
this.atomOutputContext);
}
// </entry>
this.atomOutputContext.XmlWriter.WriteEndElement();
this.EndEntryXmlCustomization(entry);
this.CheckAndWriteParentNavigationLinkEndForInlineElement();
}
/// <summary>
/// Start writing an entry.
/// </summary>
/// <param name="entry">The entry to write.</param>
protected override void StartEntry(ODataEntry entry)
{
this.CheckAndWriteParentNavigationLinkStartForInlineElement();
Debug.Assert(
this.ParentNavigationLink == null || !this.ParentNavigationLink.IsCollection.Value,
"We should have already verified that the IsCollection matches the actual content of the link (feed/entry).");
if (entry == null)
{
Debug.Assert(this.ParentNavigationLink != null, "When entry == null, it has to be an expanded single entry navigation.");
// this is a null expanded single entry and it is null, an empty <m:inline /> will be written.
return;
}
this.StartEntryXmlCustomization(entry);
// <entry>
this.atomOutputContext.XmlWriter.WriteStartElement(AtomConstants.AtomNamespacePrefix, AtomConstants.AtomEntryElementName, AtomConstants.AtomNamespace);
if (this.IsTopLevel)
{
this.atomEntryAndFeedSerializer.WriteBaseUriAndDefaultNamespaceAttributes();
}
string etag = entry.ETag;
if (etag != null)
{
// TODO, ckerer: if this is a top-level entry also put the ETag into the headers.
ODataAtomWriterUtils.WriteETag(this.atomOutputContext.XmlWriter, etag);
}
AtomEntryScope currentEntryScope = this.CurrentEntryScope;
AtomEntryMetadata entryMetadata = entry.Atom();
// Write the id if it's available here.
// If it's not available here we will try to write it at the end of the entry again.
string entryId = entry.Id;
if (entryId != null)
{
this.atomEntryAndFeedSerializer.WriteEntryId(entryId);
currentEntryScope.SetWrittenElement(AtomElement.Id);
}
// <category term="type" scheme="odatascheme"/>
// If no type information is provided, don't include the category element for type at all
// NOTE: the validation of the type name is done by the core writer.
string typeName = entry.TypeName;
SerializationTypeNameAnnotation serializationTypeNameAnnotation = entry.GetAnnotation<SerializationTypeNameAnnotation>();
if (serializationTypeNameAnnotation != null)
{
typeName = serializationTypeNameAnnotation.TypeName;
}
this.atomEntryAndFeedSerializer.WriteEntryTypeName(typeName, entryMetadata);
// Write the edit link if it's available here.
// If it's not available here we will try to write it at the end of the entry again.
Uri editLink = entry.EditLink;
if (editLink != null)
{
this.atomEntryAndFeedSerializer.WriteEntryEditLink(editLink, entryMetadata);
currentEntryScope.SetWrittenElement(AtomElement.EditLink);
}
// Write the self link if it's available here.
// If it's not available here we will try to write it at the end of the entry again.
Uri readLink = entry.ReadLink;
if (readLink != null)
{
this.atomEntryAndFeedSerializer.WriteEntryReadLink(readLink, entryMetadata);
currentEntryScope.SetWrittenElement(AtomElement.ReadLink);
}
}
protected override void EndEntry(ODataEntry entry)
{
if (entry == null)
{
this.CheckAndWriteParentNavigationLinkEndForInlineElement();
}
else
{
IEdmEntityType entryEntityType = base.EntryEntityType;
EntryPropertiesValueCache propertyValueCache = new EntryPropertiesValueCache(entry);
ODataEntityPropertyMappingCache cache2 = this.atomOutputContext.Model.EnsureEpmCache(entryEntityType, 0x7fffffff);
if (cache2 != null)
{
EpmWriterUtils.CacheEpmProperties(propertyValueCache, cache2.EpmSourceTree);
}
ProjectedPropertiesAnnotation projectedProperties = entry.GetAnnotation<ProjectedPropertiesAnnotation>();
AtomEntryScope currentEntryScope = this.CurrentEntryScope;
AtomEntryMetadata entryMetadata = entry.Atom();
if (!currentEntryScope.IsElementWritten(AtomElement.Id))
{
this.atomEntryAndFeedSerializer.WriteEntryId(entry.Id);
}
Uri editLink = entry.EditLink;
if ((editLink != null) && !currentEntryScope.IsElementWritten(AtomElement.EditLink))
{
this.atomEntryAndFeedSerializer.WriteEntryEditLink(editLink, entryMetadata);
}
Uri readLink = entry.ReadLink;
if ((readLink != null) && !currentEntryScope.IsElementWritten(AtomElement.ReadLink))
{
this.atomEntryAndFeedSerializer.WriteEntryReadLink(readLink, entryMetadata);
}
AtomEntryMetadata epmEntryMetadata = null;
if (cache2 != null)
{
ODataVersionChecker.CheckEntityPropertyMapping(this.atomOutputContext.Version, entryEntityType, this.atomOutputContext.Model);
epmEntryMetadata = EpmSyndicationWriter.WriteEntryEpm(cache2.EpmTargetTree, propertyValueCache, entryEntityType.ToTypeReference().AsEntity(), this.atomOutputContext);
}
this.atomEntryAndFeedSerializer.WriteEntryMetadata(entryMetadata, epmEntryMetadata, this.updatedTime);
IEnumerable<ODataProperty> entryStreamProperties = propertyValueCache.EntryStreamProperties;
if (entryStreamProperties != null)
{
foreach (ODataProperty property in entryStreamProperties)
{
this.atomEntryAndFeedSerializer.WriteStreamProperty(property, entryEntityType, base.DuplicatePropertyNamesChecker, projectedProperties);
}
}
IEnumerable<ODataAssociationLink> associationLinks = entry.AssociationLinks;
if (associationLinks != null)
{
foreach (ODataAssociationLink link in associationLinks)
{
this.atomEntryAndFeedSerializer.WriteAssociationLink(link, entryEntityType, base.DuplicatePropertyNamesChecker, projectedProperties);
}
}
IEnumerable<ODataAction> actions = entry.Actions;
if (actions != null)
{
foreach (ODataAction action in actions)
{
ValidationUtils.ValidateOperationNotNull(action, true);
this.atomEntryAndFeedSerializer.WriteOperation(action);
}
}
IEnumerable<ODataFunction> functions = entry.Functions;
if (functions != null)
{
foreach (ODataFunction function in functions)
{
ValidationUtils.ValidateOperationNotNull(function, false);
this.atomEntryAndFeedSerializer.WriteOperation(function);
}
}
this.WriteEntryContent(entry, entryEntityType, propertyValueCache, (cache2 == null) ? null : cache2.EpmSourceTree.Root, projectedProperties);
if (cache2 != null)
{
EpmCustomWriter.WriteEntryEpm(this.atomOutputContext.XmlWriter, cache2.EpmTargetTree, propertyValueCache, entryEntityType.ToTypeReference().AsEntity(), this.atomOutputContext);
}
this.atomOutputContext.XmlWriter.WriteEndElement();
this.EndEntryXmlCustomization(entry);
this.CheckAndWriteParentNavigationLinkEndForInlineElement();
}
}
protected override void StartEntry(ODataEntry entry)
{
this.CheckAndWriteParentNavigationLinkStartForInlineElement();
if (entry != null)
{
this.StartEntryXmlCustomization(entry);
this.atomOutputContext.XmlWriter.WriteStartElement("", "entry", "http://www.w3.org/2005/Atom");
if (base.IsTopLevel)
{
this.atomEntryAndFeedSerializer.WriteBaseUriAndDefaultNamespaceAttributes();
}
string eTag = entry.ETag;
if (eTag != null)
{
ODataAtomWriterUtils.WriteETag(this.atomOutputContext.XmlWriter, eTag);
}
AtomEntryScope currentEntryScope = this.CurrentEntryScope;
AtomEntryMetadata entryMetadata = entry.Atom();
string id = entry.Id;
if (id != null)
{
this.atomEntryAndFeedSerializer.WriteEntryId(id);
currentEntryScope.SetWrittenElement(AtomElement.Id);
}
string typeName = entry.TypeName;
SerializationTypeNameAnnotation annotation = entry.GetAnnotation<SerializationTypeNameAnnotation>();
if (annotation != null)
{
typeName = annotation.TypeName;
}
this.atomEntryAndFeedSerializer.WriteEntryTypeName(typeName, entryMetadata);
Uri editLink = entry.EditLink;
if (editLink != null)
{
this.atomEntryAndFeedSerializer.WriteEntryEditLink(editLink, entryMetadata);
currentEntryScope.SetWrittenElement(AtomElement.EditLink);
}
Uri readLink = entry.ReadLink;
if (readLink != null)
{
this.atomEntryAndFeedSerializer.WriteEntryReadLink(readLink, entryMetadata);
currentEntryScope.SetWrittenElement(AtomElement.ReadLink);
}
}
}
public static MaterializerEntry GetEntry(ODataEntry entry)
{
return entry.GetAnnotation<MaterializerEntry>();
}
private static void EndEntryXmlCustomizer(ODataEntry entry, XmlWriter entryWriter, XmlWriter parentWriter)
{
WritingEntityInfo annotation = entry.GetAnnotation<WritingEntityInfo>();
entryWriter.Close();
annotation.RequestInfo.FireWritingEntityEvent(annotation.Entity, annotation.EntryPayload.Root, null);
annotation.EntryPayload.Root.WriteTo(parentWriter);
}
public void AddTypeNameAnnotationAsNeeded_AddsAnnotation_IfTypeOfPathDoesNotMatchEntryType()
{
// Arrange
string expectedTypeName = "TypeName";
ODataEntry entry = new ODataEntry
{
TypeName = expectedTypeName
};
// Act
ODataEntityTypeSerializer.AddTypeNameAnnotationAsNeeded(entry, _customerType.EntityDefinition(), ODataMetadataLevel.MinimalMetadata);
// Assert
SerializationTypeNameAnnotation annotation = entry.GetAnnotation<SerializationTypeNameAnnotation>();
Assert.NotNull(annotation); // Guard
Assert.Equal(expectedTypeName, annotation.TypeName);
}
[Fact] // Issue 984: Redundant type name serialization in OData JSON light minimal metadata mode
public void AddTypeNameAnnotationAsNeeded_AddsAnnotationWithNullValue_IfTypeOfPathMatchesEntryType()
{
// Arrange
CustomersModelWithInheritance model = new CustomersModelWithInheritance();
ODataEntry entry = new ODataEntry
{
TypeName = model.SpecialCustomer.FullName()
};
// Act
ODataEntityTypeSerializer.AddTypeNameAnnotationAsNeeded(entry, model.SpecialCustomer, ODataMetadataLevel.MinimalMetadata);
// Assert
SerializationTypeNameAnnotation annotation = entry.GetAnnotation<SerializationTypeNameAnnotation>();
Assert.NotNull(annotation); // Guard
Assert.Null(annotation.TypeName);
}
/// <summary>
/// Finish writing an entry.
/// </summary>
/// <param name="entry">The entry to write.</param>
protected override void EndEntry(ODataEntry entry)
{
if (entry == null)
{
Debug.Assert(
this.ParentNavigationLink != null && !this.ParentNavigationLink.IsCollection.Value,
"when entry == null, it has to be and expanded single entry navigation");
// this is a null expanded single entry and it is null, JSON null should be written as value in StartEntry()
return;
}
// Get the projected properties
ProjectedPropertiesAnnotation projectedProperties = entry.GetAnnotation<ProjectedPropertiesAnnotation>();
// Write the properties
this.jsonEntryAndFeedSerializer.AssertRecursionDepthIsZero();
this.jsonEntryAndFeedSerializer.WriteProperties(
this.EntryEntityType,
entry.Properties,
false /* isComplexValue */,
this.DuplicatePropertyNamesChecker,
projectedProperties);
this.jsonEntryAndFeedSerializer.AssertRecursionDepthIsZero();
// Close the object scope
this.jsonOutputContext.JsonWriter.EndObjectScope();
}
/// <summary>
/// Start writing an entry.
/// </summary>
/// <param name="entry">The entry to write.</param>
protected override void StartEntry(ODataEntry entry)
{
if (entry == null)
{
Debug.Assert(
this.ParentNavigationLink != null && !this.ParentNavigationLink.IsCollection.Value,
"when entry == null, it has to be and expanded single entry navigation");
// this is a null expanded single entry and it is null, so write a JSON null as value.
this.jsonOutputContext.JsonWriter.WriteValue(null);
return;
}
// Write just the object start, nothing else, since we might not have complete information yet
this.jsonOutputContext.JsonWriter.StartObjectScope();
// Get the projected properties
ProjectedPropertiesAnnotation projectedProperties = entry.GetAnnotation<ProjectedPropertiesAnnotation>();
// Write the metadata
this.jsonEntryAndFeedSerializer.WriteEntryMetadata(entry, projectedProperties, this.EntryEntityType, this.DuplicatePropertyNamesChecker);
}
protected override void StartEntry(ODataEntry entry)
{
if (entry == null)
{
this.jsonOutputContext.JsonWriter.WriteValue((string) null);
}
else
{
this.jsonOutputContext.JsonWriter.StartObjectScope();
ProjectedPropertiesAnnotation projectedProperties = entry.GetAnnotation<ProjectedPropertiesAnnotation>();
this.jsonEntryAndFeedSerializer.WriteEntryMetadata(entry, projectedProperties, base.EntryEntityType, base.DuplicatePropertyNamesChecker);
}
}
public void AddTypeNameAnnotationAsNeeded_DoesNotAddAnnotation_InDefaultMetadataMode()
{
// Arrange
ODataEntry entry = new ODataEntry();
// Act
ODataEntityTypeSerializer.AddTypeNameAnnotationAsNeeded(entry, null, ODataMetadataLevel.Default);
// Assert
Assert.Null(entry.GetAnnotation<SerializationTypeNameAnnotation>());
}
private static XmlWriter StartEntryXmlCustomizer(ODataEntry entry, XmlWriter entryWriter)
{
return entry.GetAnnotation<WritingEntityInfo>().EntryPayload.CreateWriter();
}
public void AddTypeNameAnnotationAsNeeded_AddsAnnotation_InJsonLightMetadataMode()
{
// Arrange
string expectedTypeName = "TypeName";
ODataEntry entry = new ODataEntry
{
TypeName = expectedTypeName
};
// Act
ODataEntityTypeSerializer.AddTypeNameAnnotationAsNeeded(entry, null, ODataMetadataLevel.MinimalMetadata);
// Assert
SerializationTypeNameAnnotation annotation = entry.GetAnnotation<SerializationTypeNameAnnotation>();
Assert.NotNull(annotation); // Guard
Assert.Equal(expectedTypeName, annotation.TypeName);
}
internal void WriteEntryMetadata(ODataEntry entry, ProjectedPropertiesAnnotation projectedProperties, IEdmEntityType entryEntityType, DuplicatePropertyNamesChecker duplicatePropertyNamesChecker)
{
base.JsonWriter.WriteName("__metadata");
base.JsonWriter.StartObjectScope();
string id = entry.Id;
if (id != null)
{
base.JsonWriter.WriteName("id");
base.JsonWriter.WriteValue(id);
}
Uri uri = entry.EditLink ?? entry.ReadLink;
if (uri != null)
{
base.JsonWriter.WriteName("uri");
base.JsonWriter.WriteValue(base.UriToAbsoluteUriString(uri));
}
string eTag = entry.ETag;
if (eTag != null)
{
base.WriteETag("etag", eTag);
}
string typeName = entry.TypeName;
SerializationTypeNameAnnotation annotation = entry.GetAnnotation<SerializationTypeNameAnnotation>();
if (annotation != null)
{
typeName = annotation.TypeName;
}
if (typeName != null)
{
base.JsonWriter.WriteName("type");
base.JsonWriter.WriteValue(typeName);
}
ODataStreamReferenceValue mediaResource = entry.MediaResource;
if (mediaResource != null)
{
WriterValidationUtils.ValidateStreamReferenceValue(mediaResource, true);
base.WriteStreamReferenceValueContent(mediaResource);
}
IEnumerable<ODataAction> actions = entry.Actions;
if (actions != null)
{
this.WriteOperations(actions.Cast<ODataOperation>(), true);
}
IEnumerable<ODataFunction> functions = entry.Functions;
if (functions != null)
{
this.WriteOperations(functions.Cast<ODataOperation>(), false);
}
IEnumerable<ODataAssociationLink> associationLinks = entry.AssociationLinks;
if (associationLinks != null)
{
bool flag = true;
foreach (ODataAssociationLink link in associationLinks)
{
ValidationUtils.ValidateAssociationLinkNotNull(link);
if (!projectedProperties.ShouldSkipProperty(link.Name))
{
if (flag)
{
base.JsonWriter.WriteName("properties");
base.JsonWriter.StartObjectScope();
flag = false;
}
base.ValidateAssociationLink(link, entryEntityType);
this.WriteAssociationLink(link, duplicatePropertyNamesChecker);
}
}
if (!flag)
{
base.JsonWriter.EndObjectScope();
}
}
base.JsonWriter.EndObjectScope();
}
