private static EdmModel CreateCustomerProductsModel() { var model = new EdmModel(); var container = new EdmEntityContainer("defaultNamespace", "DefaultContainer"); model.AddElement(container); var productType = new EdmEntityType("defaultNamespace", "Product"); model.AddElement(productType); var customerType = new EdmEntityType("defaultNamespace", "Customer"); customerType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo() { Name = "Products", Target = productType, TargetMultiplicity = EdmMultiplicity.Many }); productType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo() { Name = "Customers", Target = customerType, TargetMultiplicity = EdmMultiplicity.Many }); model.AddElement(customerType); var productSet = new EdmEntitySet( container, "Products", productType); container.AddElement(productSet); var customerSet = new EdmEntitySet( container, "Customers", customerType); var productsNavProp = customerType.NavigationProperties().Single(np => np.Name == "Products"); customerSet.AddNavigationTarget(productsNavProp, productSet); container.AddElement(customerSet); return model; }
public static IEdmModel SimpleCustomerOrderModel() { var model = new EdmModel(); var customerType = new EdmEntityType("Default", "Customer"); customerType.AddStructuralProperty("ID", EdmPrimitiveTypeKind.Int32); customerType.AddStructuralProperty("FirstName", EdmPrimitiveTypeKind.String); customerType.AddStructuralProperty("LastName", EdmPrimitiveTypeKind.String); IEdmTypeReference primitiveTypeReference = EdmCoreModel.Instance .GetPrimitive(EdmPrimitiveTypeKind.String, isNullable: true); customerType.AddStructuralProperty("City", primitiveTypeReference, defaultValue: null, concurrencyMode: EdmConcurrencyMode.Fixed); model.AddElement(customerType); var orderType = new EdmEntityType("Default", "Order"); orderType.AddStructuralProperty("ID", EdmPrimitiveTypeKind.Int32); orderType.AddStructuralProperty("Name", EdmPrimitiveTypeKind.String); orderType.AddStructuralProperty("Shipment", EdmPrimitiveTypeKind.String); model.AddElement(orderType); var addressType = new EdmComplexType("Default", "Address"); addressType.AddStructuralProperty("Street", EdmPrimitiveTypeKind.String); addressType.AddStructuralProperty("City", EdmPrimitiveTypeKind.String); addressType.AddStructuralProperty("State", EdmPrimitiveTypeKind.String); addressType.AddStructuralProperty("Country", EdmPrimitiveTypeKind.String); addressType.AddStructuralProperty("ZipCode", EdmPrimitiveTypeKind.String); model.AddElement(addressType); // Add navigations customerType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo() { Name = "Orders", Target = orderType, TargetMultiplicity = EdmMultiplicity.Many }); orderType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo() { Name = "Customer", Target = customerType, TargetMultiplicity = EdmMultiplicity.One }); var container = new EdmEntityContainer("Default", "Container"); var customerSet = container.AddEntitySet("Customers", customerType); var orderSet = container.AddEntitySet("Orders", orderType); customerSet.AddNavigationTarget(customerType.NavigationProperties().Single(np => np.Name == "Orders"), orderSet); orderSet.AddNavigationTarget(orderType.NavigationProperties().Single(np => np.Name == "Customer"), customerSet); EntitySetLinkBuilderAnnotation linkAnnotation = new MockEntitySetLinkBuilderAnnotation(); model.SetEntitySetLinkBuilder(customerSet, linkAnnotation); model.SetEntitySetLinkBuilder(orderSet, linkAnnotation); model.AddElement(container); return model; }
static TableStorageQueryIndexInspector() { EdmModel = new EdmModel(); TableServiceEntity = new EdmEntityType("Glimpse.WindowsAzure.Storage", "TableServiceEntity"); TableServiceEntity.AddStructuralProperty("PartitionKey", EdmPrimitiveTypeKind.String); TableServiceEntity.AddStructuralProperty("RowKey", EdmPrimitiveTypeKind.String); TableServiceEntity.AddStructuralProperty("Timestamp", EdmPrimitiveTypeKind.DateTime); EdmModel.AddElement(TableServiceEntity); var container = new EdmEntityContainer("TestModel", "DefaultContainer"); container.AddEntitySet("Entities", TableServiceEntity); EdmModel.AddElement(container); }
public static IEdmModel BuildEdmModel(ODataModelBuilder builder) { if (builder == null) { throw Error.ArgumentNull("builder"); } EdmModel model = new EdmModel(); EdmEntityContainer container = new EdmEntityContainer(builder.Namespace, builder.ContainerName); // add types and sets, building an index on the way. Dictionary<Type, IEdmStructuredType> edmTypeMap = model.AddTypes(builder.StructuralTypes); Dictionary<string, EdmEntitySet> edmEntitySetMap = model.AddEntitySets(builder, container, edmTypeMap); // add procedures model.AddProcedures(builder.Procedures, container, edmTypeMap, edmEntitySetMap); // finish up model.AddElement(container); // build the map from IEdmEntityType to IEdmFunctionImport model.SetAnnotationValue<BindableProcedureFinder>(model, new BindableProcedureFinder(model)); return model; }
private EdmEntityType ConvertToEdmEntityType(JSchema schema, EdmModel model, string name) { var type = new EdmEntityType("namespace", name); foreach (var property in schema.Properties) { if (property.Value.Type == null) throw new Exception("Type specyfication missing."); var structuralType = MapPropertyToStructuralType(property, schema, model); if (structuralType != null) { type.AddStructuralProperty(property.Key, structuralType); } else { type.AddStructuralProperty(property.Key, ToEdmPrimitiveType(property.Value.Type.Value)); } } model.AddElement(type); return type; }
public static IEdmModel SimpleCustomerOrderModel() { var model = new EdmModel(); var customerType = new EdmEntityType("Default", "Customer"); customerType.AddStructuralProperty("ID", EdmPrimitiveTypeKind.Int32); customerType.AddStructuralProperty("FirstName", EdmPrimitiveTypeKind.String); customerType.AddStructuralProperty("LastName", EdmPrimitiveTypeKind.String); model.AddElement(customerType); var orderType = new EdmEntityType("Default", "Order"); orderType.AddStructuralProperty("ID", EdmPrimitiveTypeKind.Int32); orderType.AddStructuralProperty("Name", EdmPrimitiveTypeKind.String); model.AddElement(orderType); var addressType = new EdmComplexType("Default", "Address"); addressType.AddStructuralProperty("Street", EdmPrimitiveTypeKind.String); addressType.AddStructuralProperty("City", EdmPrimitiveTypeKind.String); addressType.AddStructuralProperty("State", EdmPrimitiveTypeKind.String); addressType.AddStructuralProperty("Country", EdmPrimitiveTypeKind.String); addressType.AddStructuralProperty("ZipCode", EdmPrimitiveTypeKind.String); model.AddElement(addressType); // Add navigations customerType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo() { Name = "Orders", Target = orderType, TargetMultiplicity = EdmMultiplicity.Many }); orderType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo() { Name = "Customer", Target = customerType, TargetMultiplicity = EdmMultiplicity.One }); var container = new EdmEntityContainer("Default", "Container"); var customerSet = container.AddEntitySet("Customers", customerType); var orderSet = container.AddEntitySet("Orders", orderType); customerSet.AddNavigationTarget(customerType.NavigationProperties().Single(np => np.Name == "Orders"), orderSet); orderSet.AddNavigationTarget(orderType.NavigationProperties().Single(np => np.Name == "Customer"), customerSet); Mock<IEntitySetLinkBuilder> linkAnnotation = new Mock<IEntitySetLinkBuilder>(); model.SetEntitySetLinkBuilderAnnotation(customerSet, linkAnnotation.Object); model.SetEntitySetLinkBuilderAnnotation(orderSet, linkAnnotation.Object); model.AddElement(container); return model; }
public IEdmModel ToEdmModel(JSchema schema) { var model = new EdmModel(); var container = new EdmEntityContainer("namespace", "containerName"); var rootType = ConvertToEdmEntityType(schema, model, "root"); container.AddEntitySet("root", rootType); model.AddElement(container); return model; }
public IEdmModel BuildModel(IEnumerable<TableData> tables) { var model = new EdmModel(); var container = new EdmEntityContainer("sitecore.com", "Visits"); model.AddElement(container); var tableMap = new Dictionary<TableDataSchema, EdmEntityTypeWrapper>(); foreach (var table in tables) { var typeWrapper = AddTable(model, table); container.AddEntitySet(table.Name, typeWrapper.Type); tableMap.Add(table.Schema, typeWrapper); } foreach (var t in tableMap) { foreach (var reference in t.Key.RelatedTables) { if (reference.RelationType == RelationType.Child || reference.RelationType == RelationType.DimensionReference) { var source = t.Value; var target = tableMap[reference.RelatedTable]; t.Value.Type.AddBidirectionalNavigation(new EdmNavigationPropertyInfo() { Name = reference.RelatedTable.Name, TargetMultiplicity = EdmMultiplicity.Many, Target = target.Type }, new EdmNavigationPropertyInfo() { Name = t.Key.Name, TargetMultiplicity = reference.RelationType == RelationType.Child ? EdmMultiplicity.One : EdmMultiplicity.ZeroOrOne, DependentProperties = reference.RelatedFields.Select(f=>target.Properties[f]), Target = source.Type }); } } } return model; }
public void EntityContainer_Is_Default_ShowsUp_In_Metadata() { // Arrange EdmModel model = new EdmModel(); EdmEntityContainer container = new EdmEntityContainer("Default", "SampleContainer"); model.AddElement(container); // Act model.SetIsDefaultEntityContainer(container, isDefaultContainer: true); // Assert MemoryStream stream = new MemoryStream(); ODataMessageWriter writer = new ODataMessageWriter(new ODataMessageWrapper(stream) as IODataResponseMessage, new ODataMessageWriterSettings(), model); writer.WriteMetadataDocument(); stream.Seek(0, SeekOrigin.Begin); XElement element = XElement.Load(stream); var containerXml = element.Descendants().Where(n => n.Name.LocalName == "EntityContainer").SingleOrDefault(); Assert.Equal("SampleContainer", containerXml.Attribute("Name").Value); Assert.Equal("true", containerXml.Attributes().Where(a => a.Name.LocalName == "IsDefaultEntityContainer").Single().Value); }
public static IEdmModel BuildEdmModel(ODataModelBuilder builder) { if (builder == null) { throw Error.ArgumentNull("builder"); } EdmModel model = new EdmModel(); EdmEntityContainer container = new EdmEntityContainer(builder.Namespace, builder.ContainerName); // add types and sets, building an index on the way. Dictionary<string, IEdmStructuredType> edmTypeMap = model.AddTypes(builder.StructuralTypes); Dictionary<string, EdmEntitySet> edmEntitySetMap = model.AddEntitySets(builder.EntitySets, container, edmTypeMap); // add procedures container.AddProcedures(builder.Procedures, edmTypeMap, edmEntitySetMap); // finish up model.AddElement(container); return model; }
private static IEdmModel BuildModel(JObject viewObject, out IList<string> fieldsToIgnore) { var model = new EdmModel(); fieldsToIgnore = new List<string>(); var name = viewObject.PrimitivePropertyValue<string>("name"); name = name.Replace(' ', '_'); var entityType = new EdmEntityType(false, false, null, "OData4Socrata", name, Enumerable.Empty<IEdmStructuralProperty>()); var entitySet = new EdmEntitySet(name, entityType); EdmComplexType phoneComplex = null; EdmComplexType locationComplex = null; EdmComplexType urlComplex = null; foreach (var column in viewObject.ArrayPropertyValue<JObject>("columns")) { var fieldName = column.PrimitivePropertyValue<string>("name"); var sodaType = column.PrimitivePropertyValue<string>("dataTypeName"); IEdmTypeReference typeReference; switch (sodaType) { case "meta_data": fieldsToIgnore.Add(fieldName); continue; case "text": typeReference = EdmLibraryExtensions.GetPrimitiveTypeReference(typeof (string)); break; case "url": if (urlComplex == null) { urlComplex = new EdmComplexType(false, false, null, entityType.Namespace, "url"); new EdmStructuralProperty(urlComplex, "url", EdmLibraryExtensions.GetPrimitiveTypeReference(typeof (string)), null, EdmConcurrencyMode.None); model.AddElement(urlComplex); } typeReference = new EdmComplexTypeReference(urlComplex, false); break; case "phone": if (phoneComplex == null) { phoneComplex = new EdmComplexType(false, false, null, entityType.Namespace, "phone"); new EdmStructuralProperty(phoneComplex, "phone_number", EdmLibraryExtensions.GetPrimitiveTypeReference(typeof (string)), null, EdmConcurrencyMode.None); new EdmStructuralProperty(phoneComplex, "phone_type", EdmLibraryExtensions.GetPrimitiveTypeReference(typeof (string)), null, EdmConcurrencyMode.None); model.AddElement(phoneComplex); } typeReference = new EdmComplexTypeReference(phoneComplex, false); break; case "location": if (locationComplex == null) { locationComplex = new EdmComplexType(false, false, null, entityType.Namespace, "location"); new EdmStructuralProperty(locationComplex, "human_address", EdmLibraryExtensions.GetPrimitiveTypeReference(typeof (string)), null, EdmConcurrencyMode.None); new EdmStructuralProperty(locationComplex, "latitude", EdmLibraryExtensions.GetPrimitiveTypeReference(typeof (string)), null, EdmConcurrencyMode.None); new EdmStructuralProperty(locationComplex, "longitude", EdmLibraryExtensions.GetPrimitiveTypeReference(typeof (string)), null, EdmConcurrencyMode.None); new EdmStructuralProperty(locationComplex, "machine_address", EdmLibraryExtensions.GetPrimitiveTypeReference(typeof (string)), null, EdmConcurrencyMode.None); new EdmStructuralProperty(locationComplex, "needs_recoding", EdmLibraryExtensions.GetPrimitiveTypeReference(typeof (bool)), null, EdmConcurrencyMode.None); model.AddElement(locationComplex); } typeReference = new EdmComplexTypeReference(locationComplex, false); break; default: throw new Exception(); } new EdmStructuralProperty(entityType, fieldName, typeReference, null, EdmConcurrencyMode.None); } model.AddElement(entityType); var entityContainer = new EdmEntityContainer(); model.AddEntityContainer(entityContainer); entityContainer.AddElement(entitySet); return model; }
EdmEntityTypeWrapper AddTable(EdmModel model, TableData dataBuilder) { var propertyMap = new Dictionary<Field, EdmStructuralProperty>(); var table = new EdmEntityType("sitecore.com", dataBuilder.Name); foreach (var field in dataBuilder.Schema.Fields) { var prop = table.AddStructuralProperty(field.Name, GetEdmType(field.ValueType), IsNullable(field.ValueType)); if (field.FieldType == FieldType.Key) { table.AddKeys(prop); } propertyMap.Add(field, prop); } model.AddElement(table); return new EdmEntityTypeWrapper {Type = table, Properties = propertyMap}; }
public void ToDictionary_AppliesMappingToAllProperties_IfInstanceIsNotNull() { // Arrange EdmEntityType entityType = new EdmEntityType("NS", "Name"); entityType.AddStructuralProperty("SampleProperty", EdmPrimitiveTypeKind.Int32); EdmModel model = new EdmModel(); model.AddElement(entityType); model.SetAnnotationValue(entityType, new ClrTypeAnnotation(typeof(TestEntity))); IEdmTypeReference edmType = new EdmEntityTypeReference(entityType, isNullable: false); SelectExpandWrapper<TestEntity> testWrapper = new SelectExpandWrapper<TestEntity> { Instance = new TestEntity { SampleProperty = 42 }, ModelID = ModelContainer.GetModelID(model) }; Mock<IPropertyMapper> mapperMock = new Mock<IPropertyMapper>(); mapperMock.Setup(m => m.MapProperty("SampleProperty")).Returns("Sample"); Func<IEdmModel, IEdmStructuredType, IPropertyMapper> mapperProvider = (IEdmModel m, IEdmStructuredType t) => mapperMock.Object; // Act var result = testWrapper.ToDictionary(mapperProvider); // Assert Assert.Equal(42, result["Sample"]); }
public void CreateTypeNameExpression_ReturnsConditionalExpression_IfTypeHasDerivedTypes() { // Arrange IEdmEntityType baseType = new EdmEntityType("NS", "BaseType"); IEdmEntityType typeA = new EdmEntityType("NS", "A", baseType); IEdmEntityType typeB = new EdmEntityType("NS", "B", baseType); IEdmEntityType typeAA = new EdmEntityType("NS", "AA", typeA); IEdmEntityType typeAAA = new EdmEntityType("NS", "AAA", typeAA); IEdmEntityType[] types = new[] { baseType, typeA, typeAAA, typeB, typeAA }; EdmModel model = new EdmModel(); foreach (var type in types) { model.AddElement(type); model.SetAnnotationValue(type, new ClrTypeAnnotation(new MockType(type.Name, @namespace: type.Namespace))); } Expression source = Expression.Constant(42); // Act Expression result = SelectExpandBinder.CreateTypeNameExpression(source, baseType, model); // Assert Assert.Equal( result.ToString(), @"IIF((42 Is AAA), ""NS.AAA"", IIF((42 Is AA), ""NS.AA"", IIF((42 Is B), ""NS.B"", IIF((42 Is A), ""NS.A"", ""NS.BaseType""))))"); }
public void Property_EntityInstance_EdmObjectHasCollectionProperty() { // Arrange EdmEntityType edmType = new EdmEntityType("NS", "Name"); edmType.AddStructuralProperty( "CollectionProperty", new EdmCollectionTypeReference( new EdmCollectionType(EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.Int32, isNullable: false)), isNullable: false)); EdmModel model = new EdmModel(); model.AddElement(edmType); model.SetAnnotationValue<ClrTypeAnnotation>(edmType, new ClrTypeAnnotation(typeof(TestEntity))); Mock<IEdmStructuredObject> edmObject = new Mock<IEdmStructuredObject>(); object propertyValue = new List<int> { 42 }; edmObject.Setup(e => e.TryGetValue("CollectionProperty", out propertyValue)).Returns(true); edmObject.Setup(e => e.GetEdmType()).Returns(new EdmEntityTypeReference(edmType, isNullable: false)); EntityInstanceContext entityContext = new EntityInstanceContext { EdmModel = model, EdmObject = edmObject.Object, EntityType = edmType }; // Act object resource = entityContext.EntityInstance; // Assert TestEntity testEntity = Assert.IsType<TestEntity>(resource); Assert.Equal(new[] { 42 }, testEntity.CollectionProperty); }
public CustomersModelWithInheritance() { EdmModel model = new EdmModel(); // complex type address EdmComplexType address = new EdmComplexType("NS", "Address"); address.AddStructuralProperty("Street", EdmPrimitiveTypeKind.String); address.AddStructuralProperty("City", EdmPrimitiveTypeKind.String); address.AddStructuralProperty("State", EdmPrimitiveTypeKind.String); address.AddStructuralProperty("ZipCode", EdmPrimitiveTypeKind.String); address.AddStructuralProperty("Country", EdmPrimitiveTypeKind.String); model.AddElement(address); // entity type customer EdmEntityType customer = new EdmEntityType("NS", "Customer"); customer.AddKeys(customer.AddStructuralProperty("ID", EdmPrimitiveTypeKind.Int32)); customer.AddStructuralProperty("Name", EdmPrimitiveTypeKind.String); customer.AddStructuralProperty("Address", new EdmComplexTypeReference(address, isNullable: true)); model.AddElement(customer); // derived entity type special customer EdmEntityType specialCustomer = new EdmEntityType("NS", "SpecialCustomer", customer); specialCustomer.AddStructuralProperty("SpecialCustomerProperty", EdmPrimitiveTypeKind.Guid); model.AddElement(specialCustomer); // entity type order EdmEntityType order = new EdmEntityType("NS", "Order"); order.AddKeys(order.AddStructuralProperty("ID", EdmPrimitiveTypeKind.Int32)); order.AddStructuralProperty("Amount", EdmPrimitiveTypeKind.Int32); model.AddElement(order); // derived entity type special order EdmEntityType specialOrder = new EdmEntityType("NS", "SpecialOrder", order); specialOrder.AddStructuralProperty("SpecialOrderProperty", EdmPrimitiveTypeKind.Guid); model.AddElement(specialOrder); // entity sets EdmEntityContainer container = new EdmEntityContainer("NS", "ModelWithInheritance"); model.AddElement(container); EdmEntitySet customers = container.AddEntitySet("Customers", customer); EdmEntitySet orders = container.AddEntitySet("Orders", order); // actions EdmFunctionImport upgradeCustomer = container.AddFunctionImport( "upgrade", returnType: null, entitySet: new EdmEntitySetReferenceExpression(customers), sideEffecting: true, composable: false, bindable: true); upgradeCustomer.AddParameter("entity", new EdmEntityTypeReference(customer, false)); EdmFunctionImport upgradeSpecialCustomer = container.AddFunctionImport( "specialUpgrade", returnType: null, entitySet: new EdmEntitySetReferenceExpression(customers), sideEffecting: true, composable: false, bindable: true); upgradeSpecialCustomer.AddParameter("entity", new EdmEntityTypeReference(specialCustomer, false)); // navigation properties customers.AddNavigationTarget( customer.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo { Name = "Orders", TargetMultiplicity = EdmMultiplicity.Many, Target = order }), orders); orders.AddNavigationTarget( order.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo { Name = "Customer", TargetMultiplicity = EdmMultiplicity.ZeroOrOne, Target = customer }), customers); // navigation properties on derived types. customers.AddNavigationTarget( specialCustomer.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo { Name = "SpecialOrders", TargetMultiplicity = EdmMultiplicity.Many, Target = order }), orders); orders.AddNavigationTarget( specialOrder.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo { Name = "SpecialCustomer", TargetMultiplicity = EdmMultiplicity.ZeroOrOne, Target = customer }), customers); model.SetAnnotationValue<BindableProcedureFinder>(model, new BindableProcedureFinder(model)); // set properties Model = model; Container = container; Customer = customer; Order = order; Address = address; SpecialCustomer = specialCustomer; SpecialOrder = specialOrder; Orders = orders; Customers = customers; UpgradeCustomer = upgradeCustomer; }
public void ToDictionary_Throws_IfMapperProvider_ReturnsNullPropertyMapper() { // Arrange EdmEntityType entityType = new EdmEntityType("NS", "Name"); entityType.AddStructuralProperty("SampleProperty", EdmPrimitiveTypeKind.Int32); EdmModel model = new EdmModel(); model.AddElement(entityType); model.SetAnnotationValue(entityType, new ClrTypeAnnotation(typeof(TestEntity))); IEdmTypeReference edmType = new EdmEntityTypeReference(entityType, isNullable: false); SelectExpandWrapper<TestEntity> wrapper = new SelectExpandWrapper<TestEntity> { Instance = new TestEntity { SampleProperty = 42 }, ModelID = ModelContainer.GetModelID(model) }; Func<IEdmModel, IEdmStructuredType, IPropertyMapper> mapperProvider = (IEdmModel m, IEdmStructuredType t) => null; // Act & Assert Assert.Throws<InvalidOperationException>(() => wrapper.ToDictionary(mapperProvider: mapperProvider), "The mapper provider must return a valid 'System.Web.Http.OData.Query.IPropertyMapper' instance for the given 'NS.Name' IEdmType."); }
public void CreateTypeNameExpression_ReturnsNull_IfTypeHasNoDerivedTypes() { // Arrange IEdmEntityType baseType = new EdmEntityType("NS", "BaseType"); EdmModel model = new EdmModel(); model.AddElement(baseType); Expression source = Expression.Constant(42); // Act Expression result = SelectExpandBinder.CreateTypeNameExpression(source, baseType, model); // Assert Assert.Null(result); }
public void CreateTypeNameExpression_ThrowsODataException_IfTypeHasNoMapping() { // Arrange IEdmEntityType baseType = new EdmEntityType("NS", "BaseType"); IEdmEntityType derivedType = new EdmEntityType("NS", "DerivedType", baseType); EdmModel model = new EdmModel(); model.AddElement(baseType); model.AddElement(derivedType); Expression source = Expression.Constant(42); // Act & Assert Assert.Throws<ODataException>( () => SelectExpandBinder.CreateTypeNameExpression(source, baseType, model), "The provided mapping doesn't contain an entry for the entity type 'NS.DerivedType'."); }
public static IEdmModel BuildEdmModel(string containerNamespace, string containerName, IEnumerable<IStructuralTypeConfiguration> entityTypeConfigurations, IEnumerable<IEntitySetConfiguration> entitySetConfigurations) { if (entityTypeConfigurations == null) { throw Error.ArgumentNull("entityTypeConfigurations"); } if (entitySetConfigurations == null) { throw Error.ArgumentNull("entitySetConfigurations"); } EdmModel model = new EdmModel(); Dictionary<string, IEdmStructuredType> types = EdmTypeBuilder.GetTypes(entityTypeConfigurations) .OfType<IEdmStructuredType>() .ToDictionary(t => t.ToString()); foreach (IEdmStructuredType type in types.Values) { if (type.TypeKind == EdmTypeKind.Complex) { model.AddElement(type as IEdmComplexType); } else if (type.TypeKind == EdmTypeKind.Entity) { model.AddElement(type as IEdmEntityType); } else { throw Error.InvalidOperation(SRResources.UnsupportedEntityTypeInModel); } } if (entitySetConfigurations.Any()) { EdmEntityContainer container = new EdmEntityContainer(containerNamespace, containerName); Dictionary<string, EdmEntitySet> edmEntitySetMap = new Dictionary<string, EdmEntitySet>(); foreach (IEntitySetConfiguration entitySet in entitySetConfigurations) { EdmEntitySet edmEntitySet = container.AddEntitySet(entitySet.Name, (IEdmEntityType)types[entitySet.EntityType.FullName]); EntitySetLinkBuilderAnnotation entitySetLinkBuilderAnnotation = new EntitySetLinkBuilderAnnotation(entitySet); model.SetEntitySetLinkBuilderAnnotation(edmEntitySet, entitySetLinkBuilderAnnotation); model.SetAnnotationValue<EntitySetUrlAnnotation>(edmEntitySet, new EntitySetUrlAnnotation { Url = entitySet.GetUrl() }); edmEntitySetMap.Add(edmEntitySet.Name, edmEntitySet); } foreach (IEntitySetConfiguration entitySet in entitySetConfigurations) { EdmEntitySet edmEntitySet = edmEntitySetMap[entitySet.Name]; EntitySetLinkBuilderAnnotation entitySetLinkBuilderAnnotation = model.GetEntitySetLinkBuilder(edmEntitySet) as EntitySetLinkBuilderAnnotation; foreach (NavigationPropertyConfiguration navigation in entitySet.EntityType.NavigationProperties) { NavigationPropertyBinding binding = entitySet.FindBinding(navigation); if (binding != null) { EdmEntityType edmEntityType = types[entitySet.EntityType.FullName] as EdmEntityType; IEdmNavigationProperty edmNavigationProperty = edmEntityType.NavigationProperties().Single(np => np.Name == navigation.Name); edmEntitySet.AddNavigationTarget(edmNavigationProperty, edmEntitySetMap[binding.EntitySet.Name]); entitySetLinkBuilderAnnotation.AddNavigationPropertyLinkBuilder(edmNavigationProperty, entitySet.GetNavigationPropertyLink(edmNavigationProperty.Name)); } } } model.AddElement(container); } return model; }
private static IEdmModel CreateModel() { var model = new EdmModel(); var orderType = new EdmEntityType("Default", "Order"); orderType.AddStructuralProperty("ID", EdmPrimitiveTypeKind.Int32); model.AddElement(orderType); var customerType = new EdmEntityType("Default", "Customer"); customerType.AddStructuralProperty("ID", EdmPrimitiveTypeKind.Int32); model.AddElement(customerType); // Add navigations orderType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo() { Name = "Customer", Target = customerType, TargetMultiplicity = EdmMultiplicity.One }); var container = new EdmEntityContainer("Default", "Container"); var orderSet = container.AddEntitySet("Orders", orderType); var customerSet = container.AddEntitySet("Customers", customerType); container.AddFunctionImport("GetId", new EdmPrimitiveTypeReference( EdmCoreModel.Instance.GetPrimitiveType(EdmPrimitiveTypeKind.Int32), true)); orderSet.AddNavigationTarget(orderType.NavigationProperties().Single(np => np.Name == "Customer"), customerSet); model.AddElement(container); return model; }
public void ToDictionary_ContainsAllProperties_FromContainer() { // Arrange EdmEntityType entityType = new EdmEntityType("NS", "Name"); entityType.AddStructuralProperty("SampleProperty", EdmPrimitiveTypeKind.Int32); EdmModel model = new EdmModel(); model.AddElement(entityType); model.SetAnnotationValue(entityType, new ClrTypeAnnotation(typeof(TestEntity))); MockPropertyContainer container = new MockPropertyContainer(); container.Properties.Add("Property", 42); SelectExpandWrapper<TestEntity> wrapper = new SelectExpandWrapper<TestEntity> { Container = container, ModelID = ModelContainer.GetModelID(model) }; // Act var result = wrapper.ToDictionary(); // Assert Assert.Equal(42, result["Property"]); }
public void Property_EntityInstance_CanBeBuiltFromIEdmObject() { // Arrange EdmEntityType edmType = new EdmEntityType("NS", "Name"); edmType.AddStructuralProperty("Property", EdmPrimitiveTypeKind.Int32); EdmModel model = new EdmModel(); model.AddElement(edmType); model.SetAnnotationValue<ClrTypeAnnotation>(edmType, new ClrTypeAnnotation(typeof(TestEntity))); Mock<IEdmEntityObject> edmObject = new Mock<IEdmEntityObject>(); object propertyValue = 42; edmObject.Setup(e => e.TryGetPropertyValue("Property", out propertyValue)).Returns(true); edmObject.Setup(e => e.GetEdmType()).Returns(new EdmEntityTypeReference(edmType, isNullable: false)); EntityInstanceContext entityContext = new EntityInstanceContext { EdmModel = model, EdmObject = edmObject.Object, EntityType = edmType }; // Act object resource = entityContext.EntityInstance; // Assert TestEntity testEntity = Assert.IsType<TestEntity>(resource); Assert.Equal(42, testEntity.Property); }
public void ToDictionary_Throws_IfMappingIsNullOrEmpty_ForAGivenProperty(string propertyMapping) { // Arrange EdmEntityType entityType = new EdmEntityType("NS", "Name"); entityType.AddStructuralProperty("SampleProperty", EdmPrimitiveTypeKind.Int32); EdmModel model = new EdmModel(); model.AddElement(entityType); model.SetAnnotationValue(entityType, new ClrTypeAnnotation(typeof(TestEntity))); IEdmTypeReference edmType = new EdmEntityTypeReference(entityType, isNullable: false); SelectExpandWrapper<TestEntity> testWrapper = new SelectExpandWrapper<TestEntity> { Instance = new TestEntity { SampleProperty = 42 }, ModelID = ModelContainer.GetModelID(model) }; Mock<IPropertyMapper> mapperMock = new Mock<IPropertyMapper>(); mapperMock.Setup(m => m.MapProperty("SampleProperty")).Returns(propertyMapping); Func<IEdmModel, IEdmStructuredType, IPropertyMapper> mapperProvider = (IEdmModel m, IEdmStructuredType t) => mapperMock.Object; // Act & Assert Assert.Throws<InvalidOperationException>(() => testWrapper.ToDictionary(mapperProvider), "The key mapping for the property 'SampleProperty' can't be null or empty."); }
public void ToDictionary_ContainsAllStructuralProperties_IfInstanceIsNotNull() { // Arrange EdmModel model = new EdmModel(); EdmEntityType entityType = new EdmEntityType("NS", "Name"); model.AddElement(entityType); model.SetAnnotationValue(entityType, new ClrTypeAnnotation(typeof(TestEntity))); entityType.AddStructuralProperty("SampleProperty", EdmPrimitiveTypeKind.Int32); IEdmTypeReference edmType = new EdmEntityTypeReference(entityType, isNullable: false); SelectExpandWrapper<TestEntity> testWrapper = new SelectExpandWrapper<TestEntity> { Instance = new TestEntity { SampleProperty = 42 }, ModelID = ModelContainer.GetModelID(model) }; // Act var result = testWrapper.ToDictionary(); // Assert Assert.Equal(42, result["SampleProperty"]); }
public void DollarMetadata_Works_WithMultipleReferentialConstraints_ForUntypedModel() { // Arrange EdmModel model = new EdmModel(); EdmEntityType customer = new EdmEntityType("DefaultNamespace", "Customer"); customer.AddKeys(customer.AddStructuralProperty("CustomerId", EdmCoreModel.Instance.GetInt32(false))); customer.AddStructuralProperty("Name", EdmCoreModel.Instance.GetString(false)); model.AddElement(customer); EdmEntityType order = new EdmEntityType("DefaultNamespace", "Order"); order.AddKeys(order.AddStructuralProperty("OrderId", EdmCoreModel.Instance.GetInt32(false))); EdmStructuralProperty orderCustomerId = order.AddStructuralProperty("CustomerForeignKey", EdmCoreModel.Instance.GetInt32(true)); model.AddElement(order); customer.AddBidirectionalNavigation( new EdmNavigationPropertyInfo { Name = "Orders", Target = order, TargetMultiplicity = EdmMultiplicity.Many }, new EdmNavigationPropertyInfo { Name = "Customer", TargetMultiplicity = EdmMultiplicity.ZeroOrOne, DependentProperties = new[] { orderCustomerId }, }); const string expect = " <ReferentialConstraint>\r\n" + " <Principal Role=\"Customer\">\r\n" + " <PropertyRef Name=\"CustomerId\" />\r\n" + " </Principal>\r\n" + " <Dependent Role=\"Orders\">\r\n" + " <PropertyRef Name=\"CustomerForeignKey\" />\r\n" + " </Dependent>\r\n" + " </ReferentialConstraint>"; HttpServer server = new HttpServer(); server.Configuration.Routes.MapODataServiceRoute("odata", "odata", model); HttpClient client = new HttpClient(server); // Act HttpResponseMessage response = client.GetAsync("http://localhost/odata/$metadata").Result; // Assert Assert.True(response.IsSuccessStatusCode); Assert.Equal("application/xml", response.Content.Headers.ContentType.MediaType); Assert.Contains(expect, response.Content.ReadAsStringAsync().Result); }