private static void ParseComponent(EdmEntityObject entity, ComponentHelpClass item, object value)
{
int i = 0;
EdmStructuredObject actualEntity = entity;
for (i = 0; i < item.Depth - 1; i++)
{
var componentName = item.SplitedComponents[i];
object local = null;
actualEntity.TryGetPropertyValue(componentName, out local);
if (local == null)
{
var declaredProperty = actualEntity.ActualEdmType.DeclaredProperties.FirstOrDefault(w => w.Name == componentName);
var edmComplexObject = new EdmComplexObject(declaredProperty.Type.AsComplex());
actualEntity.TrySetPropertyValue(componentName, edmComplexObject);
actualEntity = edmComplexObject;
}
else
{
actualEntity = (EdmStructuredObject)local;
}
}
var propertyName = item.SplitedComponents[item.Depth - 1];
actualEntity.TrySetPropertyValue(propertyName, value);
}
/// <summary>
/// Deserializes the given <paramref name="entryWrapper"/> under the given <paramref name="readContext"/>.
/// </summary>
/// <param name="entryWrapper">The OData entry to deserialize.</param>
/// <param name="entityType">The entity type of the entry to deserialize.</param>
/// <param name="readContext">The deserializer context.</param>
/// <returns>The deserialized entity.</returns>
public virtual object ReadEntry(ODataEntryWithNavigationLinks entryWrapper, IEdmEntityTypeReference entityType,
ODataDeserializerContext readContext)
{
if (entryWrapper == null)
{
throw Error.ArgumentNull("entryWrapper");
}
if (readContext == null)
{
throw Error.ArgumentNull("readContext");
}
if (!String.IsNullOrEmpty(entryWrapper.Entry.TypeName) && entityType.FullName() != entryWrapper.Entry.TypeName)
{
// received a derived type in a base type deserializer. delegate it to the appropriate derived type deserializer.
IEdmModel model = readContext.Model;
if (model == null)
{
throw Error.Argument("readContext", SRResources.ModelMissingFromReadContext);
}
IEdmEntityType actualType = model.FindType(entryWrapper.Entry.TypeName) as IEdmEntityType;
if (actualType == null)
{
throw new ODataException(Error.Format(SRResources.EntityTypeNotInModel, entryWrapper.Entry.TypeName));
}
if (actualType.IsAbstract)
{
string message = Error.Format(SRResources.CannotInstantiateAbstractEntityType, entryWrapper.Entry.TypeName);
throw new ODataException(message);
}
IEdmTypeReference actualEntityType = new EdmEntityTypeReference(actualType, isNullable: false);
ODataEdmTypeDeserializer deserializer = DeserializerProvider.GetEdmTypeDeserializer(actualEntityType);
if (deserializer == null)
{
throw new SerializationException(
Error.Format(SRResources.TypeCannotBeDeserialized, actualEntityType.FullName(), typeof(ODataMediaTypeFormatter).Name));
}
object resource = deserializer.ReadInline(entryWrapper, actualEntityType, readContext);
EdmStructuredObject structuredObject = resource as EdmStructuredObject;
if (structuredObject != null)
{
structuredObject.ExpectedEdmType = entityType.EntityDefinition();
}
return(resource);
}
else
{
object resource = CreateEntityResource(entityType, readContext);
ApplyEntityProperties(resource, entryWrapper, entityType, readContext);
return(resource);
}
}
public void GetDefaultValue_NonNullableEntity()
{
IEdmTypeReference nonNullableEntityType = new EdmEntityTypeReference(new EdmEntityType("NS", "Entity"), isNullable: false);
var result = EdmStructuredObject.GetDefaultValue(nonNullableEntityType);
var entityObject = Assert.IsType <EdmEntityObject>(result);
Assert.Equal(nonNullableEntityType, entityObject.GetEdmType(), new EdmTypeReferenceEqualityComparer());
}
public void GetClrTypeForUntypedDelta_ThrowsInvalidOperation_ForUnsupportedTypeKind()
{
// Arrange & Act
IEdmPathTypeReference path = EdmCoreModel.Instance.GetPathType(EdmPathTypeKind.PropertyPath, true);
Action test = () => EdmStructuredObject.GetClrTypeForUntypedDelta(path);
// Assert
ExceptionAssert.Throws <InvalidOperationException>(
() => EdmStructuredObject.GetClrTypeForUntypedDelta(path),
"The EDM type '[Edm.PropertyPath Nullable=True]' of kind 'Path' is not supported.");
}
public void GetDefaultValue_NonNullableEntityCollection()
{
IEdmTypeReference elementType = new EdmEntityTypeReference(new EdmEntityType("NS", "Entity"), isNullable: true);
IEdmCollectionTypeReference entityCollectionType = new EdmCollectionTypeReference(new EdmCollectionType(elementType));
var result = EdmStructuredObject.GetDefaultValue(entityCollectionType);
var entityCollectionObject = Assert.IsType <EdmEntityObjectCollection>(result);
Assert.Equal(entityCollectionType, entityCollectionObject.GetEdmType(), new EdmTypeReferenceEqualityComparer());
}
/// <summary>
/// Sets the property value and unwraps it from a DTO wrapper if necessary.
/// </summary>
public static bool TrySetPropertyValue <T>(this EdmStructuredObject targetObject, string propertyName, T value)
{
if (value != null)
{
object unwrappedValue;
if (PropertyValueWrappingHelper.TryUnwrapEdmObject(value, out unwrappedValue))
{
return(targetObject.TrySetPropertyValue(propertyName, unwrappedValue));
}
}
return(targetObject.TrySetPropertyValue(propertyName, value));
}
private static void AssertObject(
EdmStructuredObject edmEntityObject,
string nameSet,
string surnameSet,
DateTime acceptanceDateSet,
int versionExpected,
string acceptanceTextSet)
{
object value = null;
edmEntityObject.TryGetPropertyValue(TestModelBuilder.TestEntityName_NamePropertyName, out value);
Assert.AreEqual(nameSet, value);
edmEntityObject.TryGetPropertyValue(TestModelBuilder.TestEntityName_SurnamePropertyName, out value);
Assert.AreEqual(surnameSet, value);
object agreement = null;
edmEntityObject.TryGetPropertyValue(TestModelBuilder.TestEntityName_AgreementsTypeName, out agreement);
object marketingAgreementProperty = null;
((EdmStructuredObject)agreement).TryGetPropertyValue(TestModelBuilder.TestEntityName_AgreementsTypeName_MarketingagreementTypeName, out marketingAgreementProperty);
((EdmStructuredObject)marketingAgreementProperty).TryGetPropertyValue(TestModelBuilder.TestEntityName_AgreementsTypeName_MarketingagreementTypeName_AcceptanceDatePropertyName, out value);
Assert.AreEqual(acceptanceDateSet, value);
object acceptanceAgreementInfoProperty = null;
((EdmStructuredObject)marketingAgreementProperty).TryGetPropertyValue(TestModelBuilder.TestEntityName_AgreementsTypeName_MarketingagreementTypeName_AcceptedAgreementInfoTypeName, out acceptanceAgreementInfoProperty);
((EdmStructuredObject)acceptanceAgreementInfoProperty).TryGetPropertyValue(TestModelBuilder.TestEntityName_AgreementsTypeName_MarketingagreementTypeName_AcceptedAgreementInfoTypeName_VersionPropertyName, out value);
Assert.AreEqual(versionExpected, value);
((EdmStructuredObject)acceptanceAgreementInfoProperty).TryGetPropertyValue(TestModelBuilder.TestEntityName_AgreementsTypeName_MarketingagreementTypeName_AcceptedAgreementInfoTypeName_TextPropertyName, out value);
Assert.AreEqual(acceptanceTextSet, value);
}
internal static void SetEntityPropertyValue(this DbDataReader reader, int fieldIndex, EdmStructuredObject entity)
{
string name = reader.GetName(fieldIndex);
if (reader.IsDBNull(fieldIndex))
{
entity.TrySetPropertyValue(name, null);
return;
}
if (reader.GetFieldType(fieldIndex) == typeof(DateTime))
{
entity.TrySetPropertyValue(name, new DateTimeOffset(reader.GetDateTime(fieldIndex)));
}
else
{
entity.TrySetPropertyValue(name, reader.GetValue(fieldIndex));
}
}
/// <summary>
/// Deserializes the given <paramref name="complexValue"/> under the given <paramref name="readContext"/>.
/// </summary>
/// <param name="complexValue">The complex value to deserialize.</param>
/// <param name="complexType">The EDM type of the complex value to read.</param>
/// <param name="readContext">The deserializer context.</param>
/// <returns>The deserialized complex value.</returns>
public virtual object ReadComplexValue(ODataComplexValue complexValue, IEdmComplexTypeReference complexType,
ODataDeserializerContext readContext)
{
if (complexValue == null)
{
throw Error.ArgumentNull("complexValue");
}
if (readContext == null)
{
throw Error.ArgumentNull("readContext");
}
if (readContext.Model == null)
{
throw Error.Argument("readContext", SRResources.ModelMissingFromReadContext);
}
if (!String.IsNullOrEmpty(complexValue.TypeName) && complexType.FullName() != complexValue.TypeName)
{
// received a derived complex type in a base type deserializer.
IEdmModel model = readContext.Model;
if (model == null)
{
throw Error.Argument("readContext", SRResources.ModelMissingFromReadContext);
}
IEdmComplexType actualType = model.FindType(complexValue.TypeName) as IEdmComplexType;
if (actualType == null)
{
throw new ODataException(Error.Format(SRResources.ComplexTypeNotInModel, complexValue.TypeName));
}
if (actualType.IsAbstract)
{
string message = Error.Format(SRResources.CannotInstantiateAbstractComplexType,
complexValue.TypeName);
throw new ODataException(message);
}
IEdmTypeReference actualComplexType = new EdmComplexTypeReference(actualType, isNullable: false);
ODataEdmTypeDeserializer deserializer = DeserializerProvider.GetEdmTypeDeserializer(actualComplexType);
if (deserializer == null)
{
throw new SerializationException(
Error.Format(SRResources.TypeCannotBeDeserialized, actualComplexType.FullName(),
typeof(ODataMediaTypeFormatter).Name));
}
object resource = deserializer.ReadInline(complexValue, actualComplexType, readContext);
EdmStructuredObject structuredObject = resource as EdmStructuredObject;
if (structuredObject != null)
{
structuredObject.ExpectedEdmType = complexType.ComplexDefinition();
}
return(resource);
}
else
{
object complexResource = CreateResource(complexType, readContext);
foreach (ODataProperty complexProperty in complexValue.Properties)
{
DeserializationHelpers.ApplyProperty(complexProperty, complexType, complexResource,
DeserializerProvider, readContext);
}
return(complexResource);
}
}
public void GetClrTypeForUntypedDelta(IEdmTypeReference edmType, Type expectedType)
{
// Arrange & Act & Assert
Assert.Equal(expectedType, EdmStructuredObject.GetClrTypeForUntypedDelta(edmType));
}
public void GetDefaultValue(IEdmTypeReference edmType, object expectedResult)
{
Assert.Equal(expectedResult, EdmStructuredObject.GetDefaultValue(edmType));
}
/// <summary>
/// Deserializes the given <paramref name="resourceWrapper"/> under the given <paramref name="readContext"/>.
/// </summary>
/// <param name="resourceWrapper">The OData resource to deserialize.</param>
/// <param name="structuredType">The type of the resource to deserialize.</param>
/// <param name="readContext">The deserializer context.</param>
/// <returns>The deserialized resource.</returns>
public virtual object ReadResource(ODataResourceWrapper resourceWrapper, IEdmStructuredTypeReference structuredType,
ODataDeserializerContext readContext)
{
if (resourceWrapper == null)
{
throw Error.ArgumentNull("resourceWrapper");
}
if (readContext == null)
{
throw Error.ArgumentNull("readContext");
}
if (!String.IsNullOrEmpty(resourceWrapper.Resource.TypeName) && structuredType.FullName() != resourceWrapper.Resource.TypeName)
{
// received a derived type in a base type deserializer. delegate it to the appropriate derived type deserializer.
IEdmModel model = readContext.Model;
if (model == null)
{
throw Error.Argument("readContext", SRResources.ModelMissingFromReadContext);
}
IEdmStructuredType actualType = model.FindType(resourceWrapper.Resource.TypeName) as IEdmStructuredType;
if (actualType == null)
{
throw new ODataException(Error.Format(SRResources.ResourceTypeNotInModel, resourceWrapper.Resource.TypeName));
}
if (actualType.IsAbstract)
{
string message = Error.Format(SRResources.CannotInstantiateAbstractResourceType, resourceWrapper.Resource.TypeName);
throw new ODataException(message);
}
IEdmTypeReference actualStructuredType;
IEdmEntityType actualEntityType = actualType as IEdmEntityType;
if (actualEntityType != null)
{
actualStructuredType = new EdmEntityTypeReference(actualEntityType, isNullable: false);
}
else
{
actualStructuredType = new EdmComplexTypeReference(actualType as IEdmComplexType, isNullable: false);
}
ODataEdmTypeDeserializer deserializer = DeserializerProvider.GetEdmTypeDeserializer(actualStructuredType);
if (deserializer == null)
{
throw new SerializationException(
Error.Format(SRResources.TypeCannotBeDeserialized, actualEntityType.FullName()));
}
object resource = deserializer.ReadInline(resourceWrapper, actualStructuredType, readContext);
EdmStructuredObject structuredObject = resource as EdmStructuredObject;
if (structuredObject != null)
{
structuredObject.ExpectedEdmType = structuredType.StructuredDefinition();
}
return(resource);
}
else
{
object resource = CreateResourceInstance(structuredType, readContext);
ApplyResourceProperties(resource, resourceWrapper, structuredType, readContext);
return(resource);
}
}
internal static void SetEntityPropertyValue(this DbDataReader reader, int fieldIndex, EdmStructuredObject entity, bool lowerName = false)
{
string name = reader.GetName(fieldIndex);
if (lowerName)
{
name = name.ToLower();
}
if (reader.IsDBNull(fieldIndex))
{
entity.TrySetPropertyValue(name, null);
return;
}
var t = reader.GetFieldType(fieldIndex);
entity.TryGetPropertyType(name, out Type et);
if (t == typeof(DateTime))
{
entity.TrySetPropertyValue(name, new DateTimeOffset(reader.GetDateTime(fieldIndex)));
}
else if (et == typeof(bool?) || et == typeof(bool))
{
entity.TrySetPropertyValue(name, reader[fieldIndex].ToString() != "0");
}
else
{
entity.TrySetPropertyValue(name, reader.GetValue(fieldIndex));
}
}
