public void ConvertFunction()
{
var taupoModel = new EntityModelSchema()
{
new Function("NS1", "Function1")
{
ReturnType = EdmDataTypes.Int32,
Parameters =
{
new FunctionParameter("Param1", EdmDataTypes.Int32, FunctionParameterMode.InOut),
new FunctionParameter("Param2", EdmDataTypes.Int32, FunctionParameterMode.Out)
{
new AttributeAnnotation()
{
Content = new XAttribute(this.annotationNamespace + "foo1","bar1")
},
},
},
Annotations =
{
new AttributeAnnotation()
{
Content = new XAttribute(this.annotationNamespace + "foo2", "bar2")
},
},
},
};
IEdmModel result = this.converter.ConvertToEdmModel(taupoModel);
Assert.AreEqual(1, result.SchemaElements.Count());
Assert.AreEqual(1, result.SchemaElements.OfType <IEdmOperation>().Count());
IEdmOperation operation = result.SchemaElements.OfType <IEdmOperation>().First();
Assert.AreEqual("NS1.Function1", operation.FullName());
Assert.AreEqual("Edm.Int32", operation.ReturnType.FullName());
Assert.AreEqual(2, operation.Parameters.Count());
IEdmOperationParameter p1 = operation.Parameters.ElementAt(0);
Assert.AreEqual("Param1", p1.Name);
IEdmOperationParameter p2 = operation.Parameters.ElementAt(1);
Assert.AreEqual("Param2", p2.Name);
Assert.AreEqual(1, result.DirectValueAnnotations(p2).Count());
Assert.AreEqual("bogus", result.DirectValueAnnotations(p2).First().NamespaceUri);
Assert.AreEqual("foo1", result.DirectValueAnnotations(p2).First().Name);
Assert.AreEqual("bar1", (((IEdmDirectValueAnnotation)result.DirectValueAnnotations(p2).First()).Value as IEdmStringValue).Value);
Assert.AreEqual(1, result.DirectValueAnnotations(operation).Count());
Assert.AreEqual("bogus", result.DirectValueAnnotations(operation).First().NamespaceUri);
Assert.AreEqual("foo2", result.DirectValueAnnotations(operation).First().Name);
Assert.AreEqual("bar2", (((IEdmDirectValueAnnotation)result.DirectValueAnnotations(operation).First()).Value as IEdmStringValue).Value);
}
private void VisitDirectAnnotations(IEdmElement element)
{
IEnumerable <IEdmDirectValueAnnotation> annotations = _model.DirectValueAnnotations(element);
foreach (var annotation in annotations)
{
VisitDirectAnnotation(annotation);
}
}
private void SetImmediateAnnotations(IEdmElement edmAnnotatable, IEdmElement stockAnnotatable, IEdmModel edmModel, EdmModel stockModel)
{
IEnumerable<IEdmDirectValueAnnotation> annotations = edmModel.DirectValueAnnotations(edmAnnotatable);
foreach (IEdmDirectValueAnnotation annotation in annotations)
{
var annotationValue = annotation.Value;
string annotationNamespace = annotation.NamespaceUri;
string annotationName = annotation.Name;
stockModel.SetAnnotationValue(stockAnnotatable, annotationNamespace, annotationName, annotationValue);
}
}
private void SetImmediateAnnotations(IEdmElement edmAnnotatable, IEdmElement stockAnnotatable, IEdmModel edmModel, EdmModel stockModel)
{
IEnumerable <IEdmDirectValueAnnotation> annotations = edmModel.DirectValueAnnotations(edmAnnotatable);
foreach (IEdmDirectValueAnnotation annotation in annotations)
{
var annotationValue = annotation.Value;
string annotationNamespace = annotation.NamespaceUri;
string annotationName = annotation.Name;
stockModel.SetAnnotationValue(stockAnnotatable, annotationNamespace, annotationName, annotationValue);
}
}
internal static IEnumerable <IEdmDirectValueAnnotation> GetODataAnnotations(this IEdmModel model, IEdmElement annotatable)
{
IEnumerable <IEdmDirectValueAnnotation> enumerable = model.DirectValueAnnotations(annotatable);
if (enumerable == null)
{
return(null);
}
return(from a in enumerable
where a.NamespaceUri == "http://schemas.microsoft.com/ado/2007/08/dataservices/metadata"
select a);
}
/// <summary>
/// Gets all the serializable annotations in the OData metadata namespace on the <paramref name="annotatable"/>.
/// </summary>
/// <param name="model">The <see cref="IEdmModel"/> containing the annotations."/></param>
/// <param name="annotatable">The <see cref="IEdmElement"/> to get the annotations from.</param>
/// <returns>All annotations in the OData metadata namespace; or null if no annotations are found.</returns>
internal static IEnumerable <IEdmDirectValueAnnotation> GetODataAnnotations(this IEdmModel model, IEdmElement annotatable)
{
Debug.Assert(model != null, "model != null");
Debug.Assert(annotatable != null, "annotatable != null");
IEnumerable <IEdmDirectValueAnnotation> annotations = model.DirectValueAnnotations(annotatable);
if (annotations == null)
{
return(null);
}
return(annotations.Where(a => a.NamespaceUri == ODataMetadataConstants.ODataMetadataNamespace));
}
public void ConvertEntityContainer()
{
var taupoModel = new EntityModelSchema()
{
new EntityContainer("MyContainer")
{
new EntitySet("Customers", "Customer"),
new EntitySet("Orders", "Order")
{
new AttributeAnnotation()
{
Content = new XAttribute(this.annotationNamespace + "foo1", "bar1")
},
},
new AssociationSet("CustomerOrders", "CustomerOrder")
{
new AssociationSetEnd("Order", "Orders"),
new AssociationSetEnd("Customer", "Customers")
},
new FunctionImport("FunctionImport1")
{
ReturnTypes = { new FunctionImportReturnType(DataTypes.CollectionOfEntities("Customer"), "Customers") },
Parameters = { new FunctionParameter("ExcludingId", EdmDataTypes.Int32) },
Annotations = { new AttributeAnnotation()
{
Content = new XAttribute(this.annotationNamespace + "foo5", "bar5")
} },
},
new AttributeAnnotation()
{
Content = new XAttribute(this.annotationNamespace + "foo4", "bar4")
},
},
new EntityType("Customer")
{
new MemberProperty("Id", EdmDataTypes.Int32)
{
IsPrimaryKey = true
},
},
new EntityType("Order")
{
new MemberProperty("Id", EdmDataTypes.Int32)
{
IsPrimaryKey = true
},
},
new AssociationType("CustomerOrder")
{
new AssociationEnd("Customer", "Customer", EndMultiplicity.One, OperationAction.Cascade),
new AssociationEnd("Order", "Order", EndMultiplicity.Many),
},
}
.ApplyDefaultNamespace("NS1")
.Resolve();
IEdmModel result = this.converter.ConvertToEdmModel(taupoModel);
IEdmEntityType customer = (IEdmEntityType)result.FindType("NS1.Customer");
IEdmEntityType order = (IEdmEntityType)result.FindType("NS1.Order");
IEdmEntityContainer convertedContainer = result.EntityContainer;
Assert.AreEqual("MyContainer", convertedContainer.Name);
Assert.AreEqual(3, convertedContainer.Elements.Count());
Assert.AreEqual(2, convertedContainer.Elements.OfType <IEdmEntitySet>().Count());
Assert.AreEqual(1, convertedContainer.Elements.OfType <IEdmOperationImport>().Count());
Assert.AreEqual(1, result.DirectValueAnnotations(convertedContainer).Count());
Assert.AreEqual("bogus", result.DirectValueAnnotations(convertedContainer).First().NamespaceUri);
Assert.AreEqual("foo4", result.DirectValueAnnotations(convertedContainer).First().Name);
Assert.AreEqual("bar4", (((IEdmDirectValueAnnotation)result.DirectValueAnnotations(convertedContainer).First()).Value as IEdmStringValue).Value);
IEdmEntitySet convertedCustomerSet = convertedContainer.Elements.OfType <IEdmEntitySet>().ElementAt(0);
Assert.AreEqual("Customers", convertedCustomerSet.Name);
Assert.AreEqual(result.FindType("NS1.Customer"), convertedCustomerSet.ElementType);
Assert.AreEqual(0, result.DirectValueAnnotations(convertedCustomerSet).Count(a => a.NamespaceUri == "bogus"));
IEdmEntitySet convertedOrderSet = convertedContainer.Elements.OfType <IEdmEntitySet>().ElementAt(1);
Assert.AreEqual("Orders", convertedOrderSet.Name);
Assert.AreEqual(result.FindType("NS1.Order"), convertedOrderSet.ElementType);
var annotations = result.DirectValueAnnotations(convertedOrderSet).Where(a => a.NamespaceUri == "bogus");
Assert.AreEqual(1, annotations.Count());
Assert.AreEqual("foo1", annotations.First().Name);
Assert.AreEqual("bar1", (((IEdmDirectValueAnnotation)annotations.First()).Value as IEdmStringValue).Value);
var toOrder = customer.NavigationProperties().First();
Assert.AreSame(convertedOrderSet, convertedCustomerSet.FindNavigationTarget(toOrder));
Assert.AreEqual("CustomerOrders", result.GetAssociationSetName(convertedCustomerSet, toOrder));
var toCustomer = order.NavigationProperties().First();
Assert.AreSame(convertedCustomerSet, convertedOrderSet.FindNavigationTarget(toCustomer));
Assert.AreEqual("CustomerOrders", result.GetAssociationSetName(convertedOrderSet, toCustomer));
IEdmOperationImport convertedFunctionImport = convertedContainer.Elements.OfType <IEdmOperationImport>().First();
Assert.AreEqual("FunctionImport1", convertedFunctionImport.Name);
IEdmEntitySet eset;
Assert.IsTrue(convertedFunctionImport.TryGetStaticEntitySet(out eset));
Assert.AreEqual(convertedCustomerSet, eset);
Assert.AreEqual(EdmTypeKind.Collection, convertedFunctionImport.ReturnType.TypeKind());
Assert.AreEqual(null, convertedFunctionImport.ReturnType.FullName());
Assert.AreEqual(1, convertedFunctionImport.Parameters.Count());
Assert.AreEqual("ExcludingId", convertedFunctionImport.Parameters.First().Name);
Assert.AreEqual(EdmTypeKind.Primitive, convertedFunctionImport.Parameters.First().Type.TypeKind());
Assert.AreEqual(1, result.DirectValueAnnotations(convertedFunctionImport).Count());
Assert.AreEqual("bogus", result.DirectValueAnnotations(convertedFunctionImport).First().NamespaceUri);
Assert.AreEqual("foo5", result.DirectValueAnnotations(convertedFunctionImport).First().Name);
Assert.AreEqual("bar5", (((IEdmDirectValueAnnotation)result.DirectValueAnnotations(convertedFunctionImport).First()).Value as IEdmStringValue).Value);
}
public void ConvertAssociationType_WithRefrentialConstraint_WithNavigation()
{
var taupoModel = new EntityModelSchema()
{
new EntityType("Customer")
{
new MemberProperty("Id", EdmDataTypes.Int32)
{
IsPrimaryKey = true
},
new NavigationProperty("ToOrders", "CustomerOrder", "Customer", "Order")
{
new AttributeAnnotation()
{
Content = new XAttribute(this.annotationNamespace + "foo2", "bar2")
},
},
},
new EntityType("Order")
{
new MemberProperty("Id", EdmDataTypes.Int32)
{
IsPrimaryKey = true
},
new MemberProperty("cId", EdmDataTypes.Int32),
new NavigationProperty("ToCustomer", "CustomerOrder", "Order", "Customer")
},
new AssociationType("CustomerOrder")
{
new AssociationEnd("Customer", "Customer", EndMultiplicity.One, OperationAction.Cascade),
new AssociationEnd("Order", "Order", EndMultiplicity.Many),
new ReferentialConstraint()
.WithDependentProperties("Order", "cId")
.ReferencesPrincipalProperties("Customer", "Id"),
},
}
.ApplyDefaultNamespace("NS1")
.Resolve();
IEdmModel result = this.converter.ConvertToEdmModel(taupoModel);
IEdmEntityType customer = (IEdmEntityType)result.FindType("NS1.Customer");
IEdmEntityType order = (IEdmEntityType)result.FindType("NS1.Order");
Assert.AreEqual(1, customer.NavigationProperties().Count());
Assert.AreEqual(1, order.NavigationProperties().Count());
IEdmNavigationProperty toOrders = customer.NavigationProperties().First();
IEdmNavigationProperty toCustomer = order.NavigationProperties().First();
Assert.AreEqual("ToOrders", toOrders.Name);
Assert.IsFalse(toOrders.ContainsTarget);
Assert.IsInstanceOfType(toOrders.Type, typeof(IEdmCollectionTypeReference));
var elementTypeRef = ((IEdmCollectionTypeReference)toOrders.Type).CollectionDefinition().ElementType;
Assert.IsInstanceOfType(elementTypeRef, typeof(IEdmEntityTypeReference));
Assert.AreEqual(order, ((IEdmEntityTypeReference)elementTypeRef).EntityDefinition());
Assert.AreSame(customer, toOrders.DeclaringType);
Assert.AreSame(toCustomer, toOrders.Partner);
Assert.AreEqual(EdmOnDeleteAction.Cascade, toOrders.OnDelete);
Assert.AreEqual(true, toOrders.IsPrincipal);
Assert.IsNull(toOrders.DependentProperties);
Assert.AreEqual("ToCustomer", toCustomer.Name);
Assert.IsFalse(toCustomer.ContainsTarget);
Assert.IsInstanceOfType(toCustomer.Type, typeof(IEdmEntityTypeReference));
Assert.AreEqual(customer, ((IEdmEntityTypeReference)toCustomer.Type).EntityDefinition());
Assert.IsFalse(((IEdmEntityTypeReference)toCustomer.Type).IsNullable);
Assert.AreSame(order, toCustomer.DeclaringType);
Assert.AreSame(toOrders, toCustomer.Partner);
Assert.AreEqual(EdmOnDeleteAction.None, toCustomer.OnDelete);
Assert.AreEqual(false, toCustomer.IsPrincipal);
Assert.AreEqual(1, toCustomer.DependentProperties.Count());
Assert.AreSame(order.FindProperty("cId"), toCustomer.DependentProperties.ElementAt(0));
// check immediate annotation
var annotation = result.DirectValueAnnotations(toOrders).Single(a => a.NamespaceUri == "bogus");
Assert.AreEqual("foo2", annotation.Name);
Assert.AreEqual("bar2", (((IEdmDirectValueAnnotation)annotation).Value as IEdmStringValue).Value);
// check custom naming information
Assert.AreEqual("NS1.CustomerOrder", result.GetAssociationFullName(toOrders));
Assert.AreEqual("Customer", result.GetAssociationEndName(toOrders));
Assert.AreEqual("NS1.CustomerOrder", result.GetAssociationFullName(toCustomer));
Assert.AreEqual("Order", result.GetAssociationEndName(toCustomer));
}
public void ConvertComplexType()
{
var taupoModel = new EntityModelSchema()
{
new ComplexType("NS1", "Complex1")
{
new MemberProperty("p1", EdmDataTypes.Int32),
new MemberProperty("p2", EdmDataTypes.Int32.Nullable())
{
DefaultValue = 100,
Annotations =
{
new ConcurrencyTokenAnnotation(),
new AttributeAnnotation()
{
Content = new XAttribute(this.annotationNamespace + "foo1", "bar1")
},
},
},
new AttributeAnnotation()
{
Content = new XAttribute(this.annotationNamespace + "foo2", "bar2")
},
},
};
IEdmModel result = this.converter.ConvertToEdmModel(taupoModel);
Assert.IsNull(result.EntityContainer);
Assert.AreEqual(1, result.SchemaElements.Count());
Assert.AreEqual(1, result.SchemaElements.OfType <IEdmComplexType>().Count());
IEdmComplexType complex = result.SchemaElements.OfType <IEdmComplexType>().Single();
Assert.AreEqual("NS1.Complex1", complex.FullName());
Assert.IsNull(complex.BaseComplexType());
Assert.AreEqual(2, complex.DeclaredStructuralProperties().Count());
Assert.AreEqual(2, complex.StructuralProperties().Count());
IEdmStructuralProperty property = complex.DeclaredStructuralProperties().ElementAt(0);
IEdmTypeReference propertyType = property.Type;
Assert.AreEqual("p1", property.Name);
Assert.AreEqual("Edm.Int32", propertyType.FullName());
Assert.AreEqual(EdmTypeKind.Primitive, propertyType.TypeKind());
Assert.IsFalse(propertyType.IsNullable);
Assert.AreEqual(complex, property.DeclaringType);
Assert.AreEqual(EdmConcurrencyMode.None, property.ConcurrencyMode);
Assert.IsNull(property.DefaultValueString);
Assert.AreEqual(0, result.DirectValueAnnotations(property).Count());
property = complex.DeclaredStructuralProperties().ElementAt(1);
propertyType = property.Type;
Assert.AreEqual("p2", property.Name);
Assert.AreEqual("Edm.Int32", propertyType.FullName());
Assert.AreEqual(EdmTypeKind.Primitive, propertyType.TypeKind());
Assert.IsTrue(propertyType.IsNullable);
Assert.AreEqual(complex, property.DeclaringType);
Assert.AreEqual(EdmConcurrencyMode.Fixed, property.ConcurrencyMode);
Assert.AreEqual("100", property.DefaultValueString);
Assert.AreEqual(1, result.DirectValueAnnotations(complex).Count());
Assert.AreEqual("bogus", result.DirectValueAnnotations(complex).First().NamespaceUri);
Assert.AreEqual("foo2", result.DirectValueAnnotations(complex).First().Name);
Assert.AreEqual("bar2", (((IEdmDirectValueAnnotation)result.DirectValueAnnotations(complex).First()).Value as IEdmStringValue).Value);
Assert.AreEqual(1, result.DirectValueAnnotations(property).Count());
Assert.AreEqual("bogus", result.DirectValueAnnotations(property).First().NamespaceUri);
Assert.AreEqual("foo1", result.DirectValueAnnotations(property).First().Name);
Assert.AreEqual("bar1", (((IEdmDirectValueAnnotation)result.DirectValueAnnotations(property).First()).Value as IEdmStringValue).Value);
}
public void ConvertEntityType()
{
var taupoModel = new EntityModelSchema()
{
new EntityType("NS1", "Entity1")
{
new MemberProperty("p1", EdmDataTypes.Int16)
{
new AttributeAnnotation()
{
Content = new XAttribute(this.annotationNamespace + "foo1", "bar1")
},
},
new MemberProperty("p2", EdmDataTypes.Int64)
{
IsPrimaryKey = true
},
new MemberProperty("p3", EdmDataTypes.Boolean)
{
IsPrimaryKey = true
},
new AttributeAnnotation()
{
Content = new XAttribute(this.annotationNamespace + "foo2", "bar2")
},
},
};
IEdmModel result = this.converter.ConvertToEdmModel(taupoModel);
Assert.IsNull(result.EntityContainer);
Assert.AreEqual(1, result.SchemaElements.Count());
Assert.AreEqual(1, result.SchemaElements.OfType <IEdmEntityType>().Count());
IEdmEntityType entity = result.SchemaElements.OfType <IEdmEntityType>().First();
Assert.AreEqual("NS1.Entity1", entity.FullName());
Assert.AreEqual(3, entity.DeclaredStructuralProperties().Count());
Assert.AreEqual("p1", entity.DeclaredStructuralProperties().ElementAt(0).Name);
Assert.AreEqual("p2", entity.DeclaredStructuralProperties().ElementAt(1).Name);
Assert.AreEqual("p3", entity.DeclaredStructuralProperties().ElementAt(2).Name);
Assert.AreEqual(2, entity.DeclaredKey.Count());
Assert.AreEqual("p2", entity.DeclaredKey.ElementAt(0).Name);
Assert.AreEqual("p3", entity.DeclaredKey.ElementAt(1).Name);
Assert.AreEqual(1, result.DirectValueAnnotations(entity).Count());
Assert.AreEqual("bogus", result.DirectValueAnnotations(entity).First().NamespaceUri);
Assert.AreEqual("foo2", result.DirectValueAnnotations(entity).First().Name);
Assert.AreEqual("bar2", (((IEdmDirectValueAnnotation)result.DirectValueAnnotations(entity).First()).Value as IEdmStringValue).Value);
IEdmStructuralProperty p1 = entity.DeclaredStructuralProperties().ElementAt(0);
Assert.AreEqual(1, result.DirectValueAnnotations(p1).Count());
Assert.AreEqual("bogus", result.DirectValueAnnotations(p1).First().NamespaceUri);
Assert.AreEqual("foo1", result.DirectValueAnnotations(p1).First().Name);
Assert.AreEqual("bar1", (((IEdmDirectValueAnnotation)result.DirectValueAnnotations(p1).First()).Value as IEdmStringValue).Value);
IEdmStructuralProperty p2 = entity.DeclaredStructuralProperties().ElementAt(1);
Assert.AreEqual(0, result.DirectValueAnnotations(p2).Count());
}
