/// <summary>
/// Caches and returns the properties for the specified complex value.
/// </summary>
/// <param name="complexValue">The complex value to cache the properties for.</param>
/// <returns>The cached properties enumeration for the complex value.</returns>
/// <remarks>This method assumes that the complex value's properties are not cached yet.</remarks>
internal IEnumerable<ODataProperty> CacheComplexValueProperties(ODataComplexValue complexValue)
{
DebugUtils.CheckNoExternalCallers();
Debug.Assert(
this.epmValuesCache == null || complexValue == null || !this.epmValuesCache.ContainsKey(complexValue),
"Complex value must not be cached.");
if (complexValue == null)
{
return null;
}
IEnumerable<ODataProperty> properties = complexValue.Properties;
List<ODataProperty> cachedProperties = null;
if (properties != null)
{
cachedProperties = new List<ODataProperty>(properties);
}
if (this.epmValuesCache == null)
{
this.epmValuesCache = new Dictionary<object, object>(ReferenceEqualityComparer<object>.Instance);
}
this.epmValuesCache.Add(complexValue, cachedProperties);
return cachedProperties;
}
public ODataJsonLightInheritComplexCollectionWriterTests()
{
collectionStartWithoutSerializationInfo = new ODataCollectionStart();
collectionStartWithSerializationInfo = new ODataCollectionStart();
collectionStartWithSerializationInfo.SetSerializationInfo(new ODataCollectionStartSerializationInfo { CollectionTypeName = "Collection(ns.Address)" });
address = new ODataComplexValue { Properties = new[]
{
new ODataProperty { Name = "Street", Value = "1 Microsoft Way" },
new ODataProperty { Name = "Zipcode", Value = 98052 },
new ODataProperty { Name = "State", Value = new ODataEnumValue("WA", "ns.StateEnum") },
new ODataProperty { Name = "City", Value = "Shanghai" }
}, TypeName = "TestNamespace.DerivedAddress" };
items = new[] { address };
EdmComplexType addressType = new EdmComplexType("ns", "Address");
addressType.AddProperty(new EdmStructuralProperty(addressType, "Street", EdmCoreModel.Instance.GetString(isNullable: true)));
addressType.AddProperty(new EdmStructuralProperty(addressType, "Zipcode", EdmCoreModel.Instance.GetInt32(isNullable: true)));
var stateEnumType = new EdmEnumType("ns", "StateEnum", isFlags: true);
stateEnumType.AddMember("IL", new EdmIntegerConstant(1));
stateEnumType.AddMember("WA", new EdmIntegerConstant(2));
addressType.AddProperty(new EdmStructuralProperty(addressType, "State", new EdmEnumTypeReference(stateEnumType, true)));
EdmComplexType derivedAddressType = new EdmComplexType("ns", "DerivedAddress", addressType, false);
derivedAddressType.AddProperty(new EdmStructuralProperty(derivedAddressType, "City", EdmCoreModel.Instance.GetString(isNullable: true)));
addressTypeReference = new EdmComplexTypeReference(addressType, isNullable: false);
derivedAddressTypeReference = new EdmComplexTypeReference(derivedAddressType, isNullable: false);
}
public void MultipleTypeCustomInstanceAnnotationsOnErrorShouldRoundtrip()
{
var originalInt = new KeyValuePair<string, ODataValue>("int.error", new ODataPrimitiveValue(1));
var originalDouble = new KeyValuePair<string, ODataValue>("double.error", new ODataPrimitiveValue(double.NaN));
DateTimeOffset dateTimeOffset = new DateTimeOffset(2012, 10, 10, 12, 12, 59, new TimeSpan());
var originalDateTimeOffset = new KeyValuePair<string, ODataValue>("DateTimeOffset.error", new ODataPrimitiveValue(dateTimeOffset));
Date date = new Date(2014, 12, 12);
var originalDate = new KeyValuePair<string, ODataValue>("Date.error", new ODataPrimitiveValue(date));
TimeOfDay time = new TimeOfDay(10, 12, 3, 9);
var originaltime = new KeyValuePair<string, ODataValue>("TimeOfDay.error", new ODataPrimitiveValue(time));
TimeSpan timeSpan = new TimeSpan(12345);
var originalTimeSpan = new KeyValuePair<string, ODataValue>("TimeSpan.error", new ODataPrimitiveValue(timeSpan));
GeographyPoint geographyPoint = GeographyPoint.Create(32.0, -100.0);
var originalGeography = new KeyValuePair<string, ODataValue>("Geography.error", new ODataPrimitiveValue(geographyPoint));
var originalNull = new KeyValuePair<string, ODataValue>("null.error", new ODataNullValue());
var complexValue = new ODataComplexValue
{
TypeName = "ns.ErrorDetails",
Properties = new[] { new ODataProperty { Name = "ErrorDetailName", Value = "inner property value" } }
};
var originalComplex = new KeyValuePair<string, ODataValue>("sample.error", complexValue);
var error = this.WriteThenReadErrorWithInstanceAnnotation(originalInt, originalDouble, originalDate, originalDateTimeOffset, originaltime, originalTimeSpan, originalGeography, originalNull, originalComplex);
var annotation = RunBasicVerificationAndGetAnnotationValue("int.error", error);
annotation.Should().BeOfType<ODataPrimitiveValue>();
annotation.As<ODataPrimitiveValue>().Value.Should().Be(1);
annotation = RunBasicVerificationAndGetAnnotationValue("double.error", error);
annotation.Should().BeOfType<ODataPrimitiveValue>();
annotation.As<ODataPrimitiveValue>().Value.Should().Be(double.NaN);
annotation = RunBasicVerificationAndGetAnnotationValue("Date.error", error);
annotation.Should().BeOfType<ODataPrimitiveValue>();
annotation.As<ODataPrimitiveValue>().Value.Should().Be(date);
annotation = RunBasicVerificationAndGetAnnotationValue("DateTimeOffset.error", error);
annotation.Should().BeOfType<ODataPrimitiveValue>();
annotation.As<ODataPrimitiveValue>().Value.Should().Be(dateTimeOffset);
annotation = RunBasicVerificationAndGetAnnotationValue("TimeOfDay.error", error);
annotation.Should().BeOfType<ODataPrimitiveValue>();
annotation.As<ODataPrimitiveValue>().Value.Should().Be(time);
annotation = RunBasicVerificationAndGetAnnotationValue("TimeSpan.error", error);
annotation.Should().BeOfType<ODataPrimitiveValue>();
annotation.As<ODataPrimitiveValue>().Value.Should().Be(timeSpan);
annotation = RunBasicVerificationAndGetAnnotationValue("Geography.error", error);
annotation.Should().BeOfType<ODataPrimitiveValue>();
annotation.As<ODataPrimitiveValue>().Value.Should().Be(geographyPoint);
annotation = RunBasicVerificationAndGetAnnotationValue("null.error", error);
annotation.Should().BeOfType<ODataNullValue>();
annotation = RunBasicVerificationAndGetAnnotationValue("sample.error", error);
annotation.Should().BeOfType<ODataComplexValue>();
annotation.As<ODataComplexValue>().Properties.First().Value.Should().Be("inner property value");
}
/// <summary>
/// Creates a new Edm structured value from an OData complex value.
/// </summary>
/// <param name="complexValue">The <see cref="ODataComplexValue"/> to create the structured value for.</param>
internal ODataEdmStructuredValue(ODataComplexValue complexValue)
: base(complexValue.GetEdmType())
{
Debug.Assert(complexValue != null, "complexValue != null");
this.properties = complexValue.Properties;
this.structuredType = this.Type == null ? null : this.Type.AsStructured();
}
public void ComplexTypeRoundtripAtomTest()
{
var age = new ODataProperty() { Name = "Age", Value = (Int16)18 };
var email = new ODataProperty() { Name = "Email", Value = "*****@*****.**" };
var tel = new ODataProperty() { Name = "Tel", Value = "0123456789" };
var id = new ODataProperty() { Name = "ID", Value = Guid.Empty };
ODataComplexValue complexValue = new ODataComplexValue() { TypeName = "NS.PersonalInfo", Properties = new[] { age, email, tel, id } };
this.VerifyComplexTypeRoundtrip(complexValue, "NS.PersonalInfo");
}
public void ComplexTypeCollectionRoundtripAtomTest()
{
ODataComplexValue subject0 = new ODataComplexValue() { TypeName = "NS.Subject", Properties = new[] { new ODataProperty() { Name = "Name", Value = "English" }, new ODataProperty() { Name = "Score", Value = (Int16)98 } } };
ODataComplexValue subject1 = new ODataComplexValue() { TypeName = "NS.Subject", Properties = new[] { new ODataProperty() { Name = "Name", Value = "Math" }, new ODataProperty() { Name = "Score", Value = (Int16)90 } } };
ODataCollectionValue complexCollectionValue = new ODataCollectionValue { TypeName = "Collection(NS.Subject)", Items = new[] { subject0, subject1 } };
ODataFeedAndEntrySerializationInfo info = new ODataFeedAndEntrySerializationInfo() {
NavigationSourceEntityTypeName = subject0.TypeName,
NavigationSourceName = "Subjects",
ExpectedTypeName = subject0.TypeName
};
this.VerifyTypeCollectionRoundtrip(complexCollectionValue, "Subjects", info);
}
/// <summary>
/// Returns the properties for the specified complex value.
/// </summary>
/// <param name="epmValueCache">The EPM value cache to use (can be null).</param>
/// <param name="complexValue">The complex value to get the properties for.</param>
/// <param name="writingContent">If we're writing content of an entry or not.</param>
/// <returns>The properties enumeration for the complex value.</returns>
internal static IEnumerable<ODataProperty> GetComplexValueProperties(
EpmValueCache epmValueCache,
ODataComplexValue complexValue,
bool writingContent)
{
DebugUtils.CheckNoExternalCallers();
Debug.Assert(complexValue != null, "complexValue != null");
Debug.Assert(writingContent || epmValueCache != null, "If we're not writing content, then the EPM value cache must exist.");
if (epmValueCache == null)
{
return complexValue.Properties;
}
else
{
return epmValueCache.GetComplexValueProperties(complexValue, writingContent);
}
}
public void WriteEntryAndComplex()
{
Action<ODataJsonLightOutputContext> test = outputContext =>
{
var entry = new ODataEntry();
var complex = new ODataComplexValue() {Properties = new List<ODataProperty>() {new ODataProperty() {Name = "Name", Value = "ComplexName"}}};
entry.Properties = new List<ODataProperty>() {new ODataProperty() {Name = "ID", Value = 1}, new ODataProperty() {Name = "complexProperty", Value = complex}};
var parameterWriter = new ODataJsonLightParameterWriter(outputContext, operation: null);
parameterWriter.WriteStart();
var entryWriter = parameterWriter.CreateEntryWriter("entry");
entryWriter.WriteStart(entry);
entryWriter.WriteEnd();
parameterWriter.WriteValue("complex", complex);
parameterWriter.WriteEnd();
parameterWriter.Flush();
};
WriteAndValidate(test, "{\"entry\":{\"ID\":1,\"complexProperty\":{\"Name\":\"ComplexName\"}},\"complex\":{\"Name\":\"ComplexName\"}}", writingResponse: false);
}
/// <summary>
/// Reads a property value starting on a complex value.
/// </summary>
/// <param name="complexValue">The complex value to start with.</param>
/// <param name="complexPropertySegment">The EPM source path segment which points to the <paramref name="complexValue"/>.</param>
/// <param name="epmValueCache">The EPM value cache to use.</param>
/// <param name="sourceSegmentIndex">The index in the property value path to start with.</param>
/// <param name="resourceType">The resource type of the complex value.</param>
/// <param name="metadata">The metadata provider to use.</param>
/// <param name="nullOnParentProperty">true if the value of the property is null because one of its parent properties was null, in this case
/// the return value of the method is always null. false if the value of the property is the actual property value which may or may not be null.</param>
/// <returns>The value of the property (may be null), or null if the property itself was not found due to one of its parent properties being null.</returns>
private object ReadComplexPropertyValue(
ODataComplexValue complexValue,
EpmSourcePathSegment complexPropertySegment,
EpmValueCache epmValueCache,
int sourceSegmentIndex,
ResourceType resourceType,
DataServiceMetadataProviderWrapper metadata,
out bool nullOnParentProperty)
{
Debug.Assert(this.propertyValuePath != null, "The propertyValuePath should have been initialized by now.");
Debug.Assert(this.propertyValuePath.Length > sourceSegmentIndex, "The propertyValuePath must be at least as long as the source segment index.");
Debug.Assert(epmValueCache != null, "epmValueCache != null");
Debug.Assert(sourceSegmentIndex >= 0, "sourceSegmentIndex >= 0");
Debug.Assert(resourceType != null, "resourceType != null");
if (complexValue == null)
{
nullOnParentProperty = true;
return null;
}
return this.ReadPropertyValue(
EpmValueCache.GetComplexValueProperties(epmValueCache, complexPropertySegment, complexValue, false),
sourceSegmentIndex,
resourceType,
metadata,
epmValueCache,
out nullOnParentProperty);
}
public void SerializeTopLevelPropertyOfComplexTypeShouldWork()
{
EdmModel model = new EdmModel();
EdmComplexType complexType = new EdmComplexType("ns", "complex");
complexType.AddProperty(new EdmStructuralProperty(complexType, "propertyName1", EdmCoreModel.Instance.GetInt32(isNullable: false)));
complexType.AddProperty(new EdmStructuralProperty(complexType, "propertyName2", EdmCoreModel.Instance.GetString(isNullable: false)));
model.AddElement(complexType);
EdmComplexTypeReference complexReference = new EdmComplexTypeReference(complexType, isNullable: false);
EdmEntityType entityType = new EdmEntityType("ns", "entityType", baseType: null, isAbstract: false, isOpen: false);
entityType.AddStructuralProperty("complexPropertyName", complexReference);
model.AddElement(entityType);
ODataComplexValue complexValue = new ODataComplexValue { Properties = new[] { new ODataProperty { Name = "propertyName1", Value = 1 }, new ODataProperty {Name = "propertyName2", Value = "stringValue"} }, TypeName = "ns.complex" };
ODataProperty complexProperty = new ODataProperty { Name = "complexPropertyName", Value = complexValue };
string val = SerializeProperty(model, complexProperty);
val.Should().Be("<?xml version=\"1.0\" encoding=\"utf-8\"?><m:value xmlns:d=\"http://docs.oasis-open.org/odata/ns/data\" xmlns:georss=\"http://www.georss.org/georss\" xmlns:gml=\"http://www.opengis.net/gml\" m:context=\"http://odata.org/$metadata#ns.complex\" m:type=\"#ns.complex\" xmlns:m=\"http://docs.oasis-open.org/odata/ns/metadata\"><d:propertyName1 m:type=\"Int32\">1</d:propertyName1><d:propertyName2>stringValue</d:propertyName2></m:value>");
}
/// <summary>
/// Writes out the value of a collection property.
/// </summary>
/// <param name="collectionValue">The collection value to write.</param>
/// <param name="metadataTypeReference">The metadata type reference for the collection.</param>
/// <param name="isOpenPropertyType">true if the type name belongs to an open property.</param>
/// <remarks>The current recursion depth is measured by the number of complex and collection values between
/// this one and the top-level payload, not including this one.</remarks>
internal void WriteCollectionValue(
ODataCollectionValue collectionValue,
IEdmTypeReference metadataTypeReference,
bool isOpenPropertyType)
{
DebugUtils.CheckNoExternalCallers();
Debug.Assert(collectionValue != null, "collectionValue != null");
this.IncreaseRecursionDepth();
// Start the object scope which will represent the entire CollectionValue instance
this.JsonWriter.StartObjectScope();
// resolve the type name to the type; if no type name is specified we will use the
// type inferred from metadata
IEdmCollectionTypeReference collectionTypeReference = (IEdmCollectionTypeReference)TypeNameOracle.ResolveAndValidateTypeNameForValue(this.Model, metadataTypeReference, collectionValue, isOpenPropertyType);
// "__metadata": { "type": "typename" }
// If the CollectionValue has type information write out the metadata and the type in it.
string collectionItemTypeName;
string typeName = this.VerboseJsonOutputContext.TypeNameOracle.GetValueTypeNameForWriting(collectionValue, collectionTypeReference, collectionValue.GetAnnotation <SerializationTypeNameAnnotation>(), /*collectionValidator*/ null, out collectionItemTypeName);
if (typeName != null)
{
ODataJsonWriterUtils.WriteMetadataWithTypeName(this.JsonWriter, typeName);
}
// "results": [
// This represents the array of items in the CollectionValue
this.JsonWriter.WriteDataArrayName();
this.JsonWriter.StartArrayScope();
// Iterate through the CollectionValue items and write them out (treat null Items as an empty enumeration)
IEnumerable items = collectionValue.Items;
if (items != null)
{
IEdmTypeReference expectedItemTypeReference = collectionTypeReference == null ? null : collectionTypeReference.ElementType();
CollectionWithoutExpectedTypeValidator collectionValidator = new CollectionWithoutExpectedTypeValidator(collectionItemTypeName);
DuplicatePropertyNamesChecker duplicatePropertyNamesChecker = null;
foreach (object item in items)
{
ValidationUtils.ValidateCollectionItem(item, false /* isStreamable */);
ODataComplexValue itemAsComplexValue = item as ODataComplexValue;
if (itemAsComplexValue != null)
{
if (duplicatePropertyNamesChecker == null)
{
duplicatePropertyNamesChecker = this.CreateDuplicatePropertyNamesChecker();
}
this.WriteComplexValue(
itemAsComplexValue,
expectedItemTypeReference,
false,
duplicatePropertyNamesChecker,
collectionValidator);
duplicatePropertyNamesChecker.Clear();
}
else
{
Debug.Assert(!(item is ODataCollectionValue), "!(item is ODataCollectionValue)");
Debug.Assert(!(item is ODataStreamReferenceValue), "!(item is ODataStreamReferenceValue)");
this.WritePrimitiveValue(item, collectionValidator, expectedItemTypeReference);
}
}
}
// End the array scope which holds the items
this.JsonWriter.EndArrayScope();
// End the object scope which holds the entire collection
this.JsonWriter.EndObjectScope();
this.DecreaseRecursionDepth();
}
public void WriteComplexValue(ODataComplexValue complexValue, IEdmTypeReference metadataTypeReference, bool isTopLevel, bool isOpenPropertyType, DuplicatePropertyNamesChecker duplicatePropertyNamesChecker)
{
this.WriteComplexVerifier.Should().NotBeNull("WriteComplexValue was called.");
this.WriteComplexVerifier(complexValue, metadataTypeReference, isTopLevel, isOpenPropertyType, duplicatePropertyNamesChecker);
}
private void WriteProperty(
ODataProperty property,
IEdmStructuredType owningType,
bool isTopLevel,
bool allowStreamProperty,
DuplicatePropertyNamesChecker duplicatePropertyNamesChecker,
ProjectedPropertiesAnnotation projectedProperties)
{
WriterValidationUtils.ValidatePropertyNotNull(property);
string propertyName = property.Name;
if (projectedProperties.ShouldSkipProperty(propertyName))
{
return;
}
WriterValidationUtils.ValidatePropertyName(propertyName, bypassValidation);
duplicatePropertyNamesChecker.CheckForDuplicatePropertyNames(property);
if (property.InstanceAnnotations.Any())
{
if (isTopLevel)
{
this.InstanceAnnotationWriter.WriteInstanceAnnotations(property.InstanceAnnotations);
}
else
{
this.InstanceAnnotationWriter.WriteInstanceAnnotations(property.InstanceAnnotations, propertyName);
}
}
IEdmProperty edmProperty = WriterValidationUtils.ValidatePropertyDefined(
propertyName,
owningType,
!this.bypassValidation);
IEdmTypeReference propertyTypeReference = edmProperty == null ? null : edmProperty.Type;
ODataValue value = property.ODataValue;
ODataStreamReferenceValue streamReferenceValue = value as ODataStreamReferenceValue;
if (streamReferenceValue != null)
{
if (!allowStreamProperty)
{
throw new ODataException(ODataErrorStrings.ODataWriter_StreamPropertiesMustBePropertiesOfODataEntry(propertyName));
}
Debug.Assert(owningType == null || owningType.IsODataEntityTypeKind(), "The metadata should not allow named stream properties to be defined on a non-entity type.");
Debug.Assert(!isTopLevel, "Stream properties are not allowed at the top level.");
WriterValidationUtils.ValidateStreamReferenceProperty(property, edmProperty, this.WritingResponse, this.bypassValidation);
this.WriteStreamReferenceProperty(propertyName, streamReferenceValue);
return;
}
string wirePropertyName = isTopLevel ? JsonLightConstants.ODataValuePropertyName : propertyName;
if (value is ODataNullValue || value == null)
{
WriterValidationUtils.ValidateNullPropertyValue(propertyTypeReference, propertyName, this.MessageWriterSettings.WriterBehavior, this.Model, this.bypassValidation);
if (isTopLevel)
{
// Write the special null marker for top-level null properties.
this.ODataAnnotationWriter.WriteInstanceAnnotationName(ODataAnnotationNames.ODataNull);
this.JsonWriter.WriteValue(true);
}
else
{
this.JsonWriter.WriteName(wirePropertyName);
this.JsonLightValueSerializer.WriteNullValue();
}
return;
}
bool isOpenPropertyType = this.IsOpenProperty(property, owningType, edmProperty);
if (isOpenPropertyType && this.JsonLightOutputContext.MessageWriterSettings.EnableFullValidation)
{
ValidationUtils.ValidateOpenPropertyValue(propertyName, value);
}
ODataComplexValue complexValue = value as ODataComplexValue;
if (complexValue != null)
{
if (!isTopLevel)
{
this.JsonWriter.WriteName(wirePropertyName);
}
this.JsonLightValueSerializer.WriteComplexValue(complexValue, propertyTypeReference, isTopLevel, isOpenPropertyType, this.CreateDuplicatePropertyNamesChecker());
return;
}
IEdmTypeReference typeFromValue = TypeNameOracle.ResolveAndValidateTypeNameForValue(this.Model, propertyTypeReference, value, isOpenPropertyType);
ODataEnumValue enumValue = value as ODataEnumValue;
if (enumValue != null)
{
// This is a work around, needTypeOnWire always = true for client side:
// ClientEdmModel's reflection can't know a property is open type even if it is, so here
// make client side always write 'odata.type' for enum.
bool needTypeOnWire = string.Equals(this.JsonLightOutputContext.Model.GetType().Name, "ClientEdmModel", StringComparison.OrdinalIgnoreCase);
string typeNameToWrite = this.JsonLightOutputContext.TypeNameOracle.GetValueTypeNameForWriting(
enumValue, propertyTypeReference, typeFromValue, needTypeOnWire ? true /* leverage this flag to write 'odata.type' */ : isOpenPropertyType);
this.WritePropertyTypeName(wirePropertyName, typeNameToWrite, isTopLevel);
this.JsonWriter.WriteName(wirePropertyName);
this.JsonLightValueSerializer.WriteEnumValue(enumValue, propertyTypeReference);
return;
}
ODataCollectionValue collectionValue = value as ODataCollectionValue;
if (collectionValue != null)
{
string collectionTypeNameToWrite = this.JsonLightOutputContext.TypeNameOracle.GetValueTypeNameForWriting(collectionValue, propertyTypeReference, typeFromValue, isOpenPropertyType);
this.WritePropertyTypeName(wirePropertyName, collectionTypeNameToWrite, isTopLevel);
this.JsonWriter.WriteName(wirePropertyName);
// passing false for 'isTopLevel' because the outer wrapping object has already been written.
this.JsonLightValueSerializer.WriteCollectionValue(collectionValue, propertyTypeReference, isTopLevel, false /*isInUri*/, isOpenPropertyType);
}
else
{
ODataPrimitiveValue primitiveValue = value as ODataPrimitiveValue;
Debug.Assert(primitiveValue != null, "primitiveValue != null");
string typeNameToWrite = this.JsonLightOutputContext.TypeNameOracle.GetValueTypeNameForWriting(primitiveValue, propertyTypeReference, typeFromValue, isOpenPropertyType);
this.WritePropertyTypeName(wirePropertyName, typeNameToWrite, isTopLevel);
this.JsonWriter.WriteName(wirePropertyName);
this.JsonLightValueSerializer.WritePrimitiveValue(primitiveValue.Value, propertyTypeReference);
}
}
/// <summary>
/// Applies the collection data values to a collection instance.
/// </summary>
/// <param name="items">The items.</param>
/// <param name="wireTypeName">Name of the wire type.</param>
/// <param name="collectionInstance">The collection instance.</param>
/// <param name="collectionItemType">Type of the collection item.</param>
/// <param name="addValueToBackingICollectionInstance">The add value to backing I collection instance.</param>
/// <param name="isElementNullable">If element type is nullable.</param>
internal void ApplyCollectionDataValues(
IEnumerable items,
string wireTypeName,
object collectionInstance,
Type collectionItemType,
Action <object, object> addValueToBackingICollectionInstance,
bool isElementNullable)
{
Debug.Assert(collectionInstance != null, "collectionInstance != null");
Debug.Assert(WebUtil.IsCLRTypeCollection(collectionInstance.GetType(), this.materializerContext.Model), "collectionInstance must be a CollectionValue");
Debug.Assert(
ClientTypeUtil.GetImplementationType(collectionInstance.GetType(), typeof(ICollection <>)).GetGenericArguments()[0] == collectionItemType,
"collectionItemType has to match the collectionInstance generic type.");
Debug.Assert(!ClientTypeUtil.TypeIsEntity(collectionItemType, this.materializerContext.Model), "CollectionValues cannot contain entities");
Debug.Assert(addValueToBackingICollectionInstance != null, "AddValueToBackingICollectionInstance != null");
// is the Collection not empty ?
if (items != null)
{
bool isCollectionItemTypePrimitive = PrimitiveType.IsKnownNullableType(collectionItemType);
foreach (object item in items)
{
if (!isElementNullable && item == null)
{
throw DSClient.Error.InvalidOperation(DSClient.Strings.Collection_NullCollectionItemsNotSupported);
}
ODataComplexValue complexValue = item as ODataComplexValue;
ODataEnumValue enumVal = null;
// Is it a Collection of primitive types?
if (isCollectionItemTypePrimitive)
{
// verify that the Collection does not contain complex type items
if (complexValue != null || item is ODataCollectionValue)
{
throw DSClient.Error.InvalidOperation(DSClient.Strings.Collection_ComplexTypesInCollectionOfPrimitiveTypesNotAllowed);
}
object materializedValue = this.primitiveValueMaterializationPolicy.MaterializePrimitiveDataValueCollectionElement(collectionItemType, wireTypeName, item);
addValueToBackingICollectionInstance(collectionInstance, materializedValue);
}
else if ((enumVal = item as ODataEnumValue) != null)
{
// TODO: use EnumValueMaterializationPolicy.MaterializeEnumDataValueCollectionElement() here
object tmpValue = EnumValueMaterializationPolicy.MaterializeODataEnumValue(collectionItemType, enumVal);
addValueToBackingICollectionInstance(collectionInstance, tmpValue);
}
else
{
// verify that the Collection does not contain primitive values
if (item != null && complexValue == null)
{
throw DSClient.Error.InvalidOperation(DSClient.Strings.Collection_PrimitiveTypesInCollectionOfComplexTypesNotAllowed);
}
if (item != null)
{
ClientTypeAnnotation complexType = this.materializerContext.ResolveTypeForMaterialization(collectionItemType, complexValue.TypeName);
object complexInstance = this.CreateNewInstance(complexType.EdmTypeReference, complexType.ElementType);
// set properties with metarialized data values if there are any (note that for a payload that looks as follows <element xmlns="http://docs.oasis-open.org/odata/ns/data"/>
// and represents an item that is a complex type there are no properties to be set)
this.ComplexValueMaterializationPolicy.ApplyDataValues(complexType, complexValue.Properties, complexInstance);
addValueToBackingICollectionInstance(collectionInstance, complexInstance);
// Apply instance annotation for complex type item
this.InstanceAnnotationMaterializationPolicy.SetInstanceAnnotations(complexValue, complexInstance);
}
else
{
addValueToBackingICollectionInstance(collectionInstance, null);
}
}
}
}
}
/// <summary>
/// Writes a single instance annotation in ATOM format.
/// </summary>
/// <param name="instanceAnnotation">The instance annotation to write.</param>
internal void WriteInstanceAnnotation(AtomInstanceAnnotation instanceAnnotation)
{
Debug.Assert(instanceAnnotation != null, "instanceAnnotation != null");
Debug.Assert(!string.IsNullOrEmpty(instanceAnnotation.TermName), "!string.IsNullOrEmpty(instanceAnnotation.TermName)");
if (this.MessageWriterSettings.ShouldSkipAnnotation(instanceAnnotation.TermName))
{
return;
}
IEdmTypeReference expectedType = MetadataUtils.LookupTypeOfValueTerm(instanceAnnotation.TermName, this.Model);
this.WriteInstanceAnnotationStart(instanceAnnotation);
ODataPrimitiveValue primitiveValue = instanceAnnotation.Value as ODataPrimitiveValue;
if (primitiveValue != null)
{
this.WritePrimitiveInstanceAnnotationValue(primitiveValue, expectedType);
}
else
{
ODataComplexValue complexValue = instanceAnnotation.Value as ODataComplexValue;
if (complexValue != null)
{
this.WriteComplexValue(
complexValue,
expectedType,
/*isOpenPropertyType*/ false,
/*isWritingCollection*/ false,
/*beforeValueAction*/ null,
/*afterValueAction*/ null,
this.CreateDuplicatePropertyNamesChecker(),
/*collectionValidator*/ null,
/*projectedProperties*/ null);
}
else
{
ODataCollectionValue collectionValue = instanceAnnotation.Value as ODataCollectionValue;
if (collectionValue != null)
{
this.WriteCollectionValue(
collectionValue,
expectedType,
/*isOpenPropertyType*/ false,
/*isWritingCollection*/ false);
}
else
{
// Note that the ODataInstanceAnnotation constructor validates that the value is never an ODataStreamReferenceValue
Debug.Assert(instanceAnnotation.Value is ODataNullValue, "instanceAnnotation.Value is ODataNullValue");
if (expectedType != null && !expectedType.IsNullable)
{
throw new ODataException(ODataErrorStrings.ODataAtomPropertyAndValueSerializer_NullValueNotAllowedForInstanceAnnotation(instanceAnnotation.TermName, expectedType.FullName()));
}
this.WriteNullAttribute();
}
}
}
this.WriteInstanceAnnotationEnd();
}
public void WriteComplexValue(
ODataComplexValue complexValue,
IEdmTypeReference metadataTypeReference,
bool isTopLevel,
bool isOpenPropertyType,
DuplicatePropertyNamesChecker duplicatePropertyNamesChecker)
{
Debug.Assert(complexValue != null, "complexValue != null");
this.IncreaseRecursionDepth();
// Start the object scope which will represent the entire complex instance;
// for top-level complex properties we already wrote the object scope (and the context URI when needed).
if (!isTopLevel)
{
this.JsonWriter.StartObjectScope();
}
string typeName = complexValue.TypeName;
if (isTopLevel)
{
Debug.Assert(metadataTypeReference == null, "Never expect a metadata type for top-level properties.");
if (typeName == null)
{
throw new ODataException(ODataErrorStrings.ODataJsonLightValueSerializer_MissingTypeNameOnComplex);
}
}
else
{
// In requests, we allow the property type reference to be null if the type name is specified in the OM
if (metadataTypeReference == null && !this.WritingResponse && typeName == null && this.Model.IsUserModel())
{
throw new ODataException(ODataErrorStrings.ODataJsonLightPropertyAndValueSerializer_NoExpectedTypeOrTypeNameSpecifiedForComplexValueRequest);
}
}
// Resolve the type name to the type; if no type name is specified we will use the
// type inferred from metadata.
IEdmComplexTypeReference complexValueTypeReference = (IEdmComplexTypeReference)TypeNameOracle.ResolveAndValidateTypeNameForValue(this.Model, metadataTypeReference, complexValue, isOpenPropertyType);
Debug.Assert(
metadataTypeReference == null || complexValueTypeReference == null || EdmLibraryExtensions.IsAssignableFrom(metadataTypeReference, complexValueTypeReference),
"Complex property types must be the same as or inherit from the ones from metadata (unless open).");
typeName = this.JsonLightOutputContext.TypeNameOracle.GetValueTypeNameForWriting(complexValue, metadataTypeReference, complexValueTypeReference, isOpenPropertyType);
if (typeName != null)
{
ODataJsonLightWriterUtils.WriteODataTypeInstanceAnnotation(this.JsonWriter, typeName);
}
// Write custom instance annotations
this.InstanceAnnotationWriter.WriteInstanceAnnotations(complexValue.InstanceAnnotations);
// Write the properties of the complex value as usual. Note we do not allow complex types to contain named stream properties.
this.PropertySerializer.WriteProperties(
complexValueTypeReference == null ? null : complexValueTypeReference.ComplexDefinition(),
complexValue.Properties,
true /* isComplexValue */,
duplicatePropertyNamesChecker,
null /*projectedProperties */);
// End the object scope which represents the complex instance;
// for top-level complex properties we already wrote the end object scope.
if (!isTopLevel)
{
this.JsonWriter.EndObjectScope();
}
this.DecreaseRecursionDepth();
}
public void WriteCollectionValue(ODataCollectionValue collectionValue, IEdmTypeReference metadataTypeReference, bool isTopLevelProperty, bool isInUri, bool isOpenPropertyType)
{
Debug.Assert(collectionValue != null, "collectionValue != null");
Debug.Assert(!isTopLevelProperty || !isInUri, "Cannot be a top level property and in a uri");
this.IncreaseRecursionDepth();
// If the CollectionValue has type information write out the metadata and the type in it.
string typeName = collectionValue.TypeName;
if (isTopLevelProperty)
{
Debug.Assert(metadataTypeReference == null, "Never expect a metadata type for top-level properties.");
if (typeName == null)
{
throw new ODataException(ODataErrorStrings.ODataJsonLightValueSerializer_MissingTypeNameOnCollection);
}
}
else
{
// In requests, we allow the metadata type reference to be null if the type name is specified in the OM
if (metadataTypeReference == null && !this.WritingResponse && typeName == null && this.Model.IsUserModel())
{
throw new ODataException(ODataErrorStrings.ODataJsonLightPropertyAndValueSerializer_NoExpectedTypeOrTypeNameSpecifiedForCollectionValueInRequest);
}
}
// resolve the type name to the type; if no type name is specified we will use the
// type inferred from metadata
IEdmCollectionTypeReference collectionTypeReference = (IEdmCollectionTypeReference)TypeNameOracle.ResolveAndValidateTypeNameForValue(this.Model, metadataTypeReference, collectionValue, isOpenPropertyType);
typeName = this.JsonLightOutputContext.TypeNameOracle.GetValueTypeNameForWriting(collectionValue, metadataTypeReference, collectionTypeReference, isOpenPropertyType);
bool useValueProperty = isInUri && !string.IsNullOrEmpty(typeName);
if (useValueProperty)
{
// "{"
this.JsonWriter.StartObjectScope();
ODataJsonLightWriterUtils.WriteODataTypeInstanceAnnotation(this.JsonWriter, typeName);
this.JsonWriter.WriteValuePropertyName();
}
// [
// This represents the array of items in the CollectionValue
this.JsonWriter.StartArrayScope();
// Iterate through the CollectionValue items and write them out (treat null Items as an empty enumeration)
IEnumerable items = collectionValue.Items;
if (items != null)
{
IEdmTypeReference expectedItemTypeReference = collectionTypeReference == null ? null : collectionTypeReference.ElementType();
DuplicatePropertyNamesChecker duplicatePropertyNamesChecker = null;
foreach (object item in items)
{
ValidationUtils.ValidateCollectionItem(item, expectedItemTypeReference.IsNullable());
ODataComplexValue itemAsComplexValue = item as ODataComplexValue;
if (itemAsComplexValue != null)
{
if (duplicatePropertyNamesChecker == null)
{
duplicatePropertyNamesChecker = this.CreateDuplicatePropertyNamesChecker();
}
this.WriteComplexValue(
itemAsComplexValue,
expectedItemTypeReference,
false /*isTopLevel*/,
false /*isOpenPropertyType*/,
duplicatePropertyNamesChecker);
duplicatePropertyNamesChecker.Clear();
}
else
{
Debug.Assert(!(item is ODataCollectionValue), "!(item is ODataCollectionValue)");
Debug.Assert(!(item is ODataStreamReferenceValue), "!(item is ODataStreamReferenceValue)");
// by design: collection element's type name is not written for enum or non-spatial primitive value even in case of full metadata.
// because enum and non-spatial primitive types don't have inheritance, the type of each element is the same as the item type of the collection, whose type name for spatial types in full metadata mode.
ODataEnumValue enumValue = item as ODataEnumValue;
if (enumValue != null)
{
this.WriteEnumValue(enumValue, expectedItemTypeReference);
}
else
{
if (item != null)
{
this.WritePrimitiveValue(item, expectedItemTypeReference);
}
else
{
this.WriteNullValue();
}
}
}
}
}
// End the array scope which holds the items
this.JsonWriter.EndArrayScope();
if (useValueProperty)
{
this.JsonWriter.EndObjectScope();
}
this.DecreaseRecursionDepth();
}
private void WriteValue(object value)
{
ODataComplexValue complexValue = value as ODataComplexValue;
if (complexValue != null)
{
this.writer.WriteLine("ODataComplexValue");
this.writer.Indent++;
this.writer.WriteLine("TypeName: " + (complexValue.TypeName ?? "<null>"));
this.WriteProperties(complexValue.Properties);
this.writer.Indent--;
return;
}
ODataMultiValue multiValue = value as ODataMultiValue;
if (multiValue != null)
{
this.writer.WriteLine("ODataMultiValue");
this.writer.Indent++;
this.writer.WriteLine("TypeName: " + (multiValue.TypeName ?? "<null>"));
this.writer.WriteLine("Items:");
this.writer.Indent++;
foreach (object item in multiValue.Items)
{
this.WriteValue(item);
}
this.writer.Indent--;
this.writer.Indent--;
return;
}
ODataStreamReferenceValue streamReferenceValue = value as ODataStreamReferenceValue;
if (streamReferenceValue != null)
{
this.writer.WriteLine("ODataStreamReferenceValue");
this.writer.Indent++;
if (streamReferenceValue.ReadLink != null)
{
this.writer.WriteLine("ReadLink: " + streamReferenceValue.ReadLink.AbsoluteUri);
}
if (streamReferenceValue.EditLink != null)
{
this.writer.WriteLine("EditLink: " + streamReferenceValue.EditLink.AbsoluteUri);
}
this.writer.Indent--;
return;
}
if (value == null)
{
this.writer.WriteLine("null");
}
else
{
this.writer.WriteLine(value.ToString());
}
}
/// <summary>
/// Write the items in a MultiValue in ATOM format.
/// </summary>
/// <param name="writer">The <see cref="XmlWriter"/> to write to.</param>
/// <param name="metadata">The metadata provider to use or null if no metadata is available.</param>
/// <param name="multiValue">The MultiValue to write.</param>
/// <param name="resourcePropertyType">The resource type of the multi value (or null if not metadata is available).</param>
/// <param name="isOpenPropertyType">True if the type name belongs to an open property.</param>
/// <param name="isWritingCollection">True if we are writing a collection instead of an entry.</param>
/// <param name="version">The protocol version used for writing.</param>
/// <param name="epmValueCache">Cache of values used in EPM so that we avoid multiple enumerations of properties/items. (can be null)</param>
/// <param name="epmSourcePathSegment">The EPM source path segment which points to the multivalue property we're writing. (can be null)</param>
private static void WriteMultiValue(
XmlWriter writer,
DataServiceMetadataProviderWrapper metadata,
ODataMultiValue multiValue,
ResourceType resourcePropertyType,
bool isOpenPropertyType,
bool isWritingCollection,
ODataVersion version,
EpmValueCache epmValueCache,
EpmSourcePathSegment epmSourcePathSegment)
{
Debug.Assert(multiValue != null, "multiValue != null");
string typeName = multiValue.TypeName;
// resolve the type name to the resource type; if no type name is specified we will use the
// type inferred from metadata
MultiValueResourceType multiValueType = (MultiValueResourceType)MetadataUtils.ResolveTypeName(metadata, resourcePropertyType, ref typeName, ResourceTypeKind.MultiValue, isOpenPropertyType);
if (typeName != null)
{
WritePropertyTypeAttribute(writer, typeName);
}
ResourceType expectedItemType = multiValueType == null ? null : multiValueType.ItemType;
IEnumerable items = EpmValueCache.GetMultiValueItems(epmValueCache, epmSourcePathSegment, multiValue, true);
if (items != null)
{
foreach (object itemValue in items)
{
object item;
EpmMultiValueItemCache epmItemCache = itemValue as EpmMultiValueItemCache;
if (epmItemCache != null)
{
item = epmItemCache.ItemValue;
}
else
{
item = itemValue;
}
ValidationUtils.ValidateMultiValueItem(item);
writer.WriteStartElement(AtomConstants.ODataNamespacePrefix, AtomConstants.ODataMultiValueItemElementName, AtomConstants.ODataNamespace);
ODataComplexValue complexValue = item as ODataComplexValue;
if (complexValue != null)
{
WriteComplexValue(writer, metadata, complexValue, expectedItemType, false, isWritingCollection, version, epmItemCache, epmSourcePathSegment);
}
else
{
ODataMultiValue multiValueItem = item as ODataMultiValue;
if (multiValueItem != null)
{
throw new ODataException(Strings.ODataWriter_NestedMultiValuesAreNotSupported);
}
else
{
AtomValueUtils.WritePrimitiveValue(writer, item, expectedItemType);
}
}
writer.WriteEndElement();
}
}
}
/// <summary>
/// Writes a single property in ATOM format.
/// </summary>
/// <param name="writer">The <see cref="XmlWriter"/> to write to.</param>
/// <param name="metadata">The metadata provider to use or null if no metadata is available.</param>
/// <param name="property">The property to write out.</param>
/// <param name="owningType">The type owning the property (or null if no metadata is available).</param>
/// <param name="version">The protocol version used for writing.</param>
/// <param name="isTopLevel">True if writing a top-level property payload; otherwise false.</param>
/// <param name="isWritingCollection">True if we are writing a collection instead of an entry.</param>
/// <param name="epmValueCache">Cache of values used in EPM so that we avoid multiple enumerations of properties/items. (can be null)</param>
/// <param name="epmParentSourcePathSegment">The EPM source path segment which points to the property which sub-property we're writing. (can be null)</param>
internal static void WriteProperty(
XmlWriter writer,
DataServiceMetadataProviderWrapper metadata,
ODataProperty property,
ResourceType owningType,
ODataVersion version,
bool isTopLevel,
bool isWritingCollection,
EpmValueCache epmValueCache,
EpmSourcePathSegment epmParentSourcePathSegment)
{
DebugUtils.CheckNoExternalCallers();
Debug.Assert(writer != null, "writer != null");
ValidationUtils.ValidateProperty(property);
ResourceProperty resourceProperty = ValidationUtils.ValidatePropertyDefined(property.Name, owningType);
EpmSourcePathSegment epmSourcePathSegment = null;
if (epmParentSourcePathSegment != null)
{
epmSourcePathSegment = epmParentSourcePathSegment.SubProperties.Where(subProperty => subProperty.PropertyName == property.Name).FirstOrDefault();
}
object value = property.Value;
// TODO: If we implement validation or type conversions the value needs to be converted here
// since the next method call needs to know if the value is a string or not in some cases.
// If EPM tells us to skip this property in content, then we're done here.
if (!ShouldWritePropertyInContent(value, epmSourcePathSegment, version))
{
return;
}
// <d:propertyname>
writer.WriteStartElement(
isWritingCollection ? string.Empty : AtomConstants.ODataNamespacePrefix,
property.Name,
AtomConstants.ODataNamespace);
if (isTopLevel)
{
WriteDefaultNamespaceAttributes(writer, DefaultNamespaceFlags.OData | DefaultNamespaceFlags.ODataMetadata);
}
// Null property value.
if (value == null)
{
// verify that MultiValue properties are not null
if (resourceProperty != null && resourceProperty.Kind == ResourcePropertyKind.MultiValue)
{
throw new ODataException(Strings.ODataWriter_MultiValuePropertiesMustNotHaveNullValue(resourceProperty.Name));
}
ODataAtomWriterUtils.WriteNullAttribute(writer);
}
else
{
ODataComplexValue complexValue = value as ODataComplexValue;
ResourceType resourcePropertyType = resourceProperty == null ? null : resourceProperty.ResourceType;
bool isOpenPropertyType = owningType != null && owningType.IsOpenType && resourceProperty == null;
// Complex properties are written recursively.
if (complexValue != null)
{
WriteComplexValue(writer, metadata, complexValue, resourcePropertyType, isOpenPropertyType, isWritingCollection, version, epmValueCache, epmSourcePathSegment);
}
else
{
ODataMultiValue multiValue = value as ODataMultiValue;
if (multiValue != null)
{
ODataVersionChecker.CheckMultiValueProperties(version, property.Name);
WriteMultiValue(writer, metadata, multiValue, resourcePropertyType, isOpenPropertyType, isWritingCollection, version, epmValueCache, epmSourcePathSegment);
}
else
{
WritePrimitiveValue(writer, value, resourcePropertyType);
}
}
}
// </d:propertyname>
writer.WriteEndElement();
}
public void BuildPropertyContextUriForComplexPropertyValue()
{
ODataComplexValue value = new ODataComplexValue { TypeName = "FQNS.FakeType" };
var contextUri = this.CreatePropertyContextUri(value);
contextUri.OriginalString.Should().Be(BuildExpectedContextUri("#FQNS.FakeType"));
}
private void WriteProperty(
ODataProperty property,
IEdmStructuredType owningType,
bool isTopLevel,
bool allowStreamProperty,
DuplicatePropertyNamesChecker duplicatePropertyNamesChecker,
ProjectedPropertiesAnnotation projectedProperties)
{
WriterValidationUtils.ValidatePropertyNotNull(property);
string propertyName = property.Name;
if (projectedProperties.ShouldSkipProperty(propertyName))
{
return;
}
WriterValidationUtils.ValidatePropertyName(propertyName);
duplicatePropertyNamesChecker.CheckForDuplicatePropertyNames(property);
IEdmProperty edmProperty = null;
IEdmTypeReference propertyTypeReference = null;
if (this.JsonLightOutputContext.MessageWriterSettings.EnableFullValidation)
{
edmProperty = WriterValidationUtils.ValidatePropertyDefined(propertyName, owningType);
propertyTypeReference = edmProperty == null ? null : edmProperty.Type;
}
ODataValue value = property.ODataValue;
ODataPrimitiveValue primitiveValue = value as ODataPrimitiveValue;
ODataStreamReferenceValue streamReferenceValue = value as ODataStreamReferenceValue;
if (streamReferenceValue != null)
{
if (!allowStreamProperty)
{
throw new ODataException(ODataErrorStrings.ODataWriter_StreamPropertiesMustBePropertiesOfODataEntry(propertyName));
}
Debug.Assert(owningType == null || owningType.IsODataEntityTypeKind(), "The metadata should not allow named stream properties to be defined on a non-entity type.");
Debug.Assert(!isTopLevel, "Stream properties are not allowed at the top level.");
WriterValidationUtils.ValidateStreamReferenceProperty(property, edmProperty, this.Version, this.WritingResponse);
this.WriteStreamReferenceProperty(propertyName, streamReferenceValue);
return;
}
string wirePropertyName = isTopLevel ? JsonLightConstants.ODataValuePropertyName : propertyName;
if (value is ODataNullValue || value == null)
{
WriterValidationUtils.ValidateNullPropertyValue(propertyTypeReference, propertyName, this.MessageWriterSettings.WriterBehavior, this.Model);
if (isTopLevel)
{
// Write the special null marker for top-level null properties.
this.JsonWriter.WriteInstanceAnnotationName(ODataAnnotationNames.ODataNull);
this.JsonWriter.WriteValue(true);
}
else
{
this.JsonWriter.WriteName(wirePropertyName);
this.JsonLightValueSerializer.WriteNullValue();
}
return;
}
bool isOpenPropertyType = this.IsOpenProperty(property, owningType, edmProperty);
if (isOpenPropertyType && this.JsonLightOutputContext.MessageWriterSettings.EnableFullValidation)
{
ValidationUtils.ValidateOpenPropertyValue(propertyName, value);
}
ODataComplexValue complexValue = value as ODataComplexValue;
if (complexValue != null)
{
if (!isTopLevel)
{
this.JsonWriter.WriteName(wirePropertyName);
}
this.JsonLightValueSerializer.WriteComplexValue(complexValue, propertyTypeReference, isTopLevel, isOpenPropertyType, this.CreateDuplicatePropertyNamesChecker());
return;
}
IEdmTypeReference typeFromValue = TypeNameOracle.ResolveAndValidateTypeNameForValue(this.Model, propertyTypeReference, value, isOpenPropertyType);
ODataEnumValue enumValue = value as ODataEnumValue;
if (enumValue != null)
{
string typeNameToWrite = this.JsonLightOutputContext.TypeNameOracle.GetValueTypeNameForWriting(enumValue, propertyTypeReference, typeFromValue, isOpenPropertyType);
this.WritePropertyTypeName(wirePropertyName, typeNameToWrite, isTopLevel);
this.JsonWriter.WriteName(wirePropertyName);
this.JsonLightValueSerializer.WriteEnumValue(enumValue, propertyTypeReference);
return;
}
ODataCollectionValue collectionValue = value as ODataCollectionValue;
if (collectionValue != null)
{
string collectionTypeNameToWrite = this.JsonLightOutputContext.TypeNameOracle.GetValueTypeNameForWriting(collectionValue, propertyTypeReference, typeFromValue, isOpenPropertyType);
this.WritePropertyTypeName(wirePropertyName, collectionTypeNameToWrite, isTopLevel);
this.JsonWriter.WriteName(wirePropertyName);
// passing false for 'isTopLevel' because the outer wrapping object has already been written.
this.JsonLightValueSerializer.WriteCollectionValue(collectionValue, propertyTypeReference, isTopLevel, false /*isInUri*/, isOpenPropertyType);
}
else
{
Debug.Assert(primitiveValue != null, "primitiveValue != null");
string typeNameToWrite = this.JsonLightOutputContext.TypeNameOracle.GetValueTypeNameForWriting(primitiveValue, propertyTypeReference, typeFromValue, isOpenPropertyType);
this.WritePropertyTypeName(wirePropertyName, typeNameToWrite, isTopLevel);
this.JsonWriter.WriteName(wirePropertyName);
this.JsonLightValueSerializer.WritePrimitiveValue(primitiveValue.Value, propertyTypeReference);
}
}
public void WriteTopLevelErrorWithComplexInstanceAnnotation()
{
var result = SetupSerializerAndRunTest(null, serializer =>
{
ODataError error = new ODataError();
var instanceAnnotations = new Collection<ODataInstanceAnnotation>();
var complexValue = new ODataComplexValue();
complexValue.TypeName = "ns.ErrorDetails";
ODataInstanceAnnotation annotation = new ODataInstanceAnnotation("sample.complex", complexValue);
instanceAnnotations.Add(annotation);
error.InstanceAnnotations = instanceAnnotations;
serializer.WriteTopLevelError(error, false);
});
result.Should().Contain("\"@sample.complex\":{\"@odata.type\":\"#ns.ErrorDetails\"}");
}
private void ProcessUpdateRequestBody(IODataRequestMessage requestMessage, IODataResponseMessage responseMessage, object targetObject, bool isUpsert)
{
if (this.QueryContext.Target.NavigationSource != null && this.QueryContext.Target.TypeKind == EdmTypeKind.Entity)
{
using (var messageReader = new ODataMessageReader(requestMessage, this.GetReaderSettings(), this.DataSource.Model))
{
var entryReader = messageReader.CreateODataEntryReader(this.QueryContext.Target.NavigationSource, (IEdmEntityType)this.QueryContext.Target.Type);
while (entryReader.Read())
{
switch (entryReader.State)
{
case ODataReaderState.EntryEnd:
var entry = (ODataEntry)entryReader.Item;
foreach (var property in entry.Properties)
{
if (Utility.IsETagProperty(targetObject, property.Name))
{
continue;
}
// the property might be an open property, so test null first
var propertyInfo = targetObject.GetType().GetProperty(property.Name);
if (propertyInfo != null)
{
if (!isUpsert && Utility.IsReadOnly(propertyInfo))
{
continue;
}
}
this.DataSource.UpdateProvider.Update(targetObject, property.Name, property.Value);
}
break;
}
}
}
}
else if (this.QueryContext.Target.Property != null && this.QueryContext.Target.TypeKind == EdmTypeKind.Complex)
{
using (var messageReader = new ODataMessageReader(requestMessage, this.GetReaderSettings(), this.DataSource.Model))
{
var property = messageReader.ReadProperty(this.QueryContext.Target.Property);
ODataComplexValue complexValue = property.Value as ODataComplexValue;
foreach (var p in complexValue.Properties)
{
if (Utility.IsETagProperty(targetObject, property.Name))
{
continue;
}
this.DataSource.UpdateProvider.Update(targetObject, p.Name, p.Value);
}
}
}
else
{
throw Utility.BuildException(
HttpStatusCode.NotImplemented,
string.Format("PATCH/PUT for '{0}' type is not supported.", this.QueryContext.Target.TypeKind),
null);
}
var currentETag = Utility.GetETagValue(targetObject);
// if the current entity has ETag field
if (currentETag != null)
{
if (!isUpsert)
{
this.DataSource.UpdateProvider.UpdateETagValue(targetObject);
}
this.DataSource.UpdateProvider.SaveChanges();
currentETag = Utility.GetETagValue(targetObject);
responseMessage.SetHeader(ServiceConstants.HttpHeaders.ETag, currentETag);
}
else
{
this.DataSource.UpdateProvider.SaveChanges();
}
ResponseWriter.WriteEmptyResponse(responseMessage);
}
/// <summary>
/// Writes a name/value pair for a property.
/// </summary>
/// <param name="property">The property to write out.</param>
/// <param name="owningType">The <see cref="IEdmStructuredType"/> of the entry or complex type containing the property (or null if not metadata is available).</param>
/// <param name="allowStreamProperty">Should pass in true if we are writing a property of an ODataEntry instance, false otherwise.
/// Named stream properties should only be defined on ODataEntry instances.</param>
/// <param name="duplicatePropertyNamesChecker">The checker instance for duplicate property names.</param>
/// <param name="projectedProperties">Set of projected properties, or null if all properties should be written.</param>
private void WriteProperty(
ODataProperty property,
IEdmStructuredType owningType,
bool allowStreamProperty,
DuplicatePropertyNamesChecker duplicatePropertyNamesChecker,
ProjectedPropertiesAnnotation projectedProperties)
{
DebugUtils.CheckNoExternalCallers();
WriterValidationUtils.ValidatePropertyNotNull(property);
string propertyName = property.Name;
object value = property.Value;
if (projectedProperties.ShouldSkipProperty(propertyName))
{
return;
}
WriterValidationUtils.ValidatePropertyName(propertyName);
duplicatePropertyNamesChecker.CheckForDuplicatePropertyNames(property);
IEdmProperty edmProperty = WriterValidationUtils.ValidatePropertyDefined(propertyName, owningType, this.MessageWriterSettings.UndeclaredPropertyBehaviorKinds);
IEdmTypeReference propertyTypeReference = edmProperty == null ? null : edmProperty.Type;
// If the property is of Geography or Geometry type or the value is of Geography or Geometry type
// make sure to check that the version is 3.0 or above.
if ((propertyTypeReference != null && propertyTypeReference.IsSpatial()) ||
(propertyTypeReference == null && value is System.Spatial.ISpatial))
{
ODataVersionChecker.CheckSpatialValue(this.Version);
}
this.JsonWriter.WriteName(propertyName);
if (value == null)
{
WriterValidationUtils.ValidateNullPropertyValue(propertyTypeReference, propertyName, this.MessageWriterSettings.WriterBehavior, this.Model);
this.JsonWriter.WriteValue(null);
}
else
{
bool isOpenPropertyType = owningType != null && owningType.IsOpen && propertyTypeReference == null;
if (isOpenPropertyType)
{
ValidationUtils.ValidateOpenPropertyValue(propertyName, value, this.MessageWriterSettings.UndeclaredPropertyBehaviorKinds);
}
ODataComplexValue complexValue = value as ODataComplexValue;
if (complexValue != null)
{
this.WriteComplexValue(
complexValue,
propertyTypeReference,
isOpenPropertyType,
this.CreateDuplicatePropertyNamesChecker(),
/*collectionValidator*/ null);
}
else
{
ODataCollectionValue collectionValue = value as ODataCollectionValue;
if (collectionValue != null)
{
ODataVersionChecker.CheckCollectionValueProperties(this.Version, propertyName);
this.WriteCollectionValue(
collectionValue,
propertyTypeReference,
isOpenPropertyType);
}
else
{
ODataStreamReferenceValue streamReferenceValue = value as ODataStreamReferenceValue;
if (streamReferenceValue != null)
{
if (!allowStreamProperty)
{
throw new ODataException(ODataErrorStrings.ODataWriter_StreamPropertiesMustBePropertiesOfODataEntry(propertyName));
}
Debug.Assert(owningType == null || owningType.IsODataEntityTypeKind(), "The metadata should not allow named stream properties to be defined on a non-entity type.");
WriterValidationUtils.ValidateStreamReferenceProperty(property, edmProperty, this.Version, this.WritingResponse);
WriterValidationUtils.ValidateStreamReferenceValue(streamReferenceValue, /*isDefaultStream*/ false);
this.WriteStreamReferenceValue(streamReferenceValue);
}
else
{
this.WritePrimitiveValue(value, /*collectionValidator*/ null, propertyTypeReference);
}
}
}
}
}
/// <summary>
/// Reads a property value starting with the specified index to the property value path.
/// </summary>
/// <param name="epmInfo">The EPM info which describes the mapping for which to read the property value.</param>
/// <param name="cachedProperties">The enumeration of properties to search for the first property in the property value path.</param>
/// <param name="sourceSegmentIndex">The index in the property value path to start with.</param>
/// <param name="structuredTypeReference">The type of the entry or complex value the <paramref name="cachedProperties"/> enumeration belongs to.</param>
/// <param name="epmValueCache">The EPM value cache to use.</param>
/// <returns>The value of the property (may be null), or null if the property itself was not found due to one of its parent properties being null.</returns>
private object ReadPropertyValue(
EntityPropertyMappingInfo epmInfo,
IEnumerable <ODataProperty> cachedProperties,
int sourceSegmentIndex,
IEdmStructuredTypeReference structuredTypeReference,
EpmValueCache epmValueCache)
{
Debug.Assert(epmInfo != null, "epmInfo != null");
Debug.Assert(epmInfo.PropertyValuePath != null, "The PropertyValuePath should have been initialized by now.");
Debug.Assert(epmInfo.PropertyValuePath.Length > sourceSegmentIndex, "The PropertyValuePath must be at least as long as the source segment index.");
Debug.Assert(structuredTypeReference != null, "structuredTypeReference != null");
Debug.Assert(epmValueCache != null, "epmValueCache != null");
EpmSourcePathSegment sourceSegment = epmInfo.PropertyValuePath[sourceSegmentIndex];
string propertyName = sourceSegment.PropertyName;
bool lastSegment = epmInfo.PropertyValuePath.Length == sourceSegmentIndex + 1;
IEdmStructuredType structuredType = structuredTypeReference.StructuredDefinition();
IEdmProperty edmProperty = WriterValidationUtils.ValidatePropertyDefined(propertyName, structuredType);
if (edmProperty != null)
{
// If this is the last part of the path, then it has to be a primitive or atomic collection type otherwise should be a complex type
if (lastSegment)
{
if (!edmProperty.Type.IsODataPrimitiveTypeKind() && !edmProperty.Type.IsNonEntityODataCollectionTypeKind())
{
throw new ODataException(o.Strings.EpmSourceTree_EndsWithNonPrimitiveType(propertyName));
}
}
else
{
if (edmProperty.Type.TypeKind() != EdmTypeKind.Complex)
{
throw new ODataException(o.Strings.EpmSourceTree_TraversalOfNonComplexType(propertyName));
}
}
}
else
{
Debug.Assert(
structuredType.IsOpen,
"Only open types can have undeclared properties, otherwise we should have failed in the ValidatePropertyDefined method.");
}
ODataProperty property = cachedProperties == null ? null : cachedProperties.FirstOrDefault(p => p.Name == propertyName);
if (property == null)
{
throw new ODataException(o.Strings.EpmSourceTree_MissingPropertyOnInstance(propertyName, structuredTypeReference.ODataFullName()));
}
object propertyValue = property.Value;
ODataComplexValue propertyComplexValue = propertyValue as ODataComplexValue;
if (lastSegment)
{
if (propertyValue == null)
{
WriterValidationUtils.ValidateNullPropertyValue(edmProperty, this.WriterBehavior, this.atomOutputContext.Model);
}
else
{
// If this property is the last one it has to be either a primitive or collection
if (propertyComplexValue != null)
{
throw new ODataException(o.Strings.EpmSourceTree_EndsWithNonPrimitiveType(propertyName));
}
else
{
ODataCollectionValue propertyCollectionValue = propertyValue as ODataCollectionValue;
if (propertyCollectionValue != null)
{
// Validate the type name for the collection
string typeName = propertyCollectionValue.TypeName;
WriterValidationUtils.ResolveTypeNameForWriting(
this.atomOutputContext.Model,
edmProperty == null ? null : edmProperty.Type,
ref typeName,
EdmTypeKind.Collection,
edmProperty == null);
}
else
{
if (propertyValue is ODataStreamReferenceValue)
{
// Stream properties should not come here, if it were an ODataEntry property it would have been
// filtered in ReadEntryPropertyValue() by "epmValueCache.EntryProperties" call.
throw new ODataException(o.Strings.ODataWriter_StreamPropertiesMustBePropertiesOfODataEntry(propertyName));
}
else if (propertyValue is ISpatial)
{
throw new ODataException(o.Strings.EpmSourceTree_OpenPropertySpatialTypeCannotBeMapped(propertyName, epmInfo.DefiningType.FullName()));
}
else if (edmProperty != null)
{
ValidationUtils.ValidateIsExpectedPrimitiveType(propertyValue, edmProperty.Type);
}
}
}
}
return(propertyValue);
}
// Otherwise it's in the middle and thus it must be a complex value
if (propertyComplexValue == null)
{
if (propertyValue != null)
{
// It's not a complex value - fail.
throw new ODataException(o.Strings.EpmSourceTree_TraversalOfNonComplexType(propertyName));
}
else
{
// The value of the property is null, which can be a null complex value
// Note that we must not attempt to resolve the type as if the type name was null here, because
// 1) We don't need the type for anything anyway (the value is null, this is the end)
// 2) If the property is open, trying to resolve a null type name would throw
// but we don't have a null type name, we have a null entire value.
return(null);
}
}
string localTypeName = propertyComplexValue.TypeName;
IEdmComplexTypeReference complexValueType = WriterValidationUtils.ResolveTypeNameForWriting(
this.atomOutputContext.Model,
edmProperty == null ? null : edmProperty.Type,
ref localTypeName,
EdmTypeKind.Complex,
edmProperty == null).AsComplexOrNull();
return(this.ReadComplexPropertyValue(
epmInfo,
propertyComplexValue,
epmValueCache,
sourceSegmentIndex + 1,
complexValueType));
}
public void WritingMultipleInstanceAnnotationInComplexValueShouldSkipBaseOnSettings()
{
var complexType = new EdmComplexType("TestNamespace", "Address");
model.AddElement(complexType);
var result = this.SetupSerializerAndRunTest(serializer =>
{
var complexValue = new ODataComplexValue
{
TypeName = "TestNamespace.Address",
InstanceAnnotations = new Collection<ODataInstanceAnnotation>
{
new ODataInstanceAnnotation("Annotation.1", new ODataPrimitiveValue(true)),
new ODataInstanceAnnotation("Annotation.2", new ODataPrimitiveValue(123)),
new ODataInstanceAnnotation("Annotation.3", new ODataPrimitiveValue("annotation"))
}
};
var complexTypeRef = new EdmComplexTypeReference(complexType, false);
serializer.WriteComplexValue(complexValue, complexTypeRef, false, false, new DuplicatePropertyNamesChecker(false, true));
});
result.Should().NotContain("\"@Annotation.1\":true,\"@Annotation.2\":123,\"@Annotation.3\":\"annotation\"");
}
/// <summary>
/// Visits an item in the object model.
/// </summary>
/// <param name="objectModelItem">The item to visit.</param>
public virtual void Visit(object objectModelItem)
{
ODataFeed feed = objectModelItem as ODataFeed;
if (feed != null)
{
this.VisitFeed(feed);
return;
}
ODataEntry entry = objectModelItem as ODataEntry;
if (entry != null)
{
this.VisitEntry(entry);
return;
}
ODataProperty property = objectModelItem as ODataProperty;
if (property != null)
{
this.VisitProperty(property);
return;
}
ODataNavigationLink navigationLink = objectModelItem as ODataNavigationLink;
if (navigationLink != null)
{
this.VisitNavigationLink(navigationLink);
return;
}
ODataComplexValue complexValue = objectModelItem as ODataComplexValue;
if (complexValue != null)
{
this.VisitComplexValue(complexValue);
return;
}
ODataCollectionValue collectionValue = objectModelItem as ODataCollectionValue;
if (collectionValue != null)
{
this.VisitCollectionValue(collectionValue);
return;
}
ODataStreamReferenceValue streamReferenceValue = objectModelItem as ODataStreamReferenceValue;
if (streamReferenceValue != null)
{
this.VisitStreamReferenceValue(streamReferenceValue);
return;
}
ODataCollectionStart collectionStart = objectModelItem as ODataCollectionStart;
if (collectionStart != null)
{
this.VisitCollectionStart(collectionStart);
return;
}
ODataServiceDocument serviceDocument = objectModelItem as ODataServiceDocument;
if (serviceDocument != null)
{
this.VisitServiceDocument(serviceDocument);
return;
}
ODataEntitySetInfo entitySetInfo = objectModelItem as ODataEntitySetInfo;
if (entitySetInfo != null)
{
this.VisitEntitySet(entitySetInfo);
return;
}
ODataError error = objectModelItem as ODataError;
if (error != null)
{
this.VisitError(error);
return;
}
ODataInnerError innerError = objectModelItem as ODataInnerError;
if (innerError != null)
{
this.VisitInnerError(innerError);
return;
}
ODataEntityReferenceLinks entityReferenceLinks = objectModelItem as ODataEntityReferenceLinks;
if (entityReferenceLinks != null)
{
this.VisitEntityReferenceLinks(entityReferenceLinks);
return;
}
ODataEntityReferenceLink entityReferenceLink = objectModelItem as ODataEntityReferenceLink;
if (entityReferenceLink != null)
{
this.VisitEntityReferenceLink(entityReferenceLink);
return;
}
ODataAction action = objectModelItem as ODataAction;
if (action != null)
{
this.VisitODataOperation(action);
return;
}
ODataFunction function = objectModelItem as ODataFunction;
if (function != null)
{
this.VisitODataOperation(function);
return;
}
ODataParameters parameters = objectModelItem as ODataParameters;
if (parameters != null)
{
this.VisitParameters(parameters);
return;
}
ODataBatch batch = objectModelItem as ODataBatch;
if (batch != null)
{
this.VisitBatch(batch);
return;
}
ODataBatchChangeset batchChangeset = objectModelItem as ODataBatchChangeset;
if (batchChangeset != null)
{
this.VisitBatchChangeset(batchChangeset);
return;
}
ODataBatchRequestOperation batchRequestOperation = objectModelItem as ODataBatchRequestOperation;
if (batchRequestOperation != null)
{
this.VisitBatchRequestOperation(batchRequestOperation);
return;
}
ODataBatchResponseOperation batchResponseOperation = objectModelItem as ODataBatchResponseOperation;
if (batchResponseOperation != null)
{
this.VisitBatchResponseOperation(batchResponseOperation);
return;
}
if (objectModelItem == null || objectModelItem.GetType().IsValueType || objectModelItem is string ||
objectModelItem is byte[] || objectModelItem is ISpatial)
{
this.VisitPrimitiveValue(objectModelItem);
return;
}
this.VisitUnsupportedValue(objectModelItem);
}
internal bool WriteComplexValue(
ODataComplexValue complexValue,
IEdmTypeReference metadataTypeReference,
bool isOpenPropertyType,
bool isWritingCollection,
Action beforeValueAction,
Action afterValueAction,
DuplicatePropertyNamesChecker duplicatePropertyNamesChecker,
CollectionWithoutExpectedTypeValidator collectionValidator,
ProjectedPropertiesAnnotation projectedProperties)
{
Debug.Assert(complexValue != null, "complexValue != null");
string typeName = complexValue.TypeName;
if (collectionValidator != null)
{
collectionValidator.ValidateCollectionItem(typeName, EdmTypeKind.Complex);
}
this.IncreaseRecursionDepth();
// resolve the type name to the type; if no type name is specified we will use the
// type inferred from metadata
IEdmComplexTypeReference complexTypeReference = TypeNameOracle.ResolveAndValidateTypeForComplexValue(this.Model, metadataTypeReference, complexValue, isOpenPropertyType, this.WriterValidator).AsComplexOrNull();
string collectionItemTypeName;
typeName = this.AtomOutputContext.TypeNameOracle.GetValueTypeNameForWriting(complexValue, complexTypeReference, complexValue.GetAnnotation<SerializationTypeNameAnnotation>(), collectionValidator, out collectionItemTypeName);
Debug.Assert(collectionItemTypeName == null, "collectionItemTypeName == null");
Action beforeValueCallbackWithTypeName = beforeValueAction;
if (typeName != null)
{
// The beforeValueAction (if specified) will write the actual property element start.
// So if we are to write the type attribute, we must postpone that after the start element was written.
// And so we chain the existing action with our type attribute writing and use that
// as the before action instead.
if (beforeValueAction != null)
{
beforeValueCallbackWithTypeName = () =>
{
beforeValueAction();
this.WritePropertyTypeAttribute(typeName);
};
}
else
{
this.WritePropertyTypeAttribute(typeName);
}
}
bool propertyWritten = this.WriteProperties(
complexTypeReference == null ? null : complexTypeReference.ComplexDefinition(),
complexValue.Properties,
isWritingCollection,
beforeValueCallbackWithTypeName,
afterValueAction,
duplicatePropertyNamesChecker,
projectedProperties);
this.DecreaseRecursionDepth();
return propertyWritten;
}
/// <summary>
/// Writes the body operation parameters associated with a ServiceAction.
/// </summary>
/// <param name="operationParameters">The list of operation parameters to write.</param>
/// <param name="requestMessage">The OData request message used to write the operation parameters.</param>
internal void WriteBodyOperationParameters(List <BodyOperationParameter> operationParameters, ODataRequestMessageWrapper requestMessage)
{
Debug.Assert(requestMessage != null, "requestMessage != null");
Debug.Assert(operationParameters != null, "operationParameters != null");
Debug.Assert(operationParameters.Any(), "operationParameters.Any()");
using (ODataMessageWriter messageWriter = Serializer.CreateMessageWriter(requestMessage, this.requestInfo, true /*isParameterPayload*/))
{
ODataParameterWriter parameterWriter = messageWriter.CreateODataParameterWriter(null);
parameterWriter.WriteStart();
foreach (OperationParameter operationParameter in operationParameters)
{
if (operationParameter.Value == null)
{
parameterWriter.WriteValue(operationParameter.Name, operationParameter.Value);
}
else
{
ClientEdmModel model = this.requestInfo.Model;
IEdmType edmType = model.GetOrCreateEdmType(operationParameter.Value.GetType());
Debug.Assert(edmType != null, "edmType != null");
switch (edmType.TypeKind)
{
case EdmTypeKind.Collection:
{
Collections.IEnumerator enumerator = ((ICollection)operationParameter.Value).GetEnumerator();
ODataCollectionWriter collectionWriter = parameterWriter.CreateCollectionWriter(operationParameter.Name);
ODataCollectionStart odataCollectionStart = new ODataCollectionStart();
collectionWriter.WriteStart(odataCollectionStart);
while (enumerator.MoveNext())
{
Object collectionItem = enumerator.Current;
if (collectionItem == null)
{
throw new NotSupportedException(Strings.Serializer_NullCollectionParamterItemValue(operationParameter.Name));
}
IEdmType edmItemType = model.GetOrCreateEdmType(collectionItem.GetType());
Debug.Assert(edmItemType != null, "edmItemType != null");
switch (edmItemType.TypeKind)
{
case EdmTypeKind.Complex:
{
Debug.Assert(model.GetClientTypeAnnotation(edmItemType).ElementType != null, "edmItemType.GetClientTypeAnnotation().ElementType != null");
ODataComplexValue complexValue = this.propertyConverter.CreateODataComplexValue(
model.GetClientTypeAnnotation(edmItemType).ElementType,
collectionItem,
null /*propertyName*/,
false /*isCollectionItem*/,
null /*visitedComplexTypeObjects*/);
Debug.Assert(complexValue != null, "complexValue != null");
collectionWriter.WriteItem(complexValue);
break;
}
case EdmTypeKind.Primitive:
{
collectionWriter.WriteItem(collectionItem);
break;
}
default:
// EdmTypeKind.Entity
// EdmTypeKind.Row
// EdmTypeKind.EntityReference
// EdmTypeKind.Enum.
throw new NotSupportedException(Strings.Serializer_InvalidCollectionParamterItemType(operationParameter.Name, edmItemType.TypeKind));
}
}
collectionWriter.WriteEnd();
collectionWriter.Flush();
break;
}
case EdmTypeKind.Complex:
{
Debug.Assert(model.GetClientTypeAnnotation(edmType).ElementType != null, "model.GetClientTypeAnnotation(edmType).ElementType != null");
ODataComplexValue complexValue = this.propertyConverter.CreateODataComplexValue(
model.GetClientTypeAnnotation(edmType).ElementType,
operationParameter.Value,
null /*propertyName*/,
false /*isCollectionItemType*/,
null /*visitedComplexTypeObjects*/);
Debug.Assert(complexValue != null, "complexValue != null");
parameterWriter.WriteValue(operationParameter.Name, complexValue);
break;
}
case EdmTypeKind.Primitive:
parameterWriter.WriteValue(operationParameter.Name, operationParameter.Value);
break;
default:
// EdmTypeKind.Entity
// EdmTypeKind.Row
// EdmTypeKind.EntityReference
// EdmTypeKind.Enum.
throw new NotSupportedException(Strings.Serializer_InvalidParameterType(operationParameter.Name, edmType.TypeKind));
}
} // else
} // foreach
parameterWriter.WriteEnd();
parameterWriter.Flush();
}
}
/// <summary>
/// Writes a single property in ATOM format.
/// </summary>
/// <param name="property">The property to write out.</param>
/// <param name="owningType">The owning type for the <paramref name="property"/> or null if no metadata is available.</param>
/// <param name="isTopLevel">true if writing a top-level property payload; otherwise false.</param>
/// <param name="isWritingCollection">true if we are writing a top-level collection instead of an entry.</param>
/// <param name="beforePropertyAction">Action which is called before the property is written, if it's going to be written.</param>
/// <param name="duplicatePropertyNamesChecker">The checker instance for duplicate property names.</param>
/// <param name="projectedProperties">Set of projected properties, or null if all properties should be written.</param>
/// <returns>true if the property was actually written, false otherwise.</returns>
private bool WriteProperty(
ODataProperty property,
IEdmStructuredType owningType,
bool isTopLevel,
bool isWritingCollection,
Action beforePropertyAction,
DuplicatePropertyNamesChecker duplicatePropertyNamesChecker,
ProjectedPropertiesAnnotation projectedProperties)
{
WriterValidationUtils.ValidatePropertyNotNull(property);
object value = property.Value;
string propertyName = property.Name;
//// TODO: If we implement type conversions the value needs to be converted here
//// since the next method call needs to know if the value is a string or not in some cases.
ODataComplexValue complexValue = value as ODataComplexValue;
ProjectedPropertiesAnnotation complexValueProjectedProperties = null;
if (!ShouldWritePropertyInContent(projectedProperties, propertyName))
{
return(false);
}
WriterValidationUtils.ValidatePropertyName(propertyName);
duplicatePropertyNamesChecker.CheckForDuplicatePropertyNames(property);
IEdmProperty edmProperty = WriterValidationUtils.ValidatePropertyDefined(propertyName, owningType);
IEdmTypeReference propertyTypeReference = edmProperty == null ? null : edmProperty.Type;
if (value is ODataStreamReferenceValue)
{
throw new ODataException(ODataErrorStrings.ODataWriter_StreamPropertiesMustBePropertiesOfODataEntry(propertyName));
}
// Null property value.
if (value == null)
{
this.WriteNullPropertyValue(propertyTypeReference, propertyName, isTopLevel, isWritingCollection, beforePropertyAction);
return(true);
}
bool isOpenPropertyType = owningType != null && owningType.IsOpen && propertyTypeReference == null;
if (isOpenPropertyType)
{
ValidationUtils.ValidateOpenPropertyValue(propertyName, value);
}
if (complexValue != null)
{
return(this.WriteComplexValueProperty(
complexValue,
propertyName,
isTopLevel,
isWritingCollection,
beforePropertyAction,
propertyTypeReference,
isOpenPropertyType,
complexValueProjectedProperties));
}
ODataCollectionValue collectionValue = value as ODataCollectionValue;
if (collectionValue != null)
{
this.WriteCollectionValueProperty(
collectionValue,
propertyName,
isTopLevel,
isWritingCollection,
beforePropertyAction,
propertyTypeReference,
isOpenPropertyType);
return(true);
}
// If the value isn't one of the value types tested for already, it must be a non-null primitive or enum type.
this.WritePropertyStart(beforePropertyAction, property, isWritingCollection, isTopLevel);
SerializationTypeNameAnnotation serializationTypeNameAnnotation = property.ODataValue.GetAnnotation <SerializationTypeNameAnnotation>();
ODataEnumValue enumValue = value as ODataEnumValue;
if (enumValue != null)
{
this.WriteEnumValue(enumValue, /*collectionValidator*/ null, propertyTypeReference, serializationTypeNameAnnotation);
}
else
{
this.WritePrimitiveValue(value, /*collectionValidator*/ null, propertyTypeReference, serializationTypeNameAnnotation);
}
this.WritePropertyEnd();
return(true);
}
private string ConvertToEscapedUriValue(string paramName, object value)
{
Debug.Assert(!string.IsNullOrEmpty(paramName), "!string.IsNullOrEmpty(paramName)");
Object valueInODataFormat = null;
// Literal values with single quotes need special escaping due to System.Uri changes in behavior between .NET 4.0 and 4.5.
// We need to ensure that our escaped values do not change between those versions, so we need to escape values differently when they could contain single quotes.
bool needsSpecialEscaping = false;
if (value == null)
{
needsSpecialEscaping = true;
}
else
{
if (value.GetType() == typeof(ODataUriNullValue))
{
valueInODataFormat = value;
needsSpecialEscaping = true;
}
else
{
ClientEdmModel model = this.requestInfo.Model;
IEdmType edmType = model.GetOrCreateEdmType(value.GetType());
Debug.Assert(edmType != null, "edmType != null");
switch (edmType.TypeKind)
{
case EdmTypeKind.Primitive:
valueInODataFormat = value;
needsSpecialEscaping = true;
break;
case EdmTypeKind.Complex:
ClientTypeAnnotation typeAnnotation = model.GetClientTypeAnnotation(edmType);
Debug.Assert(typeAnnotation != null, "typeAnnotation != null");
valueInODataFormat = this.propertyConverter.CreateODataComplexValue(
typeAnnotation.ElementType,
value,
null /*propertyName*/,
false /*isCollectionItemType*/,
null /*visitedComplexTypeObjects*/);
// When using JsonVerbose to format query string parameters for Actions,
// we cannot write out Complex values in the URI without the type name of the complex type in the JSON payload.
// If this value is null, the client has to set the ResolveName property on the DataServiceContext instance.
ODataComplexValue complexValue = (ODataComplexValue)valueInODataFormat;
SerializationTypeNameAnnotation serializedTypeNameAnnotation = complexValue.GetAnnotation <SerializationTypeNameAnnotation>();
if (serializedTypeNameAnnotation == null || string.IsNullOrEmpty(serializedTypeNameAnnotation.TypeName))
{
throw Error.InvalidOperation(Strings.DataServiceException_GeneralError);
}
break;
case EdmTypeKind.Collection:
IEdmCollectionType edmCollectionType = edmType as IEdmCollectionType;
Debug.Assert(edmCollectionType != null, "edmCollectionType != null");
IEdmTypeReference itemTypeReference = edmCollectionType.ElementType;
Debug.Assert(itemTypeReference != null, "itemTypeReference != null");
ClientTypeAnnotation itemTypeAnnotation = model.GetClientTypeAnnotation(itemTypeReference.Definition);
Debug.Assert(itemTypeAnnotation != null, "itemTypeAnnotation != null");
switch (itemTypeAnnotation.EdmType.TypeKind)
{
// We only support primitive or complex type as a collection item type.
case EdmTypeKind.Primitive:
case EdmTypeKind.Complex:
break;
default:
throw new NotSupportedException(Strings.Serializer_InvalidCollectionParamterItemType(paramName, itemTypeAnnotation.EdmType.TypeKind));
}
valueInODataFormat = this.propertyConverter.CreateODataCollection(
itemTypeAnnotation.ElementType,
null /*propertyName*/,
value,
null /*visitedComplexTypeObjects*/);
break;
default:
// EdmTypeKind.Entity
// EdmTypeKind.Row
// EdmTypeKind.EntityReference
// EdmTypeKind.Enum.
throw new NotSupportedException(Strings.Serializer_InvalidParameterType(paramName, edmType.TypeKind));
}
}
Debug.Assert(valueInODataFormat != null, "valueInODataFormat != null");
}
// In the released WCF Data Services 5.0, we didn't pass the model for JSON Verbose literals, so continuing that behavior for backward compatibility
ODataFormat literalFormat = this.requestInfo.Format.UriLiteralFormat;
IEdmModel edmModel = literalFormat == ODataFormat.VerboseJson ? null : this.requestInfo.Model;
// ODL can handle null values so we can send null values here.
string literal = ODataUriUtils.ConvertToUriLiteral(valueInODataFormat, CommonUtil.ConvertToODataVersion(this.requestInfo.MaxProtocolVersionAsVersion), edmModel, literalFormat);
// The value from ConvertToUriValue will not be escaped, but will already contain literal delimiters like single quotes, so we
// need to use our own escape method that will preserve those characters instead of directly calling Uri.EscapeDataString that may escape them.
// This is only necessary for primitives and nulls because the other structures are serialized using the JSON format and it uses double quotes
// which have always been escaped.
if (needsSpecialEscaping)
{
return(DataStringEscapeBuilder.EscapeDataString(literal));
}
return(Uri.EscapeDataString(literal));
}
void IODataSerializationFeature.Apply(ODataComplexValue complexValue, ODataSerializationFeatureContext context)
{
Contract.Requires <ArgumentNullException>(complexValue != null, nameof(complexValue));
Contract.Requires <ArgumentNullException>(context != null, nameof(context));
}
/// <summary>
/// Creates an <see cref="ODataComplexValue"/> for the object represented by <paramref name="graph"/>.
/// </summary>
/// <param name="graph">The value of the <see cref="ODataComplexValue"/> to be created.</param>
/// <param name="complexType">The EDM complex type of the object.</param>
/// <param name="writeContext">The serializer context.</param>
/// <returns>The created <see cref="ODataComplexValue"/>.</returns>
public virtual ODataComplexValue CreateODataComplexValue(object graph, IEdmComplexTypeReference complexType,
ODataSerializerContext writeContext)
{
if (writeContext == null)
{
throw Error.ArgumentNull("writeContext");
}
if (graph == null || graph is NullEdmComplexObject)
{
return(null);
}
IEdmComplexObject complexObject = graph as IEdmComplexObject ?? new TypedEdmComplexObject(graph, complexType, writeContext.Model);
List <ODataProperty> propertyCollection = new List <ODataProperty>();
foreach (IEdmProperty property in complexType.ComplexDefinition().Properties())
{
IEdmTypeReference propertyType = property.Type;
ODataEdmTypeSerializer propertySerializer = SerializerProvider.GetEdmTypeSerializer(propertyType);
if (propertySerializer == null)
{
throw Error.NotSupported(SRResources.TypeCannotBeSerialized, propertyType.FullName(), typeof(ODataMediaTypeFormatter).Name);
}
object propertyValue;
if (complexObject.TryGetPropertyValue(property.Name, out propertyValue))
{
if (propertyValue != null && propertyType != null && propertyType.IsComplex())
{
IEdmTypeReference actualType = writeContext.GetEdmType(propertyValue, propertyValue.GetType());
if (actualType != null && propertyType != actualType)
{
propertyType = actualType;
}
}
var odataProperty = propertySerializer.CreateProperty(propertyValue, propertyType, property.Name,
writeContext);
if (odataProperty != null)
{
propertyCollection.Add(odataProperty);
}
}
}
// Try to add the dynamic properties if the complex type is open.
if (complexType.ComplexDefinition().IsOpen)
{
List <ODataProperty> dynamicProperties =
AppendDynamicProperties(complexObject, complexType, writeContext, propertyCollection, new string[0]);
if (dynamicProperties != null)
{
propertyCollection.AddRange(dynamicProperties);
}
}
string typeName = complexType.FullName();
ODataComplexValue value = new ODataComplexValue()
{
Properties = propertyCollection,
TypeName = typeName
};
AddTypeNameAnnotationAsNeeded(value, writeContext.MetadataLevel);
return(value);
}
public void SerializeTopLevelPropertyOfCollectionTypeShouldWork()
{
EdmModel model = new EdmModel();
EdmComplexType complexType = new EdmComplexType("ns", "complex");
complexType.AddProperty(new EdmStructuralProperty(complexType, "propertyName1", EdmCoreModel.Instance.GetInt32(isNullable: false)));
complexType.AddProperty(new EdmStructuralProperty(complexType, "propertyName2", EdmCoreModel.Instance.GetString(isNullable: false)));
model.AddElement(complexType);
ODataCollectionValue primitiveCollectionValue = new ODataCollectionValue { Items = new[] { "value1", "value2" }};
primitiveCollectionValue.TypeName = "Collection(Edm.String)";
ODataProperty primitiveCollectionProperty = new ODataProperty { Name = "PrimitiveCollectionProperty", Value = primitiveCollectionValue };
string pval = SerializeProperty(model, primitiveCollectionProperty);
pval.Should().Be("<?xml version=\"1.0\" encoding=\"utf-8\"?><m:value xmlns:d=\"http://docs.oasis-open.org/odata/ns/data\" xmlns:georss=\"http://www.georss.org/georss\" xmlns:gml=\"http://www.opengis.net/gml\" m:context=\"http://odata.org/$metadata#Collection(Edm.String)\" m:type=\"#Collection(String)\" xmlns:m=\"http://docs.oasis-open.org/odata/ns/metadata\"><m:element>value1</m:element><m:element>value2</m:element></m:value>");
ODataComplexValue complexValue1 = new ODataComplexValue { Properties = new[] { new ODataProperty { Name = "propertyName1", Value = 1 }, new ODataProperty { Name = "propertyName2", Value = "stringValue" } }, TypeName = "ns.complex" };
ODataComplexValue complexValue2 = new ODataComplexValue { Properties = new[] { new ODataProperty { Name = "propertyName1", Value = 1 }, new ODataProperty { Name = "propertyName2", Value = "stringValue" } }, TypeName = "ns.complex" };
ODataCollectionValue complexCollectionValue = new ODataCollectionValue { Items = new[] { complexValue1, complexValue2 }, TypeName = "Collection(ns.complex)" };
ODataProperty complexCollectionProperty = new ODataProperty { Name = "ComplexCollectionProperty", Value = complexCollectionValue };
string cval = SerializeProperty(model, complexCollectionProperty);
cval.Should().Be("<?xml version=\"1.0\" encoding=\"utf-8\"?><m:value xmlns:d=\"http://docs.oasis-open.org/odata/ns/data\" xmlns:georss=\"http://www.georss.org/georss\" xmlns:gml=\"http://www.opengis.net/gml\" m:context=\"http://odata.org/$metadata#Collection(ns.complex)\" m:type=\"#Collection(ns.complex)\" xmlns:m=\"http://docs.oasis-open.org/odata/ns/metadata\"><m:element><d:propertyName1 m:type=\"Int32\">1</d:propertyName1><d:propertyName2>stringValue</d:propertyName2></m:element><m:element><d:propertyName1 m:type=\"Int32\">1</d:propertyName1><d:propertyName2>stringValue</d:propertyName2></m:element></m:value>");
}
/// <summary>Applies a data value to the specified <paramref name="instance"/>.</summary>
/// <param name="type">Type to which a property value will be applied.</param>
/// <param name="property">Property with value to apply.</param>
/// <param name="instance">Instance on which value will be applied.</param>
internal void ApplyDataValue(ClientTypeAnnotation type, ODataProperty property, object instance)
{
Debug.Assert(type != null, "type != null");
Debug.Assert(property != null, "property != null");
Debug.Assert(instance != null, "instance != null");
var prop = type.GetProperty(property.Name, this.MaterializerContext.IgnoreMissingProperties);
if (prop == null)
{
return;
}
// Is it a collection? (note: property.Properties will be null if the Collection is empty (contains no elements))
Type enumTypeTmp = null;
if (prop.IsPrimitiveOrEnumOrComplexCollection)
{
// Collections must not be null
if (property.Value == null)
{
throw DSClient.Error.InvalidOperation(DSClient.Strings.Collection_NullCollectionNotSupported(property.Name));
}
// This happens if the payload contain just primitive value for a Collection property
if (property.Value is string)
{
throw DSClient.Error.InvalidOperation(DSClient.Strings.Deserialize_MixedTextWithComment);
}
if (property.Value is ODataComplexValue)
{
throw DSClient.Error.InvalidOperation(DSClient.Strings.AtomMaterializer_InvalidCollectionItem(property.Name));
}
// ODataLib already parsed the data and materialized all the primitive types. There is nothing more to materialize
// anymore. Only complex type instance and collection instances need to be materialized, but those will be
// materialized later on.
// We need to materialize items before we change collectionInstance since this may throw. If we tried materializing
// after the Collection is wiped or created we would leave the object in half constructed state.
object collectionInstance = prop.GetValue(instance);
if (collectionInstance == null)
{
collectionInstance = this.CollectionValueMaterializationPolicy.CreateCollectionPropertyInstance(property, prop.PropertyType);
// allowAdd is false - we need to assign instance as the new property value
prop.SetValue(instance, collectionInstance, property.Name, false /* allowAdd? */);
}
else
{
// Clear existing Collection
prop.ClearBackingICollectionInstance(collectionInstance);
}
bool isElementNullable = prop.EdmProperty.Type.AsCollection().ElementType().IsNullable;
this.CollectionValueMaterializationPolicy.ApplyCollectionDataValues(
property,
collectionInstance,
prop.PrimitiveOrComplexCollectionItemType,
prop.AddValueToBackingICollectionInstance,
isElementNullable);
}
else if ((enumTypeTmp = Nullable.GetUnderlyingType(prop.NullablePropertyType) ?? prop.NullablePropertyType) != null &&
enumTypeTmp.IsEnum())
{
ODataEnumValue enumValue = property.Value as ODataEnumValue;
object tmpValue = EnumValueMaterializationPolicy.MaterializeODataEnumValue(enumTypeTmp, enumValue);
// TODO: 1. use EnumValueMaterializationPolicy 2. handle nullable enum property
prop.SetValue(instance, tmpValue, property.Name, false /* allowAdd? */);
}
else
{
object propertyValue = property.Value;
ODataComplexValue complexValue = propertyValue as ODataComplexValue;
if (propertyValue != null && complexValue != null)
{
if (!prop.EdmProperty.Type.IsComplex())
{
// The error message is a bit odd, but it's compatible with V1.
throw DSClient.Error.InvalidOperation(DSClient.Strings.Deserialize_ExpectingSimpleValue);
}
// Complex type.
bool needToSet = false;
ClientEdmModel edmModel = this.MaterializerContext.Model;
ClientTypeAnnotation complexType = edmModel.GetClientTypeAnnotation(edmModel.GetOrCreateEdmType(prop.PropertyType));
object complexInstance = prop.GetValue(instance);
// Validating property inheritance in complexvalue and instance
if (prop.PropertyType.Name != property.Name)
{
complexType = this.MaterializerContext.ResolveTypeForMaterialization(prop.PropertyType, complexValue.TypeName);
// recreate complexInstance with derived type
complexInstance = null;
}
if (complexValue.Properties.Any() || complexInstance == null)
{
complexInstance = this.CreateNewInstance(complexType.EdmTypeReference, complexType.ElementType);
needToSet = true;
}
this.MaterializeDataValues(complexType, complexValue.Properties, this.MaterializerContext.IgnoreMissingProperties);
this.ApplyDataValues(complexType, complexValue.Properties, complexInstance);
if (needToSet)
{
prop.SetValue(instance, complexInstance, property.Name, true /* allowAdd? */);
}
// Set instance annotation for this complex instance
this.InstanceAnnotationMaterializationPolicy.SetInstanceAnnotations(property, complexInstance);
}
else
{
this.MaterializePrimitiveDataValue(prop.NullablePropertyType, property);
prop.SetValue(instance, property.GetMaterializedValue(), property.Name, true /* allowAdd? */);
}
}
// Apply instance annotation for Property
this.InstanceAnnotationMaterializationPolicy.SetInstanceAnnotations(property, type.ElementType, instance);
}
/// <summary>
/// Writes out the value of a complex property.
/// </summary>
/// <param name="jsonWriter">The <see cref="JsonWriter"/> to write to.</param>
/// <param name="metadata">The metadata provider to use or null if no metadata is available.</param>
/// <param name="complexValue">The complex value to write.</param>
/// <param name="resourcePropertyType">The metadata type for the complex value.</param>
/// <param name="isOpenPropertyType">True if the type name belongs to an open property.</param>
/// <param name="version">The protocol version used for writing.</param>
internal static void WriteComplexValue(
JsonWriter jsonWriter,
DataServiceMetadataProviderWrapper metadata,
ODataComplexValue complexValue,
ResourceType resourcePropertyType,
bool isOpenPropertyType,
ODataVersion version)
{
DebugUtils.CheckNoExternalCallers();
Debug.Assert(complexValue != null, "complexValue != null");
// Start the object scope which will represent the entire complex instance
jsonWriter.StartObjectScope();
// Write the "__metadata" : { "type": "typename" }
// But only if we actually have a typename to write, otherwise we need the __metadata to be omitted entirely
string typeName = complexValue.TypeName;
// resolve the type name to the resource type; if no type name is specified we will use the
// type inferred from metadata
ResourceType complexValueType = MetadataUtils.ResolveTypeName(metadata, resourcePropertyType, ref typeName, ResourceTypeKind.ComplexType, isOpenPropertyType);
if (typeName != null)
{
// Write the __metadata object
jsonWriter.WriteName(JsonConstants.ODataMetadataName);
jsonWriter.StartObjectScope();
// "type": "typename"
jsonWriter.WriteName(JsonConstants.ODataMetadataTypeName);
jsonWriter.WriteValue(typeName);
// End the __metadata
jsonWriter.EndObjectScope();
}
// Write the properties of the complex value as usual
WriteProperties(jsonWriter, metadata, complexValueType, complexValue.Properties, version);
// End the object scope which represents the complex instance
jsonWriter.EndObjectScope();
}
public void ComplexCustomInstanceAnnotationOnErrorShouldRoundtrip()
{
var originalComplexValue = new ODataComplexValue
{
TypeName = "ns.ErrorDetails",
Properties = new[] { new ODataProperty { Name = "ErrorDetailName", Value = "inner property value" } }
};
var original = new KeyValuePair<string, ODataValue>("sample.error", originalComplexValue);
var error = this.WriteThenReadErrorWithInstanceAnnotation(original);
var annotation = RunBasicVerificationAndGetAnnotationValue("sample.error", error);
annotation.Should().BeOfType<ODataComplexValue>();
annotation.As<ODataComplexValue>().Properties.First().Value.Should().Be("inner property value");
}
public void BuildPropertyContextUriForComplexPropertyValueWithNonNullAnnotation()
{
ODataComplexValue value = new ODataComplexValue { TypeName = "FQNS.FromObject" };
value.SetAnnotation(new SerializationTypeNameAnnotation { TypeName = "FQNS.FromAnnotation" });
var contextUri = this.CreatePropertyContextUri(value);
contextUri.OriginalString.Should().Be(BuildExpectedContextUri("#FQNS.FromAnnotation"));
}
/// <summary>
/// Writes out the value of a complex property.
/// </summary>
/// <param name="writer">The <see cref="XmlWriter"/> to write to.</param>
/// <param name="metadata">The metadata provider to use or null if no metadata is available.</param>
/// <param name="complexValue">The complex value to write.</param>
/// <param name="metadataType">The metadata type for the complex value.</param>
/// <param name="isOpenPropertyType">True if the type name belongs to an open property.</param>
/// <param name="isWritingCollection">True if we are writing a collection instead of an entry.</param>
/// <param name="version">The protocol version used for writing.</param>
/// <param name="epmValueCache">Cache of values used in EPM so that we avoid multiple enumerations of properties/items. (can be null)</param>
/// <param name="epmSourcePathSegment">The EPM source path segment which points to the property we're writing. (can be null)</param>
internal static void WriteComplexValue(
XmlWriter writer,
DataServiceMetadataProviderWrapper metadata,
ODataComplexValue complexValue,
ResourceType metadataType,
bool isOpenPropertyType,
bool isWritingCollection,
ODataVersion version,
EpmValueCache epmValueCache,
EpmSourcePathSegment epmSourcePathSegment)
{
DebugUtils.CheckNoExternalCallers();
Debug.Assert(complexValue != null, "complexValue != null");
string typeName = complexValue.TypeName;
// resolve the type name to the resource type; if no type name is specified we will use the
// type inferred from metadata
ResourceType complexValueType = MetadataUtils.ResolveTypeName(metadata, metadataType, ref typeName, ResourceTypeKind.ComplexType, isOpenPropertyType);
if (typeName != null)
{
WritePropertyTypeAttribute(writer, typeName);
}
WriteProperties(
writer,
metadata,
complexValueType,
EpmValueCache.GetComplexValueProperties(epmValueCache, epmSourcePathSegment, complexValue, true),
version,
isWritingCollection,
epmValueCache,
epmSourcePathSegment);
}
public void WriteTopLevelErrorWithComplexInstanceAnnotationNoTypeNameShouldThrow()
{
SetupSerializerAndRunTest(null, serializer =>
{
ODataError error = new ODataError();
var instanceAnnotations = new Collection<ODataInstanceAnnotation>();
var complexValue = new ODataComplexValue();
ODataInstanceAnnotation annotation = new ODataInstanceAnnotation("sample.complex", complexValue);
instanceAnnotations.Add(annotation);
error.InstanceAnnotations = instanceAnnotations;
Action writeError = () => serializer.WriteTopLevelError(error, false);
writeError.ShouldThrow<ODataException>().WithMessage(Strings.WriterValidationUtils_MissingTypeNameWithMetadata);
});
}
public void ValueWithTypeNameAnnotationShouldReturnTypeNameFromAnnotation()
{
var complexValue = new ODataComplexValue() { TypeName = ComplexTypeName };
complexValue.SetAnnotation(new SerializationTypeNameAnnotation { TypeName = "TypeNameFromSTNA" });
this.testSubject.GetValueTypeNameForWriting(
complexValue,
complexTypeReference,
complexTypeReference,
/*isOpen*/ false)
.Should().Be("TypeNameFromSTNA");
}
private void VerifyComplexTypeRoundtrip(ODataComplexValue value, string typeName)
{
var typeReference = new EdmComplexTypeReference((IEdmComplexType)model.FindType(typeName), true);
MemoryStream stream = new MemoryStream();
using (ODataAtomOutputContext outputContext = new ODataAtomOutputContext(
ODataFormat.Atom,
new NonDisposingStream(stream),
Encoding.UTF8,
new ODataMessageWriterSettings() { Version = ODataVersion.V4 },
/*writingResponse*/ true,
/*synchronous*/ true,
model,
/*urlResolver*/ null))
{
ODataAtomPropertyAndValueSerializer serializer = new ODataAtomPropertyAndValueSerializer(outputContext);
serializer.XmlWriter.WriteStartElement("ValueElement");
serializer.WriteComplexValue(
value,
typeReference,
/*isOpenPropertyType*/ false,
/*isWritingCollection*/ false,
/*beforeValueAction*/ null,
/*afterValueAction*/ null,
new DuplicatePropertyNamesChecker(false, false),
/*collectionValidator*/ null,
/*projectedProperties*/ null);
serializer.XmlWriter.WriteEndElement();
}
stream.Position = 0;
object actualValue;
using (ODataAtomInputContext inputContext = new ODataAtomInputContext(
ODataFormat.Atom,
stream,
Encoding.UTF8,
new ODataMessageReaderSettings(),
/*readingResponse*/ true,
/*synchronous*/ true,
model,
/*urlResolver*/ null))
{
ODataAtomPropertyAndValueDeserializer deserializer = new ODataAtomPropertyAndValueDeserializer(inputContext);
deserializer.XmlReader.MoveToContent();
actualValue = deserializer.ReadNonEntityValue(
typeReference,
/*duplicatePropertyNamesChecker*/ null,
/*collectionValidator*/ null,
/*validateNullValue*/ true);
}
TestUtils.AssertODataValueAreEqual(actualValue as ODataValue, value);
}
public void WriteComplexValue(
ODataComplexValue complexValue,
IEdmTypeReference metadataTypeReference,
bool isTopLevel,
bool isOpenPropertyType,
DuplicatePropertyNamesChecker duplicatePropertyNamesChecker)
{
Debug.Assert(complexValue != null, "complexValue != null");
this.IncreaseRecursionDepth();
// Start the object scope which will represent the entire complex instance;
// for top-level complex properties we already wrote the object scope (and the context URI when needed).
if (!isTopLevel)
{
this.JsonWriter.StartObjectScope();
}
string typeName = complexValue.TypeName;
if (isTopLevel)
{
Debug.Assert(metadataTypeReference == null, "Never expect a metadata type for top-level properties.");
if (typeName == null)
{
throw new ODataException(ODataErrorStrings.ODataJsonLightValueSerializer_MissingTypeNameOnComplex);
}
}
else
{
// In requests, we allow the property type reference to be null if the type name is specified in the OM
if (metadataTypeReference == null && !this.WritingResponse && typeName == null && this.Model.IsUserModel())
{
throw new ODataException(ODataErrorStrings.ODataJsonLightPropertyAndValueSerializer_NoExpectedTypeOrTypeNameSpecifiedForComplexValueRequest);
}
}
// Resolve the type name to the type; if no type name is specified we will use the
// type inferred from metadata.
IEdmComplexTypeReference complexValueTypeReference = (IEdmComplexTypeReference)TypeNameOracle.ResolveAndValidateTypeNameForValue(this.Model, metadataTypeReference, complexValue, isOpenPropertyType);
Debug.Assert(
metadataTypeReference == null || complexValueTypeReference == null || EdmLibraryExtensions.IsAssignableFrom(metadataTypeReference, complexValueTypeReference),
"Complex property types must be the same as or inherit from the ones from metadata (unless open).");
typeName = this.JsonLightOutputContext.TypeNameOracle.GetValueTypeNameForWriting(complexValue, metadataTypeReference, complexValueTypeReference, isOpenPropertyType);
if (typeName != null)
{
this.ODataAnnotationWriter.WriteODataTypeInstanceAnnotation(typeName);
}
// Write custom instance annotations
this.InstanceAnnotationWriter.WriteInstanceAnnotations(complexValue.InstanceAnnotations);
// Write the properties of the complex value as usual. Note we do not allow complex types to contain named stream properties.
this.PropertySerializer.WriteProperties(
complexValueTypeReference == null ? null : complexValueTypeReference.ComplexDefinition(),
complexValue.Properties,
true /* isComplexValue */,
duplicatePropertyNamesChecker,
null /*projectedProperties */);
// End the object scope which represents the complex instance;
// for top-level complex properties we already wrote the end object scope.
if (!isTopLevel)
{
this.JsonWriter.EndObjectScope();
}
this.DecreaseRecursionDepth();
}
public void ReadComplexValue_CanReadDynamicPropertiesForOpenComplexType()
{
// Arrange
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.ComplexType <SimpleOpenAddress>();
builder.EnumType <SimpleEnum>();
IEdmModel model = builder.GetEdmModel();
IEdmComplexTypeReference addressTypeReference = model.GetEdmTypeReference(typeof(SimpleOpenAddress)).AsComplex();
var deserializerProvider = new Mock <ODataDeserializerProvider>().Object;
var deserializer = new ODataComplexTypeDeserializer(deserializerProvider);
ODataEnumValue enumValue = new ODataEnumValue("Third", typeof(SimpleEnum).FullName);
ODataComplexValue complexValue = new ODataComplexValue
{
Properties = new[]
{
// declared properties
new ODataProperty {
Name = "Street", Value = "My Way #599"
},
new ODataProperty {
Name = "City", Value = "Redmond & Shanghai"
},
// dynamic properties
new ODataProperty {
Name = "GuidProperty", Value = new Guid("181D3A20-B41A-489F-9F15-F91F0F6C9ECA")
},
new ODataProperty {
Name = "EnumValue", Value = enumValue
},
new ODataProperty {
Name = "DateTimeProperty", Value = new DateTimeOffset(new DateTime(1992, 1, 1))
}
},
TypeName = typeof(SimpleOpenAddress).FullName
};
ODataDeserializerContext readContext = new ODataDeserializerContext()
{
Model = model
};
// Act
SimpleOpenAddress address = deserializer.ReadComplexValue(complexValue, addressTypeReference, readContext)
as SimpleOpenAddress;
// Assert
Assert.NotNull(address);
// Verify the declared properties
Assert.Equal("My Way #599", address.Street);
Assert.Equal("Redmond & Shanghai", address.City);
// Verify the dynamic properties
Assert.NotNull(address.Properties);
Assert.Equal(3, address.Properties.Count());
Assert.Equal(new Guid("181D3A20-B41A-489F-9F15-F91F0F6C9ECA"), address.Properties["GuidProperty"]);
Assert.Equal(SimpleEnum.Third, address.Properties["EnumValue"]);
Assert.Equal(new DateTimeOffset(new DateTime(1992, 1, 1)), address.Properties["DateTimeProperty"]);
}
private static void AssertODataComplexValueAreEqual(ODataComplexValue expectedComplexValue, ODataComplexValue actualComplexValue)
{
Assert.IsNotNull(expectedComplexValue);
Assert.IsNotNull(actualComplexValue);
Assert.AreEqual(expectedComplexValue.TypeName, actualComplexValue.TypeName);
AssertODataPropertiesAreEqual(expectedComplexValue.Properties, actualComplexValue.Properties);
}
public void ReadComplexValue_CanReadNestedOpenComplexType()
{
// Arrange
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.ComplexType <SimpleOpenAddress>();
builder.ComplexType <SimpleOpenZipCode>();
IEdmModel model = builder.GetEdmModel();
IEdmComplexTypeReference addressTypeReference = model.GetEdmTypeReference(typeof(SimpleOpenAddress)).AsComplex();
var deserializerProvider = new DefaultODataDeserializerProvider();
var deserializer = new ODataComplexTypeDeserializer(deserializerProvider);
ODataComplexValue zipCodeComplexValue = new ODataComplexValue
{
Properties = new[]
{
// declared property
new ODataProperty {
Name = "Code", Value = 101
},
// dynamic property
new ODataProperty {
Name = "DateTimeProperty", Value = new DateTimeOffset(new DateTime(2014, 4, 22))
}
},
TypeName = typeof(SimpleOpenZipCode).FullName
};
ODataComplexValue addressComplexValue = new ODataComplexValue
{
Properties = new[]
{
// declared properties
new ODataProperty {
Name = "Street", Value = "TopStreet"
},
new ODataProperty {
Name = "City", Value = "TopCity"
},
// dynamic properties
new ODataProperty {
Name = "DoubleProperty", Value = 1.179
},
new ODataProperty {
Name = "ZipCodeProperty", Value = zipCodeComplexValue
}
},
TypeName = typeof(SimpleOpenAddress).FullName
};
ODataDeserializerContext readContext = new ODataDeserializerContext()
{
Model = model
};
// Act
SimpleOpenAddress address = deserializer.ReadComplexValue(addressComplexValue, addressTypeReference, readContext)
as SimpleOpenAddress;
// Assert
Assert.NotNull(address);
// Verify the declared properties
Assert.Equal("TopStreet", address.Street);
Assert.Equal("TopCity", address.City);
// Verify the dynamic properties
Assert.NotNull(address.Properties);
Assert.Equal(2, address.Properties.Count());
Assert.Equal(1.179, address.Properties["DoubleProperty"]);
// nested open complex type
SimpleOpenZipCode zipCode = Assert.IsType <SimpleOpenZipCode>(address.Properties["ZipCodeProperty"]);
Assert.Equal(101, zipCode.Code);
Assert.Equal(1, zipCode.Properties.Count());
Assert.Equal(new DateTimeOffset(new DateTime(2014, 4, 22)), zipCode.Properties["DateTimeProperty"]);
}
public void ReadComplexValue_CanReadDynamicCollectionPropertiesForOpenComplexType()
{
// Arrange
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.ComplexType <SimpleOpenAddress>();
builder.EnumType <SimpleEnum>();
IEdmModel model = builder.GetEdmModel();
IEdmComplexTypeReference addressTypeReference =
model.GetEdmTypeReference(typeof(SimpleOpenAddress)).AsComplex();
var deserializerProvider = new DefaultODataDeserializerProvider();
var deserializer = new ODataComplexTypeDeserializer(deserializerProvider);
ODataEnumValue enumValue = new ODataEnumValue("Third", typeof(SimpleEnum).FullName);
ODataCollectionValue collectionValue = new ODataCollectionValue
{
TypeName = "Collection(" + typeof(SimpleEnum).FullName + ")",
Items = new[] { enumValue, enumValue }
};
ODataComplexValue complexValue = new ODataComplexValue
{
Properties = new[]
{
// declared properties
new ODataProperty {
Name = "Street", Value = "My Way #599"
},
// dynamic properties
new ODataProperty {
Name = "CollectionProperty", Value = collectionValue
}
},
TypeName = typeof(SimpleOpenAddress).FullName
};
ODataDeserializerContext readContext = new ODataDeserializerContext()
{
Model = model
};
// Act
SimpleOpenAddress address = deserializer.ReadComplexValue(complexValue, addressTypeReference, readContext)
as SimpleOpenAddress;
// Assert
Assert.NotNull(address);
// Verify the declared properties
Assert.Equal("My Way #599", address.Street);
Assert.Null(address.City);
// Verify the dynamic properties
Assert.NotNull(address.Properties);
Assert.Equal(1, address.Properties.Count());
var collectionValues = Assert.IsType <List <SimpleEnum> >(address.Properties["CollectionProperty"]);
Assert.NotNull(collectionValues);
Assert.Equal(2, collectionValues.Count());
Assert.Equal(SimpleEnum.Third, collectionValues[0]);
Assert.Equal(SimpleEnum.Third, collectionValues[1]);
}
/// <summary>
/// Reads a complex value.
/// </summary>
/// <param name="complexValueTypeReference">The expected type reference of the value.</param>
/// <param name="payloadTypeName">The type name read from the payload.</param>
/// <param name="serializationTypeNameAnnotation">The serialization type name for the collection value (possibly null).</param>
/// <param name="duplicatePropertyNamesChecker">The duplicate property names checker to use - this is always initialized as necessary, do not clear.</param>
/// <returns>The value of the complex value.</returns>
/// <remarks>
/// Pre-Condition: JsonNodeType.Property - the first property of the complex value object, or the second one if the first one was odata.type.
/// JsonNodeType.EndObject - the end object of the complex value object.
/// Post-Condition: almost anything - the node after the complex value (after the EndObject)
/// </remarks>
private ODataComplexValue ReadComplexValue(
IEdmComplexTypeReference complexValueTypeReference,
string payloadTypeName,
SerializationTypeNameAnnotation serializationTypeNameAnnotation,
DuplicatePropertyNamesChecker duplicatePropertyNamesChecker)
{
this.AssertJsonCondition(JsonNodeType.Property, JsonNodeType.EndObject);
Debug.Assert(duplicatePropertyNamesChecker != null, "duplicatePropertyNamesChecker != null");
this.IncreaseRecursionDepth();
ODataComplexValue complexValue = new ODataComplexValue();
complexValue.TypeName = complexValueTypeReference != null ? complexValueTypeReference.FullName() : payloadTypeName;
if (serializationTypeNameAnnotation != null)
{
complexValue.SetAnnotation(serializationTypeNameAnnotation);
}
if (complexValueTypeReference != null)
{
complexValue.SetAnnotation(new ODataTypeAnnotation(complexValueTypeReference));
}
List<ODataProperty> properties = new List<ODataProperty>();
while (this.JsonReader.NodeType == JsonNodeType.Property)
{
this.ReadPropertyCustomAnnotationValue = this.ReadCustomInstanceAnnotationValue;
this.ProcessProperty(
duplicatePropertyNamesChecker,
this.ReadTypePropertyAnnotationValue,
(propertyParsingResult, propertyName) =>
{
switch (propertyParsingResult)
{
case PropertyParsingResult.ODataInstanceAnnotation:
if (string.CompareOrdinal(ODataAnnotationNames.ODataType, propertyName) == 0)
{
throw new ODataException(ODataErrorStrings.ODataJsonLightPropertyAndValueDeserializer_ComplexTypeAnnotationNotFirst);
}
else
{
throw new ODataException(ODataErrorStrings.ODataJsonLightPropertyAndValueDeserializer_UnexpectedAnnotationProperties(propertyName));
}
case PropertyParsingResult.CustomInstanceAnnotation:
ODataAnnotationNames.ValidateIsCustomAnnotationName(propertyName);
Debug.Assert(
!this.MessageReaderSettings.ShouldSkipAnnotation(propertyName),
"!this.MessageReaderSettings.ShouldReadAndValidateAnnotation(annotationName) -- otherwise we should have already skipped the custom annotation and won't see it here.");
var customInstanceAnnotationValue = this.ReadCustomInstanceAnnotationValue(duplicatePropertyNamesChecker, propertyName);
complexValue.InstanceAnnotations.Add(new ODataInstanceAnnotation(propertyName, customInstanceAnnotationValue.ToODataValue()));
break;
case PropertyParsingResult.PropertyWithoutValue:
throw new ODataException(ODataErrorStrings.ODataJsonLightPropertyAndValueDeserializer_ComplexValuePropertyAnnotationWithoutProperty(propertyName));
case PropertyParsingResult.PropertyWithValue:
// Any other property is data
ODataProperty property = new ODataProperty();
property.Name = propertyName;
// Lookup the property in metadata
IEdmProperty edmProperty = null;
bool ignoreProperty = false;
if (complexValueTypeReference != null)
{
edmProperty = ReaderValidationUtils.ValidateValuePropertyDefined(propertyName, complexValueTypeReference.ComplexDefinition(), this.MessageReaderSettings, out ignoreProperty);
}
if (ignoreProperty
&& (this.JsonReader.NodeType == JsonNodeType.StartObject || this.JsonReader.NodeType == JsonNodeType.StartArray))
{
this.JsonReader.SkipValue();
}
else
{
// 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 || edmProperty == null
? ODataNullValueBehaviorKind.Default
: this.Model.NullValueReadBehaviorKind(edmProperty);
// Read the property value
object propertyValue = this.ReadNonEntityValueImplementation(
ValidateDataPropertyTypeNameAnnotation(duplicatePropertyNamesChecker, propertyName),
edmProperty == null ? null : edmProperty.Type,
/*duplicatePropertyNamesChecker*/ null,
/*collectionValidator*/ null,
nullValueReadBehaviorKind == ODataNullValueBehaviorKind.Default,
/*isTopLevelPropertyValue*/ false,
/*insideComplexValue*/ false,
propertyName,
edmProperty == null);
if (nullValueReadBehaviorKind != ODataNullValueBehaviorKind.IgnoreValue || propertyValue != null)
{
duplicatePropertyNamesChecker.CheckForDuplicatePropertyNames(property);
property.Value = propertyValue;
var propertyAnnotations = 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()));
}
}
}
properties.Add(property);
}
}
break;
case PropertyParsingResult.EndOfObject:
break;
case PropertyParsingResult.MetadataReferenceProperty:
throw new ODataException(ODataErrorStrings.ODataJsonLightPropertyAndValueDeserializer_UnexpectedMetadataReferenceProperty(propertyName));
}
});
}
Debug.Assert(this.JsonReader.NodeType == JsonNodeType.EndObject, "After all the properties of a complex value are read the EndObject node is expected.");
this.JsonReader.ReadEndObject();
complexValue.Properties = new ReadOnlyEnumerable<ODataProperty>(properties);
this.DecreaseRecursionDepth();
return complexValue;
}
static Program()
{
#region Feed and entry definition
Feed = new ODataFeed();
Address1 = new ODataComplexValue()
{
InstanceAnnotations = new List <ODataInstanceAnnotation>()
{
new ODataInstanceAnnotation("ns.ann2", new ODataPrimitiveValue("hi"))
},
TypeName = "TestNS.Address", // Need this for parsed model.
Properties = new List <ODataProperty>
{
new ODataProperty()
{
Name = "ZipCode",
Value = "200",
},
},
};
PersonEntry = new ODataEntry()
{
InstanceAnnotations = new List <ODataInstanceAnnotation>()
{
new ODataInstanceAnnotation("ns.ann1", new ODataPrimitiveValue("hi"))
},
Properties = new List <ODataProperty>
{
new ODataProperty()
{
Name = "Id",
Value = 1,
},
new ODataProperty()
{
Name = "Name",
Value = "Shang",
},
new ODataProperty()
{
Name = "Addr",
Value = Address1
}
},
};
PetEntry = new ODataEntry()
{
Properties = new List <ODataProperty>
{
new ODataProperty()
{
Name = "Id",
Value = 1,
},
new ODataProperty()
{
Name = "Color",
Value = new ODataEnumValue("Cyan")
},
},
};
FishEntry = new ODataEntry()
{
TypeName = "TestNS.Fish",
Properties = new List <ODataProperty>
{
new ODataProperty()
{
Name = "Id",
Value = 2,
},
new ODataProperty()
{
Name = "Color",
Value = new ODataEnumValue("Blue"),
},
new ODataProperty()
{
Name = "Name",
Value = "Qin",
},
},
};
#endregion
}
/// <summary>
/// Read a complex value from the reader.
/// </summary>
/// <param name="complexTypeReference">The type reference of the value to read (or null if no type is available).</param>
/// <param name="payloadTypeName">The name of the type specified in the payload.</param>
/// <param name="serializationTypeNameAnnotation">The serialization type name for the complex value (possibly null).</param>
/// <param name="duplicatePropertyNamesChecker">The duplicate property names checker to use (cached), or null if new one should be created.</param>
/// <returns>The value read from the payload.</returns>
/// <remarks>
/// Pre-Condition: XmlNodeType.Element - the element to read the value for.
/// XmlNodeType.Attribute - an attribute on the element to read the value for.
/// Post-Condition: XmlNodeType.EndElement - the element has been read.
///
/// Note that this method will not read null values, those should be handled by the caller already.
/// </remarks>
private ODataComplexValue ReadComplexValue(
IEdmComplexTypeReference complexTypeReference,
string payloadTypeName,
SerializationTypeNameAnnotation serializationTypeNameAnnotation,
DuplicatePropertyNamesChecker duplicatePropertyNamesChecker)
{
this.AssertXmlCondition(XmlNodeType.Element, XmlNodeType.Attribute);
this.IncreaseRecursionDepth();
ODataComplexValue complexValue = new ODataComplexValue();
IEdmComplexType complexType = complexTypeReference == null ? null : (IEdmComplexType)complexTypeReference.Definition;
// If we have a metadata type for the complex value, use that type name
// otherwise use the type name from the payload (if there was any).
complexValue.TypeName = complexType == null ? payloadTypeName : complexType.ODataFullName();
if (serializationTypeNameAnnotation != null)
{
complexValue.SetAnnotation(serializationTypeNameAnnotation);
}
// Move to the element (so that if we were on an attribute we can test the element for being empty)
this.XmlReader.MoveToElement();
if (duplicatePropertyNamesChecker == null)
{
duplicatePropertyNamesChecker = this.CreateDuplicatePropertyNamesChecker();
}
else
{
duplicatePropertyNamesChecker.Clear();
}
ReadOnlyEnumerable<ODataProperty> properties = new ReadOnlyEnumerable<ODataProperty>();
this.ReadPropertiesImplementation(complexType, properties, duplicatePropertyNamesChecker);
complexValue.Properties = properties;
this.AssertXmlCondition(true, XmlNodeType.EndElement);
Debug.Assert(complexValue != null, "The method should never return null since it doesn't handle null values.");
this.DecreaseRecursionDepth();
return complexValue;
}
public void WriteComplexValue(ODataComplexValue complexValue, IEdmTypeReference metadataTypeReference, bool isTopLevel, bool isOpenPropertyType, DuplicatePropertyNamesChecker duplicatePropertyNamesChecker)
{
this.WriteComplexVerifier.Should().NotBeNull("WriteComplexValue was called.");
this.WriteComplexVerifier(complexValue, metadataTypeReference, isTopLevel, isOpenPropertyType, duplicatePropertyNamesChecker);
}
public void WritingInstanceAnnotationInComplexValueShouldWrite()
{
var complexType = new EdmComplexType("TestNamespace", "Address");
model.AddElement(complexType);
settings.ShouldIncludeAnnotation = ODataUtils.CreateAnnotationFilter("*");
var result = this.SetupSerializerAndRunTest(serializer =>
{
var complexValue = new ODataComplexValue { TypeName = "TestNamespace.Address", InstanceAnnotations = new Collection<ODataInstanceAnnotation> { new ODataInstanceAnnotation("Is.ReadOnly", new ODataPrimitiveValue(true)) } };
var complexTypeRef = new EdmComplexTypeReference(complexType, false);
serializer.WriteComplexValue(complexValue, complexTypeRef, false, false, new DuplicatePropertyNamesChecker(false, true));
});
result.Should().Contain("\"@Is.ReadOnly\":true");
}
private static void AssertODataComplexValueAreEqual(ODataComplexValue complexValue1, ODataComplexValue complexValue2)
{
Assert.NotNull(complexValue1);
Assert.NotNull(complexValue2);
Assert.Equal(complexValue1.TypeName, complexValue2.TypeName);
AssertODataPropertiesAreEqual(complexValue1.Properties, complexValue2.Properties);
}
public void IfValueIsComplexThenODataValueShouldBeReferenceEqual()
{
ODataComplexValue complexValue = new ODataComplexValue();
this.property.Value = complexValue;
this.property.ODataValue.Should().BeSameAs(complexValue);
}
internal bool WriteComplexValue(
ODataComplexValue complexValue,
IEdmTypeReference metadataTypeReference,
bool isOpenPropertyType,
bool isWritingCollection,
Action beforeValueAction,
Action afterValueAction,
DuplicatePropertyNamesChecker duplicatePropertyNamesChecker,
CollectionWithoutExpectedTypeValidator collectionValidator,
ProjectedPropertiesAnnotation projectedProperties)
{
Debug.Assert(complexValue != null, "complexValue != null");
string typeName = complexValue.TypeName;
if (collectionValidator != null)
{
collectionValidator.ValidateCollectionItem(typeName, EdmTypeKind.Complex);
}
this.IncreaseRecursionDepth();
// resolve the type name to the type; if no type name is specified we will use the
// type inferred from metadata
IEdmComplexTypeReference complexTypeReference = TypeNameOracle.ResolveAndValidateTypeNameForValue(this.Model, metadataTypeReference, complexValue, isOpenPropertyType).AsComplexOrNull();
string collectionItemTypeName;
typeName = this.AtomOutputContext.TypeNameOracle.GetValueTypeNameForWriting(complexValue, complexTypeReference, complexValue.GetAnnotation <SerializationTypeNameAnnotation>(), collectionValidator, out collectionItemTypeName);
Debug.Assert(collectionItemTypeName == null, "collectionItemTypeName == null");
Action beforeValueCallbackWithTypeName = beforeValueAction;
if (typeName != null)
{
// The beforeValueAction (if specified) will write the actual property element start.
// So if we are to write the type attribute, we must postpone that after the start element was written.
// And so we chain the existing action with our type attribute writing and use that
// as the before action instead.
if (beforeValueAction != null)
{
beforeValueCallbackWithTypeName = () =>
{
beforeValueAction();
this.WritePropertyTypeAttribute(typeName);
};
}
else
{
this.WritePropertyTypeAttribute(typeName);
}
}
bool propertyWritten = this.WriteProperties(
complexTypeReference == null ? null : complexTypeReference.ComplexDefinition(),
complexValue.Properties,
isWritingCollection,
beforeValueCallbackWithTypeName,
afterValueAction,
duplicatePropertyNamesChecker,
projectedProperties);
this.DecreaseRecursionDepth();
return(propertyWritten);
}
/// <summary>
/// Returns the properties for the specified complex value.
/// </summary>
/// <param name="sourcePathSegment">The source path segment for the property which has this complex value.</param>
/// <param name="complexValue">The complex value to get the properties for.</param>
/// <param name="writingContent">true if we're writing entry content or false when writing out-of-content EPM.</param>
/// <returns>The properties enumeration for the complex value.</returns>
private IEnumerable<ODataProperty> GetComplexValueProperties(EpmSourcePathSegment sourcePathSegment, ODataComplexValue complexValue, bool writingContent)
{
Debug.Assert(writingContent || sourcePathSegment != null, "sourcePathSegment must be specified when writing out-of-content.");
Debug.Assert(complexValue != null, "complexValue != null");
// If we're writing into content we don't want to populate the cache if it's not already populated.
// The goal is to behave the same with and without EPM.
if (writingContent && this.epmValuesCache == null)
{
return complexValue.Properties;
}
object cachedPropertiesValue;
if (this.epmValuesCache != null && this.epmValuesCache.TryGetValue(sourcePathSegment, out cachedPropertiesValue))
{
Debug.Assert(cachedPropertiesValue is List<ODataProperty>, "The cached value for complex type must be a List of ODataProperty");
return (IEnumerable<ODataProperty>)cachedPropertiesValue;
}
IEnumerable<ODataProperty> properties = complexValue.Properties;
List<ODataProperty> cachedProperties = null;
if (properties != null)
{
cachedProperties = new List<ODataProperty>(properties);
}
if (this.epmValuesCache == null)
{
this.epmValuesCache = new Dictionary<EpmSourcePathSegment, object>(ReferenceEqualityComparer<EpmSourcePathSegment>.Instance);
}
this.epmValuesCache.Add(sourcePathSegment, cachedProperties);
return cachedProperties;
}
/// <summary>
/// Write the items of a collection in ATOM format.
/// </summary>
/// <param name="collectionValue">The collection value to write.</param>
/// <param name="propertyTypeReference">The type reference of the collection value (or null if not metadata is available).</param>
/// <param name="isOpenPropertyType">true if the type name belongs to an open property.</param>
/// <param name="isWritingCollection">true if we are writing a top-level collection instead of an entry.</param>
private void WriteCollectionValue(
ODataCollectionValue collectionValue,
IEdmTypeReference propertyTypeReference,
bool isOpenPropertyType,
bool isWritingCollection)
{
Debug.Assert(collectionValue != null, "collectionValue != null");
this.IncreaseRecursionDepth();
// resolve the type name to the type; if no type name is specified we will use the
// type inferred from metadata
IEdmCollectionTypeReference collectionTypeReference = (IEdmCollectionTypeReference)TypeNameOracle.ResolveAndValidateTypeNameForValue(this.Model, propertyTypeReference, collectionValue, isOpenPropertyType);
string collectionItemTypeName;
string typeName = this.AtomOutputContext.TypeNameOracle.GetValueTypeNameForWriting(collectionValue, collectionTypeReference, collectionValue.GetAnnotation <SerializationTypeNameAnnotation>(), /*collectionValidator*/ null, out collectionItemTypeName);
if (typeName != null)
{
this.WritePropertyTypeAttribute(typeName);
}
// COMPAT 4: ATOM and JSON format for collections - The collection format is not formally specified yet, since it's a new feature
// If the official format deviates from the current WCFDS behavior we would have to introduce a back compat mode here as well.
IEdmTypeReference expectedItemTypeReference = collectionTypeReference == null ? null : collectionTypeReference.ElementType();
CollectionWithoutExpectedTypeValidator collectionValidator = new CollectionWithoutExpectedTypeValidator(collectionItemTypeName);
IEnumerable items = collectionValue.Items;
if (items != null)
{
DuplicatePropertyNamesChecker duplicatePropertyNamesChecker = null;
foreach (object item in items)
{
ValidationUtils.ValidateCollectionItem(item, expectedItemTypeReference.IsNullable());
this.XmlWriter.WriteStartElement(AtomConstants.ODataMetadataNamespacePrefix, AtomConstants.ODataCollectionItemElementName, AtomConstants.ODataMetadataNamespace);
ODataComplexValue complexValue = item as ODataComplexValue;
if (complexValue != null)
{
if (duplicatePropertyNamesChecker == null)
{
duplicatePropertyNamesChecker = this.CreateDuplicatePropertyNamesChecker();
}
this.WriteComplexValue(
complexValue,
expectedItemTypeReference,
false,
isWritingCollection,
null /* beforeValueAction */,
null /* afterValueAction */,
duplicatePropertyNamesChecker,
collectionValidator,
null /* projectedProperties */);
duplicatePropertyNamesChecker.Clear();
}
else
{
Debug.Assert(!(item is ODataCollectionValue), "!(item is ODataCollectionValue)");
Debug.Assert(!(item is ODataStreamReferenceValue), "!(item is ODataStreamReferenceValue)");
ODataEnumValue enumValue = item as ODataEnumValue;
if (enumValue != null)
{
// Note: Currently there is no way for a user to control enum type's serializationTypeNameAnnotation information when the enum values are part of a collection.
this.WriteEnumValue(enumValue, collectionValidator, expectedItemTypeReference, /*serializationTypeNameAnnotation*/ null);
}
else
{
// Note: Currently there is no way for a user to control primitive type information when the primitive values are part of a collection.
if (item != null)
{
this.WritePrimitiveValue(item, collectionValidator, expectedItemTypeReference, /*serializationTypeNameAnnotation*/ null);
}
else
{
this.WriteNullCollectionElementValue(expectedItemTypeReference);
}
}
}
this.XmlWriter.WriteEndElement();
}
}
this.DecreaseRecursionDepth();
}
/// <summary>
/// Writes a property with a complex value in ATOM format.
/// </summary>
/// <param name="complexValue">The complex value to write.</param>
/// <param name="propertyName">The name of the property being written.</param>
/// <param name="isTopLevel">true if writing a top-level property payload; otherwise false.</param>
/// <param name="isWritingCollection">true if we are writing a top-level collection instead of an entry.</param>
/// <param name="beforeValueAction">Action called before the complex value is written, if it's actually written.</param>
/// <param name="propertyTypeReference">The type information for the property being written.</param>
/// <param name="isOpenPropertyType">true if the type name belongs to an open property.</param>
/// <param name="complexValueProjectedProperties">Set of projected properties, or null if all properties should be written.</param>
/// <returns>true if anything was written, false otherwise.</returns>
private bool WriteComplexValueProperty(
ODataComplexValue complexValue,
string propertyName,
bool isTopLevel,
bool isWritingCollection,
Action beforeValueAction,
IEdmTypeReference propertyTypeReference,
bool isOpenPropertyType,
ProjectedPropertiesAnnotation complexValueProjectedProperties)
{
// Complex properties are written recursively.
DuplicatePropertyNamesChecker complexValuePropertyNamesChecker = this.CreateDuplicatePropertyNamesChecker();
if (isTopLevel)
{
// Top-level property must always write the property element
Debug.Assert(complexValueProjectedProperties == null, "complexValueProjectedProperties == null");
this.WritePropertyStart(beforeValueAction, propertyName, complexValue, isWritingCollection, /*isTopLevel*/ true);
this.AssertRecursionDepthIsZero();
this.WriteComplexValue(
complexValue,
propertyTypeReference,
isOpenPropertyType,
isWritingCollection,
null /* beforeValueAction */,
null /* afterValueAction */,
complexValuePropertyNamesChecker,
null /* collectionValidator */,
null /* projectedProperties */);
this.AssertRecursionDepthIsZero();
this.WritePropertyEnd();
return true;
}
return this.WriteComplexValue(
complexValue,
propertyTypeReference,
isOpenPropertyType,
isWritingCollection,
() => this.WritePropertyStart(beforeValueAction, propertyName, complexValue, isWritingCollection, /*isTopLevel*/ false),
this.WritePropertyEnd,
complexValuePropertyNamesChecker,
null /* collectionValidator */,
complexValueProjectedProperties);
}
/// <summary>
/// Create new ODataComplexValue from the old, to discard all null/zero values
/// </summary>
/// <param name="source"></param>
/// <returns></returns>
private ODataComplexValue RebuildComplexValue(ODataComplexValue source)
{
ODataComplexValue newVal = new ODataComplexValue();
newVal.TypeName = source.TypeName;
List <ODataProperty> complexSons = source.Properties.ToList();
//Filter to get new list
List <ODataProperty> filteredSons = new List <ODataProperty>();
foreach (ODataProperty prop in complexSons)
{
PropertyType retType = GetPropertyType(prop);
switch (retType)
{
case PropertyType.SimpleEdmx:
{
if (null != prop.Value)
{
if (prop.Value.GetType().Name == "Int32")
{
//Check the value now.
bool bInclude = false;
try
{
//TODO: You cannot simply do this, potential bugs there maybe.
//Use your own logics the determine if need to ignore ZEORs or not.
int val = Convert.ToInt32(prop.Value);
bInclude = (0 != val);
}
catch (Exception)
{
}
if (bInclude)
{
filteredSons.Add(prop);
}
}
else
{
filteredSons.Add(prop);
}
}
}
break;
case PropertyType.ComplexType:
{
//Recursively
ODataComplexValue comx = RebuildComplexValue((ODataComplexValue)prop.Value);
if (comx.Properties.Count() > 0)
{
prop.Value = comx;
filteredSons.Add(prop);
}
}
break;
case PropertyType.Collection:
{
ODataCollectionValue coll = RebuildCollectionValue((ODataCollectionValue)prop.Value);
List <ODataComplexValue> listSubs = (List <ODataComplexValue>)coll.Items;
if (listSubs.Count > 0)
{
prop.Value = coll;
filteredSons.Add(prop);
}
}
break;
default:
break;
}
}
//Re-Assign sons
newVal.Properties = filteredSons;
return(newVal);
}
