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; }