public ODataComplexTypeSerializerTests()
{
_model = SerializationTestsHelpers.SimpleCustomerOrderModel();
_address = new Address()
{
Street = "One Microsoft Way",
City = "Redmond",
State = "Washington",
Country = "United States",
ZipCode = "98052"
};
_addressType = _model.FindDeclaredType("Default.Address") as IEdmComplexType;
_model.SetAnnotationValue(_addressType, new ClrTypeAnnotation(typeof(Address)));
_addressTypeRef = _addressType.ToEdmTypeReference(isNullable: false).AsComplex();
var cnAddressType = _model.FindDeclaredType("Default.CnAddress") as IEdmComplexType;
_model.SetAnnotationValue(cnAddressType, new ClrTypeAnnotation(typeof(CnAddress)));
var usAddressType = _model.FindDeclaredType("Default.UsAddress") as IEdmComplexType;
_model.SetAnnotationValue(usAddressType, new ClrTypeAnnotation(typeof(UsAddress)));
_locationType = _model.FindDeclaredType("Default.Location") as IEdmComplexType;
_model.SetAnnotationValue(_locationType, new ClrTypeAnnotation(typeof(Location)));
_locationTypeRef = _locationType.ToEdmTypeReference(isNullable: false).AsComplex();
ODataSerializerProvider serializerProvider = new DefaultODataSerializerProvider();
_serializer = new ODataComplexTypeSerializer(serializerProvider);
TimeZoneInfoHelper.TimeZone = null;
}
public EdmComplexType(string namespaceName, string name, IEdmComplexType baseType, bool isAbstract) : base(isAbstract, false, baseType)
{
EdmUtil.CheckArgumentNull<string>(namespaceName, "namespaceName");
EdmUtil.CheckArgumentNull<string>(name, "name");
this.namespaceName = namespaceName;
this.name = name;
}
protected override void ProcessComplexType(IEdmComplexType element)
{
base.ProcessComplexType(element);
if (element.BaseComplexType() != null)
{
this.CheckSchemaElementReference(element.BaseComplexType());
}
}
internal static object CreateResource(IEdmComplexType edmComplexType, IEdmModel edmModel)
{
Type clrType = EdmLibHelpers.GetClrType(new EdmComplexTypeReference(edmComplexType, isNullable: true), edmModel);
if (clrType == null)
{
throw Error.Argument("edmComplexType", SRResources.MappingDoesNotContainEntityType, edmComplexType.FullName());
}
return Activator.CreateInstance(clrType);
}
/// <summary>
/// Initializes a new instance of the <see cref="ComplexCastPathSegment" /> class.
/// </summary>
/// <param name="castType">The type of the cast.</param>
public ComplexCastPathSegment(IEdmComplexType castType)
{
if (castType == null)
{
throw Error.ArgumentNull("castType");
}
CastType = castType;
CastTypeName = castType.FullTypeName();
}
/// <summary>
/// Initializes a new instance of the EdmComplexTypeWithDelayLoadedProperties class.
/// </summary>
/// <param name="namespaceName">Namespace the entity belongs to.</param>
/// <param name="name">Name of the entity.</param>
/// <param name="baseType">The base type of this entity type.</param>
/// <param name="isAbstract">Denotes an entity that cannot be instantiated.</param>
/// <param name="isOpen">Denotes if the type is open.</param>
/// <param name="propertyLoadAction">An action that is used to create the properties for this type.</param>
internal EdmComplexTypeWithDelayLoadedProperties(
string namespaceName,
string name,
IEdmComplexType baseType,
bool isAbstract,
bool isOpen,
Action<EdmComplexTypeWithDelayLoadedProperties> propertyLoadAction)
: base(namespaceName, name, baseType, isAbstract, isOpen)
{
Debug.Assert(propertyLoadAction != null, "propertyLoadAction != null");
this.propertyLoadAction = propertyLoadAction;
}
/// <summary>
/// Initializes a new instance of the MetadataProviderEdmEntityType class.
/// </summary>
/// <param name="namespaceName">Namespace the entity belongs to.</param>
/// <param name="resourceType">The resource type this edm type is based on.</param>
/// <param name="baseType">The base type of this entity type.</param>
/// <param name="isAbstract">Denotes an entity that cannot be instantiated.</param>
/// /// <param name="isOpen">Denotes if the type is open.</param>
/// <param name="propertyLoadAction">An action that is used to create the properties for this type.</param>
internal MetadataProviderEdmComplexType(
string namespaceName,
ResourceType resourceType,
IEdmComplexType baseType,
bool isAbstract,
bool isOpen,
Action<EdmComplexTypeWithDelayLoadedProperties> propertyLoadAction)
: base(namespaceName, resourceType.Name, baseType, isAbstract, isOpen, propertyLoadAction)
{
Debug.Assert(resourceType != null, "resourceType != null");
Debug.Assert(resourceType.ResourceTypeKind == ResourceTypeKind.ComplexType, "Must be a complex type.");
this.ResourceType = resourceType;
}
public ODataComplexTypeSerializerTests()
{
_model = SerializationTestsHelpers.SimpleCustomerOrderModel();
_address = new Address()
{
Street = "One Microsoft Way",
City = "Redmond",
State = "Washington",
Country = "United States",
ZipCode = "98052"
};
_addressType = _model.FindDeclaredType("Default.Address") as IEdmComplexType;
ODataSerializerProvider serializerProvider = new DefaultODataSerializerProvider();
_serializer = new ODataComplexTypeSerializer(new EdmComplexTypeReference(_addressType, isNullable: false), serializerProvider);
}
/// <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.FullTypeName();
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);
}
private void CreateStructuralTypeBody(EdmStructuredType type, IStructuralTypeConfiguration config)
{
foreach (PrimitivePropertyConfiguration prop in config.Properties.OfType <PrimitivePropertyConfiguration>())
{
type.AddStructuralProperty(
prop.PropertyInfo.Name,
GetTypeKind(prop.PropertyInfo.PropertyType),
prop.OptionalProperty);
}
foreach (ComplexPropertyConfiguration prop in config.Properties.OfType <ComplexPropertyConfiguration>())
{
IEdmComplexType complexType = _types[prop.RelatedClrType.FullName] as IEdmComplexType;
type.AddStructuralProperty(
prop.PropertyInfo.Name,
new EdmComplexTypeReference(complexType, prop.OptionalProperty));
}
}
private IEdmComplexType ComputeBaseType()
{
if (this.complex.BaseTypeName != null)
{
IEdmComplexType baseType = this.Context.FindType(this.complex.BaseTypeName) as IEdmComplexType;
if (baseType != null)
{
// Evaluate the inductive step to detect cycles.
// Overriding BaseType getter from concrete type implementing IEdmComplexType will be invoked to
// detect cycles. The object assignment is required by compiler only.
IEdmStructuredType baseType2 = baseType.BaseType;
}
return(baseType ?? new UnresolvedComplexType(this.Context.UnresolvedName(this.complex.BaseTypeName), this.Location));
}
return(null);
}
public void GetEdmModel_WorksOnModelBuilder_ForOpenComplexType()
{
// Arrange
ODataModelBuilder builder = new ODataModelBuilder();
ComplexTypeConfiguration<SimpleOpenComplexType> complex = builder.ComplexType<SimpleOpenComplexType>();
complex.Property(c => c.IntProperty);
complex.HasDynamicProperties(c => c.DynamicProperties);
// Act
IEdmModel model = builder.GetEdmModel();
// Assert
Assert.NotNull(model);
IEdmComplexType complexType = Assert.Single(model.SchemaElements.OfType<IEdmComplexType>());
Assert.True(complexType.IsOpen);
IEdmProperty edmProperty = Assert.Single(complexType.Properties());
Assert.Equal("IntProperty", edmProperty.Name);
}
public void CreateResourceReaderArgumentTest()
{
IEdmEntityType entityType = null;
IEdmComplexType complexType = null;
IEdmModel model = this.CreateTestMetadata(out entityType, out complexType);
this.CombinatorialEngineProvider.RunCombinations(
this.ReaderTestConfigurationProvider.ExplicitFormatConfigurations,
(testConfiguration) =>
{
TestMessage message = TestReaderUtils.CreateInputMessageFromStream(new TestStream(), testConfiguration);
ODataMessageReaderTestWrapper messageReader = TestReaderUtils.CreateMessageReader(message, null, testConfiguration);
this.Assert.ExpectedException(
() => messageReader.CreateODataResourceReader(entityType),
ODataExpectedExceptions.ArgumentException("ODataMessageReader_ExpectedTypeSpecifiedWithoutMetadata", "resourceType"),
this.ExceptionVerifier);
});
}
public ODataComplexTypeSerializerTests()
{
_model = SerializationTestsHelpers.SimpleCustomerOrderModel();
_address = new Address()
{
Street = "One Microsoft Way",
City = "Redmond",
State = "Washington",
Country = "United States",
ZipCode = "98052"
};
_addressType = _model.FindDeclaredType("Default.Address") as IEdmComplexType;
ODataSerializerProvider serializerProvider = new DefaultODataSerializerProvider(_model);
_serializer = new ODataComplexTypeSerializer(new EdmComplexTypeReference(_addressType, isNullable: false), serializerProvider);
}
private static OpenApiSchema CreateStructuredTypeSchema(this ODataContext context, IEdmStructuredType structuredType, bool processBase, bool processExample)
{
Debug.Assert(context != null);
Debug.Assert(structuredType != null);
// A structured type without a base type is represented as a Schema Object of type object
OpenApiSchema schema = new OpenApiSchema
{
Title = (structuredType as IEdmSchemaElement)?.Name,
Type = "object",
// Each structural property and navigation property is represented
// as a name/value pair of the standard OpenAPI properties object.
// Add properties from referenced types instead of using AllOf
// because AllOf is not supported by PowerApps
Properties = context.CreateStructuredTypeCombinedPropertiesSchema(structuredType),
// make others null
AllOf = null,
OneOf = null,
AnyOf = null
};
// It optionally can contain the field description,
// whose value is the value of the unqualified annotation Core.Description of the structured type.
if (structuredType.TypeKind == EdmTypeKind.Complex)
{
IEdmComplexType complex = (IEdmComplexType)structuredType;
schema.Description = context.Model.GetDescriptionAnnotation(complex);
}
else if (structuredType.TypeKind == EdmTypeKind.Entity)
{
IEdmEntityType entity = (IEdmEntityType)structuredType;
schema.Description = context.Model.GetDescriptionAnnotation(entity);
}
if (processExample)
{
schema.Example = CreateStructuredTypePropertiesExample(context, structuredType);
}
return(schema);
}
public void TestInitialize()
{
this.testModel = Test.OData.Utils.Metadata.TestModels.BuildTestModel();
this.defaultContainer = this.testModel.EntityContainer;
this.personSet = this.defaultContainer.FindEntitySet("Persons");
this.personType = (IEdmEntityType)this.testModel.FindType("TestModel.Person");
this.employeeType = (IEdmEntityType)this.testModel.FindType("TestModel.Employee");
this.officeType = (IEdmEntityType)this.testModel.FindType("TestModel.OfficeType");
this.addressType = (IEdmComplexType)this.testModel.FindType("TestModel.Address");
this.metropolitanCitySet = this.defaultContainer.FindEntitySet("MetropolitanCities");
this.metropolitanCityType = (IEdmEntityType)this.testModel.FindType("TestModel.MetropolitanCityType");
this.boss = this.defaultContainer.FindSingleton("Boss");
this.containedOfficeNavigationProperty = (IEdmNavigationProperty)this.metropolitanCityType.FindProperty("ContainedOffice");
this.containedOfficeSet = (IEdmContainedEntitySet)metropolitanCitySet.FindNavigationTarget(this.containedOfficeNavigationProperty);
this.containedMetropolitanCityNavigationProperty = (IEdmNavigationProperty)this.officeType.FindProperty("ContainedCity");
this.containedMetropolitanCitySet = (IEdmContainedEntitySet)containedOfficeSet.FindNavigationTarget(this.containedMetropolitanCityNavigationProperty);
}
public void CanDefinePropertyOnDerivedType_NotPresentInBaseType_ButPresentInDerivedType()
{
// Arrange
ODataModelBuilder builder = new ODataModelBuilder();
builder.ComplexType<DerivedComplexType>().DerivesFrom<BaseComplexType>().Property(m => m.BaseProperty);
// Act
IEdmModel model = builder.GetEdmModel();
// Assert
IEdmComplexType baseComplex = model.AssertHasComplexType(typeof(BaseComplexType));
Assert.Null(baseComplex.BaseComplexType());
Assert.Empty(baseComplex.Properties());
IEdmComplexType derivedComplex = model.AssertHasComplexType(typeof(DerivedComplexType));
Assert.Equal(baseComplex, derivedComplex.BaseComplexType());
Assert.Single(derivedComplex.Properties());
derivedComplex.AssertHasPrimitiveProperty(model, "BaseProperty", EdmPrimitiveTypeKind.String, true);
}
private EdmEntityObjectCollection GetCustomers()
{
IEdmModel edmModel = Request.ODataProperties().Model;
IEdmEntityType customerType = edmModel.SchemaElements.OfType <IEdmEntityType>().Single(e => e.Name == "Customer");
IEdmEnumType colorType = edmModel.SchemaElements.OfType <IEdmEnumType>().Single(e => e.Name == "Color");
IEdmComplexType addressType = edmModel.SchemaElements.OfType <IEdmComplexType>().Single(e => e.Name == "Address");
// an enum object
EdmEnumObject color = new EdmEnumObject(colorType, "Red");
// a complex object
EdmComplexObject address1 = new EdmComplexObject(addressType);
address1.TrySetPropertyValue("Street", "ZiXing Rd"); // Declared property
address1.TrySetPropertyValue("StringProperty", "CN"); // a string dynamic property
address1.TrySetPropertyValue("GuidProperty", new Guid("181D3A20-B41A-489F-9F15-F91F0F6C9ECA")); // a guid dynamic property
// another complex object with complex dynamic property
EdmComplexObject address2 = new EdmComplexObject(addressType);
address2.TrySetPropertyValue("Street", "ZiXing Rd"); // Declared property
address2.TrySetPropertyValue("AddressProperty", address1); // a complex dynamic property
// an entity object
EdmEntityObject customer = new EdmEntityObject(customerType);
customer.TrySetPropertyValue("CustomerId", 1); // Declared property
customer.TrySetPropertyValue("Name", "Mike"); // Declared property
customer.TrySetPropertyValue("Color", color); // an enum dynamic property
customer.TrySetPropertyValue("Address1", address1); // a complex dynamic property
customer.TrySetPropertyValue("Address2", address2); // another complex dynamic property
// a collection with one object
EdmEntityObjectCollection collection =
new EdmEntityObjectCollection(
new EdmCollectionTypeReference(
new EdmCollectionType(new EdmEntityTypeReference(customerType, isNullable: true))));
collection.Add(customer);
return(collection);
}
private ComplexType ConvertToTaupoComplexType(IEdmComplexType edmComplexType)
{
// Taupo TODO: Abstract for ComplexType
var taupoComplexType = new ComplexType(edmComplexType.Namespace, edmComplexType.Name);
if (edmComplexType.BaseType != null)
{
taupoComplexType.BaseType = new ComplexTypeReference(edmComplexType.BaseComplexType().Namespace, edmComplexType.BaseComplexType().Name);
}
foreach (var edmProperty in edmComplexType.DeclaredStructuralProperties())
{
var taupoProperty = this.ConvertToTaupoProperty(edmProperty);
taupoComplexType.Add(taupoProperty);
}
this.ConvertAnnotationsIntoTaupo(edmComplexType, taupoComplexType);
return(taupoComplexType);
}
public void ComplexType_reference_extensions()
{
IEdmModel edmModel = this.GetEdmModel();
IEdmComplexType derivedComplexType = edmModel.SchemaElements.OfType <IEdmComplexType>().First(c => c.BaseType != null);
IEdmComplexType baseComplexType = derivedComplexType.BaseComplexType();
Assert.IsNotNull(baseComplexType, "Base complex type should not be null!");
IEdmComplexTypeReference derivedComplexTypeRef = (IEdmComplexTypeReference)derivedComplexType.ToTypeReference();
Assert.AreEqual(baseComplexType, derivedComplexTypeRef.BaseComplexType(), "ComplexTypeReference.BaseComplexType()");
Assert.AreEqual(baseComplexType, derivedComplexTypeRef.BaseType(), "ComplexTypeReference.BaseType()");
Assert.AreEqual(derivedComplexType.IsAbstract, derivedComplexTypeRef.IsAbstract(), "StructuralTypeReference.IsAbstract()");
Assert.AreEqual(derivedComplexType.IsOpen, derivedComplexTypeRef.IsOpen(), "StructuralTypeReference.IsOpen()");
Assert.AreEqual(derivedComplexType.DeclaredStructuralProperties().Count(), derivedComplexTypeRef.DeclaredStructuralProperties().Count(), "StructuralTypeReference.DeclaredStructuralProperties()");
Assert.AreEqual(derivedComplexType.StructuralProperties().Count(), derivedComplexTypeRef.StructuralProperties().Count(), "StructuralTypeReference.StructuralProperties()");
}
public void TestInitialize()
{
this.testModel = Test.OData.Utils.Metadata.TestModels.BuildTestModel();
this.defaultContainer = this.testModel.EntityContainer;
this.personSet = this.defaultContainer.FindEntitySet("Persons");
this.personType = (IEdmEntityType)this.testModel.FindType("TestModel.Person");
this.employeeType = (IEdmEntityType)this.testModel.FindType("TestModel.Employee");
this.officeType = (IEdmEntityType)this.testModel.FindType("TestModel.OfficeType");
this.addressType = (IEdmComplexType)this.testModel.FindType("TestModel.Address");
this.metropolitanCitySet = this.defaultContainer.FindEntitySet("MetropolitanCities");
this.metropolitanCityType = (IEdmEntityType)this.testModel.FindType("TestModel.MetropolitanCityType");
this.boss = this.defaultContainer.FindSingleton("Boss");
this.containedOfficeNavigationProperty = (IEdmNavigationProperty)this.metropolitanCityType.FindProperty("ContainedOffice");
this.containedOfficeSet = (IEdmContainedEntitySet)metropolitanCitySet.FindNavigationTarget(this.containedOfficeNavigationProperty);
this.containedMetropolitanCityNavigationProperty = (IEdmNavigationProperty)this.officeType.FindProperty("ContainedCity");
this.containedMetropolitanCitySet = (IEdmContainedEntitySet)containedOfficeSet.FindNavigationTarget(this.containedMetropolitanCityNavigationProperty);
}
private void VisitComplexType(IEdmComplexType complex)
{
string qualifiedName = complex.FullTypeName();
if (_types.ContainsKey(qualifiedName))
{
return; // processed
}
MetaComplexType metaComplex = new MetaComplexType();
metaComplex.QualifiedName = qualifiedName;
metaComplex.Name = complex.Name;
metaComplex.Abstract = complex.IsAbstract;
_types[qualifiedName] = metaComplex;
VisitProperties(metaComplex, complex.DeclaredProperties);
VisitNavProperties(metaComplex, complex.DeclaredNavigationProperties());
}
public void CreateEdmTypeSchemaReturnSchemaForNullableCollectionComplexType(OpenApiSpecVersion specVersion)
{
// Arrange
IEdmModel model = EdmModelHelper.TripServiceModel;
IEdmComplexType complex = model.SchemaElements.OfType <IEdmComplexType>().First(c => c.Name == "AirportLocation");
ODataContext context = new ODataContext(model);
context.Settings.OpenApiSpecVersion = specVersion;
IEdmCollectionTypeReference collectionType = new EdmCollectionTypeReference(
new EdmCollectionType(new EdmComplexTypeReference(complex, true)));
// Act
var schema = context.CreateEdmTypeSchema(collectionType);
Assert.NotNull(schema);
string json = schema.SerializeAsJson(context.Settings.OpenApiSpecVersion);
// & Assert
if (specVersion == OpenApiSpecVersion.OpenApi2_0)
{
Assert.Equal(@"{
""type"": ""array"",
""items"": {
""$ref"": ""#/definitions/Microsoft.OData.Service.Sample.TrippinInMemory.Models.AirportLocation""
}
}".ChangeLineBreaks(), json);
}
else
{
Assert.Equal(@"{
""type"": ""array"",
""items"": {
""anyOf"": [
{
""$ref"": ""#/components/schemas/Microsoft.OData.Service.Sample.TrippinInMemory.Models.AirportLocation""
}
],
""nullable"": true
}
}".ChangeLineBreaks(), json);
}
}
public void GetEdmModel_WorksOnConventionModelBuilder_ForOpenComplexType()
{
// Arrange
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.ComplexType <SimpleOpenComplexType>();
// Act
IEdmModel model = builder.GetEdmModel();
// Assert
Assert.NotNull(model);
IEdmComplexType complexType = Assert.Single(model.SchemaElements.OfType <IEdmComplexType>());
Assert.True(complexType.IsOpen);
IEdmProperty edmProperty = Assert.Single(complexType.Properties());
Assert.Equal("IntProperty", edmProperty.Name);
}
public ODataUriParserInjectionTests()
{
folderType = oneDriveModel.SchemaElements.OfType <IEdmComplexType>().Single(e => string.Equals(e.Name, "folder"));
itemType = oneDriveModel.SchemaElements.OfType <IEdmEntityType>().Single(e => string.Equals(e.Name, "item"));
specialItemType = oneDriveModel.SchemaElements.OfType <IEdmEntityType>().Single(e => string.Equals(e.Name, "specialItem"));
folderProp = itemType.FindProperty("folder") as IEdmStructuralProperty;
sizeProp = itemType.FindProperty("size") as IEdmStructuralProperty;
driveType = oneDriveModel.SchemaElements.OfType <IEdmEntityType>().Single(e => string.Equals(e.Name, "drive"));
itemsNavProp = driveType.DeclaredNavigationProperties().FirstOrDefault(p => p.Name == "items");
childrenNavProp = itemType.DeclaredNavigationProperties().FirstOrDefault(p => p.Name == "children");
thumbnailsNavProp = itemType.DeclaredNavigationProperties().FirstOrDefault(p => p.Name == "thumbnails");
drivesEntitySet = oneDriveModel.EntityContainer.FindEntitySet("drives");
driveSingleton = oneDriveModel.EntityContainer.FindSingleton("drive");
containedItemsNav = drivesEntitySet.FindNavigationTarget(itemsNavProp);
containedthumbnailsNav = containedItemsNav.FindNavigationTarget(thumbnailsNavProp);
copyOp = oneDriveModel.SchemaElements.OfType <IEdmOperation>().FirstOrDefault(o => o.Name == "copy");
searchOp = oneDriveModel.SchemaElements.OfType <IEdmOperation>().FirstOrDefault(o => o.Name == "search");
shareItemBindCollectionOp = oneDriveModel.SchemaElements.OfType <IEdmOperation>().LastOrDefault(o => o.Name == "sharedWithMe");
}
public void ODataConventionModelBuilder_IgnoresIndexerProperties()
{
MockType type =
new MockType("ComplexType")
.Property <int>("Item");
MockPropertyInfo pi = type.GetProperty("Item");
pi.Setup(p => p.GetIndexParameters()).Returns(new[] { new Mock <ParameterInfo>().Object }); // make it indexer
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.AddComplexType(type);
IEdmModel model = builder.GetEdmModel();
IEdmComplexType complexType = model.AssertHasComplexType(type);
Assert.Empty(complexType.Properties());
}
public void CreateODataComplexValue_WritesBaseAndDerivedProperties_ForDerivedComplexType()
{
// Arrange
IEdmModel model = SerializationTestsHelpers.SimpleCustomerOrderModel();
IEdmComplexType addressType = model.FindDeclaredType("Default.CnAddress") as IEdmComplexType;
Type cnAddress = typeof(CnAddress);
model.SetAnnotationValue <ClrTypeAnnotation>(addressType, new ClrTypeAnnotation(cnAddress));
IEdmComplexTypeReference addressTypeRef = addressType.ToEdmTypeReference(isNullable: false).AsComplex();
ODataSerializerProvider serializerProvider = new DefaultODataSerializerProvider();
ODataComplexTypeSerializer serializer = new ODataComplexTypeSerializer(serializerProvider);
ODataSerializerContext context = new ODataSerializerContext
{
Model = model
};
Address address = new CnAddress()
{
Street = "One Microsoft Way",
City = "Redmond",
State = "Washington",
Country = "United States",
ZipCode = "98052",
CnProp = new Guid("F83FB4CC-84BD-403B-B411-79926800F9A5")
};
// Act
var odataValue = serializer.CreateODataComplexValue(address, addressTypeRef, context);
// Assert
ODataComplexValue complexValue = Assert.IsType <ODataComplexValue>(odataValue);
Assert.Equal(complexValue.TypeName, "Default.CnAddress");
Assert.Equal(6, complexValue.Properties.Count());
// Verify the derived property
ODataProperty street = Assert.Single(complexValue.Properties.Where(p => p.Name == "CnProp"));
Assert.Equal(new Guid("F83FB4CC-84BD-403B-B411-79926800F9A5"), street.Value);
}
public void GetEdmModel_Works_ForOpenComplexTypeWithDerivedDynamicProperty()
{
// Arrange
ODataConventionModelBuilder builder = ODataConventionModelBuilderFactory.Create();
builder.ComplexType <OpenComplexTypeWithDerivedDynamicProperty>();
// Act
IEdmModel model = builder.GetEdmModel();
// Assert
Assert.NotNull(model);
IEdmComplexType complexType = Assert.Single(model.SchemaElements.OfType <IEdmComplexType>());
Assert.True(complexType.IsOpen);
IEdmProperty edmProperty = Assert.Single(complexType.Properties());
Assert.Equal("StringProperty", edmProperty.Name);
}
/// <summary>
/// Converts a complex data type to a complex type.
/// </summary>
/// <param name="complexType">The complex data type to convert.</param>
/// <returns>The corresponding complex type.</returns>
private static IEdmComplexTypeReference GetComplexType(IEdmModel model, ComplexDataType complexDataType)
{
Debug.Assert(complexDataType != null, "complexDataType != null");
IEdmSchemaType edmType = model.FindType(complexDataType.Definition.FullName);
ExceptionUtilities.Assert(
edmType != null,
"The expected complex type '{0}' was not found in the entity model for this test.",
complexDataType.Definition.FullName);
IEdmComplexType complexType = edmType as IEdmComplexType;
ExceptionUtilities.Assert(
complexType != null,
"The expected complex type '{0}' is not defined as complex type in the test's metadata.",
complexDataType.Definition.FullName);
return((IEdmComplexTypeReference)complexType.ToTypeReference(complexDataType.IsNullable));
}
private IEdmProperty CreateStructuralTypeCollectionPropertyBody(EdmStructuredType type, CollectionPropertyConfiguration collectionProperty)
{
IEdmTypeReference elementTypeReference;
Type clrType = TypeHelper.GetUnderlyingTypeOrSelf(collectionProperty.ElementType);
if (clrType == typeof(object))
{
elementTypeReference = EdmCoreModel.Instance.GetUntyped();
}
else if (TypeHelper.IsEnum(clrType))
{
IEdmType edmType = GetEdmType(clrType);
if (edmType == null)
{
throw Error.InvalidOperation(SRResources.EnumTypeDoesNotExist, clrType.Name);
}
IEdmEnumType enumElementType = (IEdmEnumType)edmType;
bool isNullable = collectionProperty.ElementType != clrType;
elementTypeReference = new EdmEnumTypeReference(enumElementType, isNullable);
}
else
{
IEdmType edmType = GetEdmType(collectionProperty.ElementType);
if (edmType != null)
{
IEdmComplexType elementType = edmType as IEdmComplexType;
Contract.Assert(elementType != null);
elementTypeReference = new EdmComplexTypeReference(elementType, collectionProperty.NullableProperty);
}
else
{
elementTypeReference =
EdmLibHelpers.GetEdmPrimitiveTypeReferenceOrNull(collectionProperty.ElementType);
Contract.Assert(elementTypeReference != null);
}
}
return(type.AddStructuralProperty(
collectionProperty.Name,
new EdmCollectionTypeReference(new EdmCollectionType(elementTypeReference))));
}
private EdmComplexType ConstructStockComplexTypeInModel(IEdmComplexType complexType, EdmModel stockModel, Dictionary <string, EdmComplexType> stockComplexTypes)
{
EdmComplexType stockType;
string fullName = complexType.FullName();
if (!stockComplexTypes.TryGetValue(fullName, out stockType))
{
stockType = new EdmComplexType(
complexType.Namespace,
complexType.Name,
complexType.BaseType != null ? this.ConstructStockComplexTypeInModel((IEdmComplexType)complexType.BaseType, stockModel, stockComplexTypes) : null,
complexType.IsAbstract);
// TODO: IsBad, Documentation
stockModel.AddElement(stockType);
stockComplexTypes.Add(fullName, stockType);
}
return(stockType);
}
public ODataComplexTypeSerializerTests()
{
_model = SerializationTestsHelpers.SimpleCustomerOrderModel();
_address = new Address()
{
Street = "One Microsoft Way",
City = "Redmond",
State = "Washington",
Country = "United States",
ZipCode = "98052"
};
_addressType = _model.FindDeclaredType("Default.Address") as IEdmComplexType;
_model.SetAnnotationValue(_addressType, new ClrTypeAnnotation(typeof(Address)));
_addressTypeRef = _addressType.ToEdmTypeReference(isNullable: false).AsComplex();
ODataSerializerProvider serializerProvider = new DefaultODataSerializerProvider();
_serializer = new ODataComplexTypeSerializer(serializerProvider);
}
/// <summary>
/// Parse Alternate Keys Vocabulary Model from AlternateKeysVocabularies.xml
/// </summary>
static AlternateKeysVocabularyModel()
{
Assembly assembly = typeof(AlternateKeysVocabularyModel).GetAssembly();
using (Stream stream = assembly.GetManifestResourceStream("AlternateKeysVocabularies.xml"))
{
IEnumerable<EdmError> errors;
Debug.Assert(stream != null, "AlternateKeysVocabularies.xml: stream!=null");
CsdlReader.TryParse(new[] { XmlReader.Create(stream) }, out Instance, out errors);
}
AlternateKeysTerm = Instance.FindDeclaredValueTerm(AlternateKeysVocabularyConstants.AlternateKeys);
Debug.Assert(AlternateKeysTerm != null, "Expected Alternate Key term");
AlternateKeyType = Instance.FindDeclaredType(AlternateKeysVocabularyConstants.AlternateKeyType) as IEdmComplexType;
Debug.Assert(AlternateKeyType != null, "Expected Alternate Key type");
PropertyRefType = Instance.FindDeclaredType(AlternateKeysVocabularyConstants.PropertyRefType) as IEdmComplexType;
Debug.Assert(PropertyRefType != null, "Expected Alternate Key property ref type");
}
/// <summary>
/// Parse Alternate Keys Vocabulary Model from AlternateKeysVocabularies.xml
/// </summary>
static AlternateKeysVocabularyModel()
{
Assembly assembly = typeof(AlternateKeysVocabularyModel).GetAssembly();
using (Stream stream = assembly.GetManifestResourceStream("AlternateKeysVocabularies.xml"))
{
IEnumerable <EdmError> errors;
Debug.Assert(stream != null, "AlternateKeysVocabularies.xml: stream!=null");
CsdlReader.TryParse(new[] { XmlReader.Create(stream) }, out Instance, out errors);
}
AlternateKeysTerm = Instance.FindDeclaredValueTerm(AlternateKeysVocabularyConstants.AlternateKeys);
Debug.Assert(AlternateKeysTerm != null, "Expected Alternate Key term");
AlternateKeyType = Instance.FindDeclaredType(AlternateKeysVocabularyConstants.AlternateKeyType) as IEdmComplexType;
Debug.Assert(AlternateKeyType != null, "Expected Alternate Key type");
PropertyRefType = Instance.FindDeclaredType(AlternateKeysVocabularyConstants.PropertyRefType) as IEdmComplexType;
Debug.Assert(PropertyRefType != null, "Expected Alternate Key property ref type");
}
public void GetEdmModel_PropertyWithDatabaseAttribute_CannotSetStoreGeneratedPatternOnComplexType()
{
// Arrange
ODataModelBuilder builder = new ODataModelBuilder();
builder.ComplexType <Customer>().Property(c => c.Name).HasStoreGeneratedPattern(DatabaseGeneratedOption.Computed);
// Act
IEdmModel model = builder.GetEdmModel();
// Assert
IEdmComplexType type = model.AssertHasComplexType(typeof(Customer));
IEdmStructuralProperty property = type.AssertHasPrimitiveProperty(model, "Name", EdmPrimitiveTypeKind.String, isNullable: true);
var idAnnotation = model.GetAnnotationValue <EdmStringConstant>(
property,
StoreGeneratedPatternAnnotation.AnnotationsNamespace,
StoreGeneratedPatternAnnotation.AnnotationName);
Assert.Null(idAnnotation);
}
public void Initialize()
{
EdmModel edmModel = new EdmModel();
EdmEntityType edmEntityType = new EdmEntityType("TestNamespace", "EntityType", baseType: null, isAbstract: false, isOpen: true);
edmModel.AddElement(edmEntityType);
EdmComplexType ComplexType = new EdmComplexType("TestNamespace", "TestComplexType");
ComplexType.AddProperty(new EdmStructuralProperty(ComplexType, "StringProperty", EdmCoreModel.Instance.GetString(false)));
edmModel.AddElement(ComplexType);
EdmComplexType derivedComplexType = new EdmComplexType("TestNamespace", "TestDerivedComplexType", ComplexType, true);
derivedComplexType.AddProperty(new EdmStructuralProperty(derivedComplexType, "DerivedStringProperty", EdmCoreModel.Instance.GetString(false)));
edmModel.AddElement(derivedComplexType);
var defaultContainer = new EdmEntityContainer("TestNamespace", "DefaultContainer_sub");
edmModel.AddElement(defaultContainer);
this.entitySet = new EdmEntitySet(defaultContainer, "TestEntitySet", edmEntityType);
defaultContainer.AddElement(this.entitySet);
this.model = TestUtils.WrapReferencedModelsToMainModel("TestNamespace", "DefaultContainer", edmModel);
this.entityType = edmEntityType;
this.complexType = ComplexType;
}
public void ComplexType_Containing_ComplexCollection_works()
{
Type complexType =
new MockType("ComplexTypeWithComplexCollection")
.Property <Version[]>("CollectionProperty");
var modelBuilder = new ODataConventionModelBuilder();
modelBuilder.AddComplexType(complexType);
var model = modelBuilder.GetEdmModel();
IEdmComplexType complexEdmType = model.AssertHasComplexType(complexType);
model.AssertHasComplexType(typeof(Version));
var collectionProperty = complexEdmType.DeclaredProperties.Where(p => p.Name == "CollectionProperty").SingleOrDefault();
Assert.NotNull(collectionProperty);
Assert.True(collectionProperty.Type.IsCollection());
Assert.Equal(collectionProperty.Type.AsCollection().ElementType().FullName(), "System.Version");
}
public void ParserTestComplexTypeWithDuplicateProperties()
{
var csdls = ODataTestModelBuilder.InvalidCsdl.ComplexTypeWithDuplicateProperties;
var model = this.GetParserResult(csdls);
IEdmEntityContainer entityContainer = model.EntityContainer;
Assert.AreEqual("DefaultContainer", entityContainer.Name, "Invalid entity container name");
Assert.IsTrue(entityContainer.Elements.Count() == 0, "Entity container has invalid amount of elements");
Assert.IsTrue(model.SchemaElements.Count() == 2, "Invalid schema element count");
Assert.AreEqual(EdmSchemaElementKind.TypeDefinition, model.SchemaElements.ElementAt(0).SchemaElementKind, "Invalid schema element kind");
IEdmComplexType complexTypeElement = (IEdmComplexType)model.SchemaElements.ElementAt(0);
Assert.AreEqual("TestModel.DuplicatePropertiesComplexType", complexTypeElement.FullName(), "Invalid complex type full name");
Assert.AreEqual("DuplicatePropertiesComplexType", complexTypeElement.Name, "Invalid complex type name");
Assert.IsTrue(complexTypeElement.DeclaredProperties.Count() == 2, "Invalid complex type property count");
Assert.AreEqual(EdmPropertyKind.Structural, complexTypeElement.DeclaredProperties.ElementAt(0).PropertyKind, "Invalid property kind");
Assert.AreEqual(EdmPropertyKind.Structural, complexTypeElement.DeclaredProperties.ElementAt(1).PropertyKind, "Invalid property kind");
IEdmProperty complexProperty1 = (IEdmProperty)complexTypeElement.DeclaredProperties.ElementAt(0);
Assert.AreEqual("Duplicate", complexProperty1.Name, "Invalid property name");
IEdmProperty complexProperty2 = (IEdmProperty)complexTypeElement.DeclaredProperties.ElementAt(1);
Assert.AreEqual("Duplicate", complexProperty2.Name, "Invalid property name");
var expectedErrors = new EdmLibTestErrors()
{
{ 6, 10, EdmErrorCode.AlreadyDefined }
};
IEnumerable <EdmError> actualErrors = null;
model.Validate(out actualErrors);
this.CompareErrors(actualErrors, expectedErrors);
}
/// <summary>Adds a new complex type (without any properties).</summary>
/// <param name="name">The name of the type.</param>
/// <param name="instanceType">The instance type or null if this should be untyped resource.</param>
/// <param name="baseType">The base type.</param>
/// <param name="isAbstract">If the type should be abstract.</param>
/// <returns>The newly created complex type.</returns>
public IEdmComplexType AddComplexType(string name, Type instanceType, IEdmComplexType baseType, bool isAbstract, string nameSpace)
{
EdmComplexType complexType = new EdmComplexType(
this.namespaceName,
name,
baseType,
isAbstract);
this.complexTypes.Add(complexType.FullName(), complexType);
if (complexType.BaseType != null)
{
List <IEdmStructuredType> derivedTypes;
if (!this.derivedTypeMappings.TryGetValue(complexType.BaseType, out derivedTypes))
{
derivedTypes = new List <IEdmStructuredType>();
this.derivedTypeMappings[complexType.BaseType] = derivedTypes;
}
}
return(complexType);
}
public ExpandModelPathTests()
{
// Address is an open complex type
var addressType = new EdmComplexType("NS", "Address");
addressType.AddStructuralProperty("Street", EdmPrimitiveTypeKind.String);
addressType.AddStructuralProperty("City", EdmPrimitiveTypeKind.String);
_addressType = addressType;
EdmEntityType customerType = new EdmEntityType("NS", "Customer");
customerType.AddKeys(customerType.AddStructuralProperty("ID", EdmPrimitiveTypeKind.Int32));
_homeAddress = customerType.AddStructuralProperty("HomeAddress", new EdmComplexTypeReference(addressType, false));
_customerType = customerType;
_relatedNavProperty = addressType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo
{
Name = "RelatedCustomers",
Target = customerType,
TargetMultiplicity = EdmMultiplicity.Many
});
}
public void CanCreateDerivedComplexType()
{
// Arrange
ODataModelBuilder builder = new ODataModelBuilder();
builder.ComplexType<BaseComplexType>().Abstract().Property(v => v.BaseProperty);
builder.ComplexType<DerivedComplexType>().DerivesFrom<BaseComplexType>().Property(v => v.DerivedProperty);
// Act
IEdmModel model = builder.GetEdmModel();
// Assert
IEdmComplexType baseComplexType = model.AssertHasComplexType(typeof(BaseComplexType));
Assert.Null(baseComplexType.BaseComplexType());
Assert.Single(baseComplexType.Properties());
baseComplexType.AssertHasPrimitiveProperty(model, "BaseProperty", EdmPrimitiveTypeKind.String, true);
IEdmComplexType derivedComplexType = model.AssertHasComplexType(typeof(DerivedComplexType));
Assert.Equal(baseComplexType, derivedComplexType.BaseComplexType());
Assert.Equal(2, derivedComplexType.Properties().Count());
derivedComplexType.AssertHasPrimitiveProperty(model, "BaseProperty", EdmPrimitiveTypeKind.String, true);
derivedComplexType.AssertHasPrimitiveProperty(model, "DerivedProperty", EdmPrimitiveTypeKind.Int32, false);
}
/// <summary>
/// Initializes a new instance of the <see cref="EdmStructuredObject"/> class.
/// </summary>
/// <param name="edmType">The <see cref="IEdmStructuredType"/> of this object.</param>
public EdmComplexObject(IEdmComplexType edmType)
: this(edmType, isNullable: false)
{
}
/// <summary>
/// Returns the cached keep-in-content annotation for the primitive properties of a complex type.
/// </summary>
/// <param name="model">The model containing the annotation.</param>
/// <param name="complexType">The complex type to get the cached keep-in-content annotation for.</param>
/// <returns>Returns the keep-in-content annotation for a type. If there's no such annotation this returns null.</returns>
internal static CachedPrimitiveKeepInContentAnnotation EpmCachedKeepPrimitiveInContent(this IEdmModel model, IEdmComplexType complexType)
{
DebugUtils.CheckNoExternalCallers();
Debug.Assert(model != null, "model != null");
Debug.Assert(complexType != null, "complexType != null");
return model.GetAnnotationValue<CachedPrimitiveKeepInContentAnnotation>(complexType);
}
/// <summary>
/// Validates that the <paramref name="payloadComplexType"/> is assignable to the <paramref name="expectedComplexType"/>
/// and fails if it's not.
/// </summary>
/// <param name="expectedComplexType">The expected complex type reference, the base type of the ComplexType expected.</param>
/// <param name="payloadComplexType">The payload complex type reference to validate.</param>
internal static void ValidateComplexTypeIsAssignable(IEdmComplexType expectedComplexType, IEdmComplexType payloadComplexType)
{
Debug.Assert(expectedComplexType != null, "expectedComplexType != null");
Debug.Assert(payloadComplexType != null, "payloadComplexType != null");
// Complex types could be assignable
if (!EdmLibraryExtensions.IsAssignableFrom(expectedComplexType, payloadComplexType))
{
throw new ODataException(Strings.ValidationUtils_IncompatibleType(payloadComplexType.ODataFullName(), expectedComplexType.ODataFullName()));
}
}
/// <summary>
/// Initializes a new instance of the <see cref="EdmComplexTypeReference"/> class.
/// </summary>
/// <param name="complexType">The type definition this reference refers to.</param>
/// <param name="isNullable">Denotes whether the type can be nullable.</param>
public EdmComplexTypeReference(IEdmComplexType complexType, bool isNullable)
: base(complexType, isNullable)
{
}
private ComplexType ConvertToTaupoComplexType(IEdmComplexType edmComplexType)
{
// Taupo TODO: Abstract for ComplexType
var taupoComplexType = new ComplexType(edmComplexType.Namespace, edmComplexType.Name);
if (edmComplexType.BaseType != null)
{
taupoComplexType.BaseType = new ComplexTypeReference(edmComplexType.BaseComplexType().Namespace, edmComplexType.BaseComplexType().Name);
}
foreach (var edmProperty in edmComplexType.DeclaredStructuralProperties())
{
var taupoProperty = this.ConvertToTaupoProperty(edmProperty);
taupoComplexType.Add(taupoProperty);
}
this.ConvertAnnotationsIntoTaupo(edmComplexType, taupoComplexType);
return taupoComplexType;
}
private bool TryGetComplexType(string typeName, out IEdmComplexType complexType)
{
complexType = _model.SchemaElements
.Where(x => x.SchemaElementKind == EdmSchemaElementKind.TypeDefinition && (x as IEdmType).TypeKind == EdmTypeKind.Complex)
.Select(x => x as IEdmComplexType)
.BestMatch(x => x.Name, typeName, _session.Pluralizer);
return complexType != null;
}
private void FillStockContentsForComplex(IEdmComplexType edmType, IEdmModel edmModel, EdmModel stockModel)
{
var stockType = (EdmComplexType)stockModel.FindType(edmType.FullName());
this.SetImmediateAnnotations(edmType, stockType, edmModel, stockModel);
foreach (var edmProperty in edmType.DeclaredStructuralProperties())
{
ConvertToStockStructuralProperty((IEdmStructuralProperty)edmProperty, edmModel, stockModel);
}
}
/// <summary>Adds a complex property to the specified <paramref name="structuredType"/>.</summary>
/// <param name="structuredType">The type to add the property to.</param>
/// <param name="name">The name of the property to add.</param>
/// <param name="complexType">Complex type to use for the property.</param>
/// <param name="isCollection">Whether the property is a collection of complex type.</param>
public void AddComplexProperty(IEdmStructuredType structuredType, string name, IEdmComplexType complexType, bool isCollection = false)
{
AddStructuralProperty(structuredType, name, EdmConcurrencyMode.None,
isCollection ? ((EdmComplexTypeReference)complexType.ToTypeReference(true)).ToCollectionTypeReference() : complexType.ToTypeReference(true));
}
internal void WriteComplexType(IEdmComplexType complexType, Dictionary<IEdmStructuredType, List<IEdmOperation>> boundOperationsMap)
{
WriteSummaryCommentForStructuredType(Context.EnableNamingAlias ? Customization.CustomizeNaming(complexType.Name) : complexType.Name);
WriteStructurdTypeDeclaration(complexType, string.Empty);
SetPropertyIdentifierMappingsIfNameConflicts(complexType.Name, complexType);
WriteTypeStaticCreateMethod(complexType.Name, complexType);
WritePropertiesForStructuredType(complexType.DeclaredProperties);
if (complexType.BaseType == null && Context.UseDataServiceCollection)
{
WriteINotifyPropertyChangedImplementation();
}
WriteClassEndForStructuredType();
}
internal static object CreateResource(IEdmComplexType edmComplexType, IEdmModel edmModel)
{
Contract.Assert(edmComplexType != null);
Contract.Assert(edmModel != null);
Type clrType = EdmLibHelpers.GetClrType(new EdmComplexTypeReference(edmComplexType, isNullable: true), edmModel);
if (clrType == null)
{
throw Error.InvalidOperation(SRResources.MappingDoesNotContainEntityType, edmComplexType.FullName());
}
return Activator.CreateInstance(clrType);
}
/// <summary>
/// Initializes a new instance of the <see cref="EdmComplexType"/> class.
/// </summary>
/// <param name="namespaceName">The namespace this type belongs to.</param>
/// <param name="name">The name of this type within its namespace.</param>
/// <param name="baseType">The base type of this complex type.</param>
/// <param name="isAbstract">Denotes whether this complex type is abstract.</param>
public EdmComplexType(string namespaceName, string name, IEdmComplexType baseType, bool isAbstract)
: this(namespaceName, name, baseType, isAbstract, false)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="EdmComplexType"/> class.
/// </summary>
/// <param name="namespaceName">The namespace this type belongs to.</param>
/// <param name="name">The name of this type within its namespace.</param>
/// <param name="baseType">The base type of this complex type.</param>
public EdmComplexType(string namespaceName, string name, IEdmComplexType baseType)
: this(namespaceName, name, baseType, false, false)
{
}
/// <summary>Adds a new complex type (without any properties).</summary>
/// <param name="name">The name of the type.</param>
/// <param name="instanceType">The instance type or null if this should be untyped resource.</param>
/// <param name="baseType">The base type.</param>
/// <param name="isAbstract">If the type should be abstract.</param>
/// <returns>The newly created complex type.</returns>
public IEdmComplexType AddComplexType(string name, Type instanceType, IEdmComplexType baseType, bool isAbstract, string nameSpace)
{
EdmComplexType complexType = new EdmComplexType(
this.namespaceName,
name,
baseType,
isAbstract);
this.complexTypes.Add(complexType.FullName(), complexType);
if (complexType.BaseType != null)
{
List<IEdmStructuredType> derivedTypes;
if (!this.derivedTypeMappings.TryGetValue(complexType.BaseType, out derivedTypes))
{
derivedTypes = new List<IEdmStructuredType>();
this.derivedTypeMappings[complexType.BaseType] = derivedTypes;
}
}
return complexType;
}
/// <summary>
/// Initializes a new instance of the <see cref="EdmStructuredObject"/> class.
/// </summary>
/// <param name="edmType">The <see cref="IEdmComplexType"/> of this object.</param>
/// <param name="isNullable">true if this object can be nullable; otherwise, false.</param>
public EdmComplexObject(IEdmComplexType edmType, bool isNullable)
: base(edmType, isNullable)
{
}
private void TestWriteComplexTypeElementHeaderMethod(IEdmComplexType complexType, string expected)
{
this.EdmModelCsdlSchemaWriterTest(writer => writer.WriteComplexTypeElementHeader(complexType), expected);
}
/// <summary>Adds a new complex type (without any properties).</summary>
/// <param name="name">The name of the type.</param>
/// <param name="instanceType">The instance type or null if this should be untyped resource.</param>
/// <param name="baseType">The base type.</param>
/// <param name="isAbstract">If the type should be abstract.</param>
/// <param name="nameSpace">The namespace of the complex type</param>
/// <returns>The newly created complex type.</returns>
public IEdmComplexType AddComplexType(string name, Type instanceType, IEdmComplexType baseType, bool isAbstract)
{
return this.AddComplexType(name, instanceType, baseType, isAbstract, this.namespaceName);
}
private EdmComplexType ConstructStockComplexTypeInModel(IEdmComplexType complexType, EdmModel stockModel, Dictionary<string, EdmComplexType> stockComplexTypes)
{
EdmComplexType stockType;
string fullName = complexType.FullName();
if (!stockComplexTypes.TryGetValue(fullName, out stockType))
{
stockType = new EdmComplexType(
complexType.Namespace,
complexType.Name,
complexType.BaseType != null ? this.ConstructStockComplexTypeInModel((IEdmComplexType)complexType.BaseType, stockModel, stockComplexTypes) : null,
complexType.IsAbstract);
// TODO: IsBad, Documentation
stockModel.AddElement(stockType);
stockComplexTypes.Add(fullName, stockType);
}
return stockType;
}
internal MetadataProviderEdmComplexType(string namespaceName, string name, IEdmComplexType baseType, bool isAbstract, Action<MetadataProviderEdmComplexType> propertyLoadAction) : base(namespaceName, name, baseType, isAbstract)
{
this.lockObject = new object();
this.propertyLoadAction = propertyLoadAction;
}
static ODataAvroScenarioTests()
{
var type = new EdmEntityType("Microsoft.Test.OData.PluggableFormat.Avro.Test", "Product");
type.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32, false);
type.AddStructuralProperty("Weight", EdmPrimitiveTypeKind.Single, false);
EntryType = type;
var cpx = new EdmComplexType("Microsoft.Test.OData.PluggableFormat.Avro.Test", "Address");
cpx.AddStructuralProperty("Road", EdmPrimitiveTypeKind.String, false);
cpx.AddStructuralProperty("ZipCode", EdmPrimitiveTypeKind.String, false);
ComplexType = cpx;
var action = new EdmAction("Microsoft.Test.OData.PluggableFormat.Avro.Test", "AddProduct", null);
action.AddParameter("Product", new EdmEntityTypeReference(EntryType, false));
action.AddParameter("Location", new EdmComplexTypeReference(ComplexType, false));
AddProduct = action;
action = new EdmAction("Microsoft.Test.OData.PluggableFormat.Avro.Test", "GetMaxId", EdmCoreModel.Instance.GetInt32(false));
action.AddParameter("Products", new EdmCollectionTypeReference(new EdmCollectionType(new EdmEntityTypeReference(EntryType, false))));
GetMaxId = action;
}
