/// <summary>
/// Creates and adds a structural property to this type.
/// </summary>
/// <param name="name">Name of the property.</param>
/// <param name="type">Type of the property.</param>
/// <param name="defaultValue">The default value of this property.</param>
/// <param name="concurrencyMode">The concurrency mode of this property.</param>
/// <returns>Created structural property.</returns>
public EdmStructuralProperty AddStructuralProperty(string name, IEdmTypeReference type, string defaultValue, EdmConcurrencyMode concurrencyMode)
{
EdmStructuralProperty property = new EdmStructuralProperty(this, name, type, defaultValue, concurrencyMode);
this.AddProperty(property);
return(property);
}
public void TestCloneEdmnavigationPropertyInfo()
{
var type = new EdmEntityType("NS", "name");
var property1 = new EdmStructuralProperty(type, "property1", EdmCoreModel.Instance.GetInt32(false));
var property2 = new EdmStructuralProperty(type, "property2", EdmCoreModel.Instance.GetInt32(false));
EdmNavigationPropertyInfo navigationPropertyInfo = new EdmNavigationPropertyInfo
{
ContainsTarget = true,
DependentProperties = new[] {property1},
Name = "navPropInfo",
OnDelete = EdmOnDeleteAction.Cascade,
PrincipalProperties = new[] {property2},
Target = type,
TargetMultiplicity = EdmMultiplicity.Many
};
var cloneNavigationPropertyInfo = navigationPropertyInfo.Clone();
Assert.AreEqual(navigationPropertyInfo.ContainsTarget, cloneNavigationPropertyInfo.ContainsTarget);
Assert.AreEqual(navigationPropertyInfo.Name, cloneNavigationPropertyInfo.Name);
Assert.AreEqual(navigationPropertyInfo.DependentProperties, cloneNavigationPropertyInfo.DependentProperties);
Assert.AreEqual(navigationPropertyInfo.OnDelete, cloneNavigationPropertyInfo.OnDelete);
Assert.AreEqual(navigationPropertyInfo.Target, cloneNavigationPropertyInfo.Target);
Assert.AreEqual(navigationPropertyInfo.PrincipalProperties, cloneNavigationPropertyInfo.PrincipalProperties);
Assert.AreEqual(navigationPropertyInfo.TargetMultiplicity, cloneNavigationPropertyInfo.TargetMultiplicity);
}
/// <summary>
/// Creates and adds a nullable structural property to this type.
/// </summary>
/// <param name="name">Name of the property.</param>
/// <param name="type">Type of the property.</param>
/// <param name="isNullable">Flag specifying if the property is nullable.</param>
/// <returns>Created structural property.</returns>
public EdmStructuralProperty AddStructuralProperty(string name, EdmPrimitiveTypeKind type, bool isNullable)
{
EdmStructuralProperty property = new EdmStructuralProperty(this, name, EdmCoreModel.Instance.GetPrimitive(type, isNullable));
this.AddProperty(property);
return(property);
}
static InstanceAnnotationsReaderIntegrationTests()
{
EdmModel modelTmp = new EdmModel();
EntityType = new EdmEntityType("TestNamespace", "TestEntityType");
modelTmp.AddElement(EntityType);
var keyProperty = new EdmStructuralProperty(EntityType, "ID", EdmCoreModel.Instance.GetInt32(false));
EntityType.AddKeys(new IEdmStructuralProperty[] { keyProperty });
EntityType.AddProperty(keyProperty);
var resourceNavigationProperty = EntityType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo { Name = "ResourceNavigationProperty", Target = EntityType, TargetMultiplicity = EdmMultiplicity.ZeroOrOne });
var resourceSetNavigationProperty = EntityType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo { Name = "ResourceSetNavigationProperty", Target = EntityType, TargetMultiplicity = EdmMultiplicity.Many });
var defaultContainer = new EdmEntityContainer("TestNamespace", "DefaultContainer_sub");
modelTmp.AddElement(defaultContainer);
EntitySet = new EdmEntitySet(defaultContainer, "TestEntitySet", EntityType);
EntitySet.AddNavigationTarget(resourceNavigationProperty, EntitySet);
EntitySet.AddNavigationTarget(resourceSetNavigationProperty, EntitySet);
defaultContainer.AddElement(EntitySet);
Singleton = new EdmSingleton(defaultContainer, "TestSingleton", EntityType);
Singleton.AddNavigationTarget(resourceNavigationProperty, EntitySet);
Singleton.AddNavigationTarget(resourceSetNavigationProperty, EntitySet);
defaultContainer.AddElement(Singleton);
ComplexType = new EdmComplexType("TestNamespace", "TestComplexType");
ComplexType.AddProperty(new EdmStructuralProperty(ComplexType, "StringProperty", EdmCoreModel.Instance.GetString(false)));
modelTmp.AddElement(ComplexType);
Model = TestUtils.WrapReferencedModelsToMainModel("TestNamespace", "DefaultContainer", modelTmp);
}
public void EdmSingletonAnnotationTests()
{
EdmModel model = new EdmModel();
EdmStructuralProperty customerProperty = new EdmStructuralProperty(customerType, "Name", EdmCoreModel.Instance.GetString(false));
customerType.AddProperty(customerProperty);
model.AddElement(this.customerType);
EdmSingleton vipCustomer = new EdmSingleton(this.entityContainer, "VIP", this.customerType);
EdmTerm term = new EdmTerm(myNamespace, "SingletonAnnotation", EdmPrimitiveTypeKind.String);
var annotation = new EdmAnnotation(vipCustomer, term, new EdmStringConstant("Singleton Annotation"));
model.AddVocabularyAnnotation(annotation);
var singletonAnnotation = vipCustomer.VocabularyAnnotations(model).Single();
Assert.Equal(vipCustomer, singletonAnnotation.Target);
Assert.Equal("SingletonAnnotation", singletonAnnotation.Term.Name);
singletonAnnotation = model.FindDeclaredVocabularyAnnotations(vipCustomer).Single();
Assert.Equal(vipCustomer, singletonAnnotation.Target);
Assert.Equal("SingletonAnnotation", singletonAnnotation.Term.Name);
EdmTerm propertyTerm = new EdmTerm(myNamespace, "SingletonPropertyAnnotation", EdmPrimitiveTypeKind.String);
var propertyAnnotation = new EdmAnnotation(customerProperty, propertyTerm, new EdmStringConstant("Singleton Property Annotation"));
model.AddVocabularyAnnotation(propertyAnnotation);
var singletonPropertyAnnotation = customerProperty.VocabularyAnnotations(model).Single();
Assert.Equal(customerProperty, singletonPropertyAnnotation.Target);
Assert.Equal("SingletonPropertyAnnotation", singletonPropertyAnnotation.Term.Name);
}
/// <summary>
/// Creates and adds a structural property to this type.
/// </summary>
/// <param name="name">Name of the property.</param>
/// <param name="type">Type of the property.</param>
/// <returns>Created structural property.</returns>
public EdmStructuralProperty AddStructuralProperty(string name, IEdmTypeReference type)
{
EdmStructuralProperty property = new EdmStructuralProperty(this, name, type);
this.AddProperty(property);
return(property);
}
public static IEdmModel CreateModel(string ns)
{
EdmModel model = new EdmModel();
var defaultContainer = new EdmEntityContainer(ns, "DefaultContainer");
model.AddElement(defaultContainer);
var addressType = new EdmComplexType(ns, "Address");
addressType.AddProperty(new EdmStructuralProperty(addressType, "Road", EdmCoreModel.Instance.GetString(false)));
addressType.AddProperty(new EdmStructuralProperty(addressType, "City", EdmCoreModel.Instance.GetString(false)));
model.AddElement(addressType);
var personType = new EdmEntityType(ns, "Person");
var personIdProperty = new EdmStructuralProperty(personType, "PersonId", EdmCoreModel.Instance.GetInt32(false));
personType.AddProperty(personIdProperty);
personType.AddKeys(new IEdmStructuralProperty[] { personIdProperty });
personType.AddProperty(new EdmStructuralProperty(personType, "FirstName", EdmCoreModel.Instance.GetString(false)));
personType.AddProperty(new EdmStructuralProperty(personType, "LastName", EdmCoreModel.Instance.GetString(false)));
personType.AddProperty(new EdmStructuralProperty(personType, "Address", new EdmComplexTypeReference(addressType, true)));
personType.AddProperty(new EdmStructuralProperty(personType, "Descriptions", new EdmCollectionTypeReference(new EdmCollectionType(EdmCoreModel.Instance.GetString(false)))));
model.AddElement(personType);
var peopleSet = new EdmEntitySet(defaultContainer, "People", personType);
defaultContainer.AddElement(peopleSet);
var numberComboType = new EdmComplexType(ns, "NumberCombo");
numberComboType.AddProperty(new EdmStructuralProperty(numberComboType, "Small", EdmCoreModel.Instance.GetInt32(false)));
numberComboType.AddProperty(new EdmStructuralProperty(numberComboType, "Middle", EdmCoreModel.Instance.GetInt64(false)));
numberComboType.AddProperty(new EdmStructuralProperty(numberComboType, "Large", EdmCoreModel.Instance.GetDecimal(false)));
model.AddElement(numberComboType);
var productType = new EdmEntityType(ns, "Product");
var productIdProperty = new EdmStructuralProperty(productType, "ProductId", EdmCoreModel.Instance.GetInt32(false));
productType.AddProperty(productIdProperty);
productType.AddKeys(new IEdmStructuralProperty[] { productIdProperty });
productType.AddProperty(new EdmStructuralProperty(productType, "Quantity", EdmCoreModel.Instance.GetInt64(false)));
productType.AddProperty(new EdmStructuralProperty(productType, "LifeTimeInSeconds", EdmCoreModel.Instance.GetDecimal(false)));
productType.AddProperty(new EdmStructuralProperty(productType, "TheCombo", new EdmComplexTypeReference(numberComboType, true)));
productType.AddProperty(new EdmStructuralProperty(productType, "LargeNumbers", new EdmCollectionTypeReference(new EdmCollectionType(EdmCoreModel.Instance.GetDecimal(false)))));
model.AddElement(productType);
var productsSet = new EdmEntitySet(defaultContainer, "Products", productType);
defaultContainer.AddElement(productsSet);
var productsProperty = personType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo
{
Name = "Products",
Target = productType,
TargetMultiplicity = EdmMultiplicity.Many
});
peopleSet.AddNavigationTarget(productsProperty, productsSet);
IEnumerable<EdmError> errors;
model.Validate(out errors);
return model;
}
public static IEdmModel CreateServiceEdmModel(string ns)
{
EdmModel model = new EdmModel();
var defaultContainer = new EdmEntityContainer(ns, "PerfInMemoryContainer");
model.AddElement(defaultContainer);
var personType = new EdmEntityType(ns, "Person");
var personIdProperty = new EdmStructuralProperty(personType, "PersonID", EdmCoreModel.Instance.GetInt32(false));
personType.AddProperty(personIdProperty);
personType.AddKeys(new IEdmStructuralProperty[] { personIdProperty });
personType.AddProperty(new EdmStructuralProperty(personType, "FirstName", EdmCoreModel.Instance.GetString(false)));
personType.AddProperty(new EdmStructuralProperty(personType, "LastName", EdmCoreModel.Instance.GetString(false)));
personType.AddProperty(new EdmStructuralProperty(personType, "MiddleName", EdmCoreModel.Instance.GetString(true)));
personType.AddProperty(new EdmStructuralProperty(personType, "Age", EdmCoreModel.Instance.GetInt32(false)));
model.AddElement(personType);
var simplePersonSet = new EdmEntitySet(defaultContainer, "SimplePeopleSet", personType);
defaultContainer.AddElement(simplePersonSet);
var largetPersonSet = new EdmEntitySet(defaultContainer, "LargePeopleSet", personType);
defaultContainer.AddElement(largetPersonSet);
var addressType = new EdmComplexType(ns, "Address");
addressType.AddProperty(new EdmStructuralProperty(addressType, "Street", EdmCoreModel.Instance.GetString(false)));
addressType.AddProperty(new EdmStructuralProperty(addressType, "City", EdmCoreModel.Instance.GetString(false)));
addressType.AddProperty(new EdmStructuralProperty(addressType, "PostalCode", EdmCoreModel.Instance.GetString(false)));
model.AddElement(addressType);
var companyType = new EdmEntityType(ns, "Company");
var companyId = new EdmStructuralProperty(companyType, "CompanyID", EdmCoreModel.Instance.GetInt32(false));
companyType.AddProperty(companyId);
companyType.AddKeys(companyId);
companyType.AddProperty(new EdmStructuralProperty(companyType, "Name", EdmCoreModel.Instance.GetString(true)));
companyType.AddProperty(new EdmStructuralProperty(companyType, "Address", new EdmComplexTypeReference(addressType, true)));
companyType.AddProperty(new EdmStructuralProperty(companyType, "Revenue", EdmCoreModel.Instance.GetInt32(false)));
model.AddElement(companyType);
var companySet = new EdmEntitySet(defaultContainer, "CompanySet", companyType);
defaultContainer.AddElement(companySet);
var companyEmployeeNavigation = companyType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo()
{
Name = "Employees",
Target = personType,
TargetMultiplicity = EdmMultiplicity.Many
});
companySet.AddNavigationTarget(companyEmployeeNavigation, largetPersonSet);
// ResetDataSource
var resetDataSourceAction = new EdmAction(ns, "ResetDataSource", null, false, null);
model.AddElement(resetDataSourceAction);
defaultContainer.AddActionImport(resetDataSourceAction);
return model;
}
public CustomInstanceAnnotationRoundtripTests()
{
this.model = new EdmModel();
this.complexType = new EdmComplexType("ns", "ErrorDetails");
var property = new EdmStructuralProperty(complexType, "ErrorDetailName", EdmCoreModel.Instance.GetString(false));
this.complexType.AddProperty(property);
this.model.AddElement(complexType);
this.stream = new MemoryStream();
}
public void Initialize()
{
this.model = new EdmModel();
this.complexType = new EdmComplexType("ns", "ErrorDetails");
var property = new EdmStructuralProperty(complexType, "ErrorDetailName", EdmCoreModel.Instance.GetString(false));
this.complexType.AddProperty(property);
this.model.AddElement(complexType);
this.stream = new MemoryStream();
}
public ODataJsonLightReaderEnumIntegrationTests()
{
EdmModel tmpModel = new EdmModel();
// enum without flags
var enumType = new EdmEnumType("NS", "Color");
var red = new EdmEnumMember(enumType, "Red", new EdmIntegerConstant(1));
enumType.AddMember(red);
enumType.AddMember("Green", new EdmIntegerConstant(2));
enumType.AddMember("Blue", new EdmIntegerConstant(3));
tmpModel.AddElement(enumType);
// enum with flags
var enumFlagsType = new EdmEnumType("NS", "ColorFlags", isFlags: true);
enumFlagsType.AddMember("Red", new EdmIntegerConstant(1));
enumFlagsType.AddMember("Green", new EdmIntegerConstant(2));
enumFlagsType.AddMember("Blue", new EdmIntegerConstant(4));
tmpModel.AddElement(enumFlagsType);
this.entityType = new EdmEntityType("NS", "MyEntityType", isAbstract: false, isOpen: true, baseType: null);
EdmStructuralProperty floatId = new EdmStructuralProperty(this.entityType, "FloatId", EdmCoreModel.Instance.GetSingle(false));
this.entityType.AddKeys(floatId);
this.entityType.AddProperty(floatId);
var enumTypeReference = new EdmEnumTypeReference(enumType, true);
this.entityType.AddProperty(new EdmStructuralProperty(this.entityType, "Color", enumTypeReference));
var enumFlagsTypeReference = new EdmEnumTypeReference(enumFlagsType, false);
this.entityType.AddProperty(new EdmStructuralProperty(this.entityType, "ColorFlags", enumFlagsTypeReference));
// enum in complex type
EdmComplexType myComplexType = new EdmComplexType("NS", "MyComplexType");
myComplexType.AddProperty(new EdmStructuralProperty(myComplexType, "MyColorFlags", enumFlagsTypeReference));
myComplexType.AddProperty(new EdmStructuralProperty(myComplexType, "Height", EdmCoreModel.Instance.GetDouble(false)));
tmpModel.AddElement(myComplexType);
this.entityType.AddProperty(new EdmStructuralProperty(this.entityType, "MyComplexType", new EdmComplexTypeReference(myComplexType, true)));
// enum in derived complex type
EdmComplexType myDerivedComplexType = new EdmComplexType("NS", "MyDerivedComplexType", myComplexType, false);
myDerivedComplexType.AddProperty(new EdmStructuralProperty(myDerivedComplexType, "MyDerivedColorFlags", new EdmEnumTypeReference(enumFlagsType, false)));
tmpModel.AddElement(myDerivedComplexType);
// enum in collection type
EdmCollectionType myCollectionType = new EdmCollectionType(enumFlagsTypeReference);
this.entityType.AddProperty(new EdmStructuralProperty(this.entityType, "MyCollectionType", new EdmCollectionTypeReference(myCollectionType)));
tmpModel.AddElement(this.entityType);
var defaultContainer = new EdmEntityContainer("NS", "DefaultContainer_sub");
this.entitySet = new EdmEntitySet(defaultContainer, "MySet", this.entityType);
defaultContainer.AddEntitySet(this.entitySet.Name, this.entityType);
tmpModel.AddElement(defaultContainer);
this.userModel = TestUtils.WrapReferencedModelsToMainModel("NS", "DefaultContainer", tmpModel);
}
public EdmReferentialConstraintTests()
{
this.typeWithOneKey = new EdmEntityType("Fake", "OneKey");
this.typeWithOneKey.AddKeys(this.key1_1 = this.typeWithOneKey.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32));
property1 = this.typeWithOneKey.AddStructuralProperty("prop1", EdmPrimitiveTypeKind.String);
this.typeWithTwoKeys = new EdmEntityType("Fake", "TwoKeys");
this.typeWithTwoKeys.AddKeys(this.key2_1 = this.typeWithTwoKeys.AddStructuralProperty("Id1", EdmPrimitiveTypeKind.Int32));
this.typeWithTwoKeys.AddKeys(this.key2_2 = this.typeWithTwoKeys.AddStructuralProperty("Id2", EdmPrimitiveTypeKind.Int32));
property2 = this.typeWithTwoKeys.AddStructuralProperty("prop2", EdmPrimitiveTypeKind.String);
var otherType = new EdmEntityType("Fake", "Other");
this.otherTypeProperty1 = otherType.AddStructuralProperty("Property1", EdmPrimitiveTypeKind.Int32);
this.otherTypeProperty2 = otherType.AddStructuralProperty("Property2", EdmPrimitiveTypeKind.Int32);
}
static DeltaLinkWriterIntegrationTests()
{
Model = new EdmModel();
EntityType = new EdmEntityType("TestNamespace", "TestEntityType");
Model.AddElement(EntityType);
var keyProperty = new EdmStructuralProperty(EntityType, "ID", EdmCoreModel.Instance.GetInt32(false));
EntityType.AddKeys(new IEdmStructuralProperty[] { keyProperty });
EntityType.AddProperty(keyProperty);
var resourceNavigationProperty = EntityType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo { Name = "ResourceNavigationProperty", Target = EntityType, TargetMultiplicity = EdmMultiplicity.ZeroOrOne });
var resourceSetNavigationProperty = EntityType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo { Name = "ResourceSetNavigationProperty", Target = EntityType, TargetMultiplicity = EdmMultiplicity.Many });
var defaultContainer = new EdmEntityContainer("TestNamespace", "DefaultContainer");
Model.AddElement(defaultContainer);
EntitySet = new EdmEntitySet(defaultContainer, "TestEntitySet", EntityType);
EntitySet.AddNavigationTarget(resourceNavigationProperty, EntitySet);
EntitySet.AddNavigationTarget(resourceSetNavigationProperty, EntitySet);
defaultContainer.AddElement(EntitySet);
}
static ODataEntityReferenceLinksTests()
{
EdmModel tmpModel = new EdmModel();
EdmComplexType complexType = new EdmComplexType("TestNamespace", "TestComplexType");
complexType.AddProperty(new EdmStructuralProperty(complexType, "StringProperty", EdmCoreModel.Instance.GetString(false)));
tmpModel.AddElement(complexType);
EntityType = new EdmEntityType("TestNamespace", "TestEntityType");
tmpModel.AddElement(EntityType);
var keyProperty = new EdmStructuralProperty(EntityType, "ID", EdmCoreModel.Instance.GetInt32(false));
EntityType.AddKeys(new IEdmStructuralProperty[] { keyProperty });
EntityType.AddProperty(keyProperty);
var defaultContainer = new EdmEntityContainer("TestNamespace", "DefaultContainer_sub");
tmpModel.AddElement(defaultContainer);
EntitySet = new EdmEntitySet(defaultContainer, "Customers", EntityType);
defaultContainer.AddElement(EntitySet);
EdmModel = TestUtils.WrapReferencedModelsToMainModel("TestNamespace", "DefaultContainer", tmpModel);
MessageReaderSettingsReadAndValidateCustomInstanceAnnotations = new ODataMessageReaderSettings { ShouldIncludeAnnotation = ODataUtils.CreateAnnotationFilter("*") };
}
private IEdmModel CreateTestModel()
{
EdmModel model = new EdmModel();
EdmEntityContainer defaultContainer = new EdmEntityContainer("TestModel", "Default");
model.AddElement(defaultContainer);
var productType = new EdmEntityType("TestModel", "Product");
EdmStructuralProperty idProperty = new EdmStructuralProperty(productType, "Id", EdmCoreModel.Instance.GetInt32(false));
productType.AddProperty(idProperty);
productType.AddKeys(idProperty);
productType.AddProperty(new EdmStructuralProperty(productType, "Name", EdmCoreModel.Instance.GetString(true)));
model.AddElement(productType);
var customerType = new EdmEntityType("TestModel", "Customer");
idProperty = new EdmStructuralProperty(customerType, "Id", EdmCoreModel.Instance.GetInt32(false));
customerType.AddProperty(idProperty);
customerType.AddKeys(idProperty);
customerType.AddProperty(new EdmStructuralProperty(customerType, "Name", EdmCoreModel.Instance.GetString(true)));
model.AddElement(productType);
defaultContainer.AddEntitySet("Products", productType);
defaultContainer.AddEntitySet("Customers", customerType);
defaultContainer.AddSingleton("SingleProduct", productType);
defaultContainer.AddSingleton("SingleCustomer", customerType);
EdmAction action = new EdmAction("TestModel", "SimpleAction", null/*returnType*/, false /*isBound*/, null /*entitySetPath*/);
model.AddElement(action);
defaultContainer.AddActionImport("SimpleActionImport", action);
EdmFunction function1 = new EdmFunction("TestModel", "SimpleFunction1", EdmCoreModel.Instance.GetInt32(false), false /*isbound*/, null, true);
function1.AddParameter("p1", EdmCoreModel.Instance.GetInt32(false));
defaultContainer.AddFunctionImport("SimpleFunctionImport1", function1);
EdmFunction function2 = new EdmFunction("TestModel", "SimpleFunction2", EdmCoreModel.Instance.GetInt32(false), false /*isbound*/, null, true);
function2.AddParameter("p1", EdmCoreModel.Instance.GetInt32(false));
defaultContainer.AddFunctionImport("SimpleFunctionImport2", function1, null, true /*IncludeInServiceDocument*/);
return model;
}
static ODataJsonLightEntryAndFeedDeserializerTests()
{
EdmModel tmpModel = new EdmModel();
EdmComplexType complexType = new EdmComplexType("TestNamespace", "TestComplexType");
complexType.AddProperty(new EdmStructuralProperty(complexType, "StringProperty", EdmCoreModel.Instance.GetString(false)));
tmpModel.AddElement(complexType);
EntityType = new EdmEntityType("TestNamespace", "TestEntityType");
tmpModel.AddElement(EntityType);
var keyProperty = new EdmStructuralProperty(EntityType, "ID", EdmCoreModel.Instance.GetInt32(false));
EntityType.AddKeys(new IEdmStructuralProperty[] { keyProperty });
EntityType.AddProperty(keyProperty);
var defaultContainer = new EdmEntityContainer("TestNamespace", "DefaultContainer_sub");
tmpModel.AddElement(defaultContainer);
EntitySet = new EdmEntitySet(defaultContainer, "TestEntitySet", EntityType);
defaultContainer.AddElement(EntitySet);
Action = new EdmAction("TestNamespace", "DoSomething", null, true, null);
Action.AddParameter("p1", new EdmEntityTypeReference(EntityType, false));
tmpModel.AddElement(Action);
ActionImport = defaultContainer.AddActionImport("DoSomething", Action);
var serviceOperationFunction = new EdmFunction("TestNamespace", "ServiceOperation", EdmCoreModel.Instance.GetInt32(true));
defaultContainer.AddFunctionImport("ServiceOperation", serviceOperationFunction);
tmpModel.AddElement(serviceOperationFunction);
tmpModel.AddElement(new EdmTerm("custom", "DateTimeOffsetAnnotation", EdmPrimitiveTypeKind.DateTimeOffset));
tmpModel.AddElement(new EdmTerm("custom", "DateAnnotation", EdmPrimitiveTypeKind.Date));
tmpModel.AddElement(new EdmTerm("custom", "TimeOfDayAnnotation", EdmPrimitiveTypeKind.TimeOfDay));
EdmModel = TestUtils.WrapReferencedModelsToMainModel("TestNamespace", "DefaultContainer", tmpModel);
MessageReaderSettingsReadAndValidateCustomInstanceAnnotations = new ODataMessageReaderSettings { ShouldIncludeAnnotation = ODataUtils.CreateAnnotationFilter("*") };
MessageReaderSettingsIgnoreInstanceAnnotations = new ODataMessageReaderSettings();
}
public void TestInitialize()
{
this.testServiceRootUri = new Uri(TestBaseUri);
this.model = new EdmModel();
var defaultContainer = new EdmEntityContainer(TestNameSpace, TestContainerName);
this.model.AddElement(defaultContainer);
productType = new EdmEntityType(TestNameSpace, "Product");
var productIdProperty = new EdmStructuralProperty(productType, "PersonId", EdmCoreModel.Instance.GetInt32(false));
productType.AddProperty(productIdProperty);
productType.AddKeys(new IEdmStructuralProperty[] { productIdProperty });
productType.AddProperty(new EdmStructuralProperty(productType, "Name", EdmCoreModel.Instance.GetString(false)));
this.model.AddElement(productType);
productBookType = new EdmEntityType(TestNameSpace, "ProductBook", productType);
productBookType.AddProperty(new EdmStructuralProperty(productBookType, "Author", EdmCoreModel.Instance.GetString(false)));
this.model.AddElement(productBookType);
productCdType = new EdmEntityType(TestNameSpace, "ProductCd", productType);
productCdType.AddProperty(new EdmStructuralProperty(productCdType, "Artist", EdmCoreModel.Instance.GetString(false)));
this.model.AddElement(productCdType);
var addressType = new EdmComplexType(TestNameSpace, "Address");
addressType.AddProperty(new EdmStructuralProperty(addressType, "Street", EdmCoreModel.Instance.GetString(false)));
addressType.AddProperty(new EdmStructuralProperty(addressType, "City", EdmCoreModel.Instance.GetString(false)));
this.model.AddElement(addressType);
var factoryAddressType = new EdmComplexType(TestNameSpace, "FactoryAddress", addressType, false);
factoryAddressType.AddProperty(new EdmStructuralProperty(factoryAddressType, "FactoryType", EdmCoreModel.Instance.GetString(false)));
factoryAddressType.AddProperty(new EdmStructuralProperty(factoryAddressType, "FactoryPhoneNumbers", new EdmCollectionTypeReference(new EdmCollectionType(EdmCoreModel.Instance.GetString(false)))));
this.model.AddElement(factoryAddressType);
var manufactoryType = new EdmComplexType(TestNameSpace, "Manufactory");
manufactoryType.AddProperty(new EdmStructuralProperty(manufactoryType, "ManufactoryAddress", new EdmComplexTypeReference(addressType, true)));
manufactoryType.AddProperty(new EdmStructuralProperty(manufactoryType, "Name", EdmCoreModel.Instance.GetString(false)));
manufactoryType.AddProperty(new EdmStructuralProperty(manufactoryType, "Numbers", new EdmCollectionTypeReference(new EdmCollectionType(EdmCoreModel.Instance.GetString(false)))));
this.model.AddElement(manufactoryType);
var companyDivisionType = new EdmComplexType(TestNameSpace, "Division");
companyDivisionType.AddProperty(new EdmStructuralProperty(companyDivisionType, "Name", EdmCoreModel.Instance.GetString(false)));
companyDivisionType.AddProperty(new EdmStructuralProperty(companyDivisionType, "Manufactory", new EdmComplexTypeReference(manufactoryType, true)));
this.model.AddElement(companyDivisionType);
var accessLevelType = new EdmEnumType(TestNameSpace, "AccessLevel", isFlags: true);
accessLevelType.AddMember("None", new EdmIntegerConstant(0));
accessLevelType.AddMember("Read", new EdmIntegerConstant(1));
accessLevelType.AddMember("Write", new EdmIntegerConstant(2));
accessLevelType.AddMember("Execute", new EdmIntegerConstant(4));
accessLevelType.AddMember("ReadWrite", new EdmIntegerConstant(3));
this.model.AddElement(accessLevelType);
personType = new EdmEntityType(TestNameSpace, "Person", null, false, /*IsOpen*/ true);
var personIdProperty = new EdmStructuralProperty(personType, "PersonId", EdmCoreModel.Instance.GetInt32(false));
personType.AddProperty(personIdProperty);
personType.AddKeys(new IEdmStructuralProperty[] { personIdProperty });
personType.AddProperty(new EdmStructuralProperty(personType, "Name", EdmCoreModel.Instance.GetString(false)));
personType.AddProperty(new EdmStructuralProperty(personType, "Age", EdmCoreModel.Instance.GetInt32(false)));
personType.AddProperty(new EdmStructuralProperty(personType, "HomeAddress", new EdmComplexTypeReference(addressType, true)));
personType.AddProperty(new EdmStructuralProperty(personType, "PhoneNumbers", new EdmCollectionTypeReference(new EdmCollectionType(EdmCoreModel.Instance.GetString(false)))));
personType.AddProperty(new EdmStructuralProperty(personType, "Addresses", new EdmCollectionTypeReference(new EdmCollectionType(new EdmComplexTypeReference(addressType, true)))));
personType.AddProperty(new EdmStructuralProperty(personType, "UserAccess", new EdmEnumTypeReference(accessLevelType, true)));
personType.AddProperty(new EdmStructuralProperty(personType, "UserAccesses", new EdmCollectionTypeReference(new EdmCollectionType(new EdmEnumTypeReference(accessLevelType, true)))));
this.model.AddElement(personType);
employeeType = new EdmEntityType(TestNameSpace, "Employee", personType, false, true);
employeeType.AddProperty(new EdmStructuralProperty(employeeType, "DateHired", EdmCoreModel.Instance.GetDateTimeOffset(true)));
employeeType.AddProperty(new EdmStructuralProperty(employeeType, "WorkNumbers", new EdmCollectionTypeReference(new EdmCollectionType(EdmCoreModel.Instance.GetString(false)))));
this.model.AddElement(employeeType);
companyType = new EdmEntityType(TestNameSpace, "Company");
var companyIdProperty = new EdmStructuralProperty(companyType, "CompanyId", EdmCoreModel.Instance.GetInt32(false));
companyType.AddProperty(companyIdProperty);
companyType.AddKeys(new IEdmStructuralProperty[] { companyIdProperty });
companyType.AddProperty(new EdmStructuralProperty(companyType, "Name", EdmCoreModel.Instance.GetString(false)));
companyType.AddProperty(new EdmStructuralProperty(companyType, "Division", new EdmComplexTypeReference(companyDivisionType, true)));
this.model.AddElement(companyType);
this.peopleSet = new EdmEntitySet(defaultContainer, "People", personType);
this.companySet = new EdmEntitySet(defaultContainer, "Companys", companyType);
this.employeeSet = new EdmEntitySet(defaultContainer, "Employees", employeeType);
defaultContainer.AddElement(this.employeeSet);
defaultContainer.AddElement(this.peopleSet);
defaultContainer.AddElement(this.companySet);
var associatedCompanyNavigation = employeeType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo
{
Name = "AssociatedCompany",
Target = companyType,
TargetMultiplicity = EdmMultiplicity.One
});
employeeSet.AddNavigationTarget(associatedCompanyNavigation, companySet);
}
/// <summary>
/// Creates and adds a structural property to this type.
/// </summary>
/// <param name="name">Name of the property.</param>
/// <param name="type">Type of the property.</param>
/// <param name="defaultValue">The default value of this property.</param>
/// <param name="concurrencyMode">The concurrency mode of this property.</param>
/// <returns>Created structural property.</returns>
public EdmStructuralProperty AddStructuralProperty(string name, IEdmTypeReference type, string defaultValue, EdmConcurrencyMode concurrencyMode)
{
EdmStructuralProperty property = new EdmStructuralProperty(this, name, type, defaultValue, concurrencyMode);
this.AddProperty(property);
return property;
}
/// <summary>
/// Creates and adds a structural property to this type.
/// </summary>
/// <param name="name">Name of the property.</param>
/// <param name="type">Type of the property.</param>
/// <returns>Created structural property.</returns>
public EdmStructuralProperty AddStructuralProperty(string name, IEdmTypeReference type)
{
EdmStructuralProperty property = new EdmStructuralProperty(this, name, type);
this.AddProperty(property);
return property;
}
/// <summary>
/// Creates and adds a nullable structural property to this type.
/// </summary>
/// <param name="name">Name of the property.</param>
/// <param name="type">Type of the property.</param>
/// <param name="isNullable">Flag specifying if the property is nullable.</param>
/// <returns>Created structural property.</returns>
public EdmStructuralProperty AddStructuralProperty(string name, EdmPrimitiveTypeKind type, bool isNullable)
{
EdmStructuralProperty property = new EdmStructuralProperty(this, name, EdmCoreModel.Instance.GetPrimitive(type, isNullable));
this.AddProperty(property);
return property;
}
public void ValidateSerializationBlockingErrors()
{
EdmModel model = new EdmModel();
EdmComplexType complexWithBadProperty = new EdmComplexType("Foo", "Bar");
complexWithBadProperty.AddProperty(new EdmStructuralProperty(complexWithBadProperty, "baz", new EdmComplexTypeReference(new EdmComplexType("", ""), false)));
model.AddElement(complexWithBadProperty);
EdmEntityType baseType = new EdmEntityType("Foo", "");
IEdmStructuralProperty keyProp = new EdmStructuralProperty(baseType, "Id", EdmCoreModel.Instance.GetInt32(false));
baseType.AddProperty(keyProp);
baseType.AddKeys(keyProp);
EdmEntityType derivedType = new EdmEntityType("Foo", "Quip", baseType);
model.AddElement(baseType);
model.AddElement(derivedType);
EdmNavigationProperty navProp = derivedType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo(){ Name="navProp", Target=derivedType, TargetMultiplicity=EdmMultiplicity.One });
EdmEntityContainer container = new EdmEntityContainer("Foo", "Container");
model.AddElement(container);
container.AddElement(new EdmEntitySet(container, "badNameSet", baseType));
StringBuilder sb = new StringBuilder();
IEnumerable<EdmError> errors;
bool written = model.TryWriteCsdl(XmlWriter.Create(sb), out errors);
var expectedErrors = new EdmLibTestErrors()
{
{ "([. Nullable=False])", EdmErrorCode.ReferencedTypeMustHaveValidName },
{ "(Foo.Quip)", EdmErrorCode.ReferencedTypeMustHaveValidName },
{ "(Microsoft.OData.Edm.Library.EdmEntitySet)", EdmErrorCode.ReferencedTypeMustHaveValidName },
};
this.CompareErrors(errors, expectedErrors);
}
private IEdmModel CreateMetadata(IEnumerable<CollectionInfo> collections = null, IEnumerable<SingletonInfo> singletons = null)
{
EdmModel edmModel=new EdmModel();
EdmEntityType edmEntityType = new EdmEntityType("DefaultNamespace", "EntityType");
EdmStructuralProperty edmStructuralProperty =new EdmStructuralProperty(edmEntityType,"Id",EdmCoreModel.Instance.GetInt32(false));
edmEntityType.AddKeys(edmStructuralProperty);
edmEntityType.AddStructuralProperty("Name", EdmCoreModel.Instance.GetString(true));
edmModel.AddElement(edmEntityType);
EdmEntityContainer edmEntityContainer = new EdmEntityContainer("DefaultNamespace", "TestContainer");
edmModel.AddElement(edmEntityContainer);
if (collections != null)
{
foreach (var collection in collections)
{
edmEntityContainer.AddEntitySet(collection.Url, edmEntityType);
}
}
if (singletons != null)
{
foreach (var singleton in singletons)
{
edmEntityContainer.AddSingleton(singleton.Url, edmEntityType);
}
}
return edmModel;
}
public static IEdmModel CreateTripPinServiceModel(string ns)
{
EdmModel model = new EdmModel();
var defaultContainer = new EdmEntityContainer(ns, "DefaultContainer");
model.AddElement(defaultContainer);
var genderType = new EdmEnumType(ns, "PersonGender", isFlags: false);
genderType.AddMember("Male", new EdmIntegerConstant(0));
genderType.AddMember("Female", new EdmIntegerConstant(1));
genderType.AddMember("Unknown", new EdmIntegerConstant(2));
model.AddElement(genderType);
var cityType = new EdmComplexType(ns, "City");
cityType.AddProperty(new EdmStructuralProperty(cityType, "CountryRegion", EdmCoreModel.Instance.GetString(false)));
cityType.AddProperty(new EdmStructuralProperty(cityType, "Name", EdmCoreModel.Instance.GetString(false)));
cityType.AddProperty(new EdmStructuralProperty(cityType, "Region", EdmCoreModel.Instance.GetString(false)));
model.AddElement(cityType);
var locationType = new EdmComplexType(ns, "Location", null, false, true);
locationType.AddProperty(new EdmStructuralProperty(locationType, "Address", EdmCoreModel.Instance.GetString(false)));
locationType.AddProperty(new EdmStructuralProperty(locationType, "City", new EdmComplexTypeReference(cityType, false)));
model.AddElement(locationType);
var eventLocationType = new EdmComplexType(ns, "EventLocation", locationType, false, true);
eventLocationType.AddProperty(new EdmStructuralProperty(eventLocationType, "BuildingInfo", EdmCoreModel.Instance.GetString(true)));
model.AddElement(eventLocationType);
var airportLocationType = new EdmComplexType(ns, "AirportLocation", locationType, false, true);
airportLocationType.AddProperty(new EdmStructuralProperty(airportLocationType, "Loc", EdmCoreModel.Instance.GetSpatial(EdmPrimitiveTypeKind.GeographyPoint, false)));
model.AddElement(airportLocationType);
var photoType = new EdmEntityType(ns, "Photo", null, false, false, true);
var photoIdProperty = new EdmStructuralProperty(photoType, "Id", EdmCoreModel.Instance.GetInt64(false));
photoType.AddProperty(photoIdProperty);
photoType.AddKeys(photoIdProperty);
photoType.AddProperty(new EdmStructuralProperty(photoType, "Name", EdmCoreModel.Instance.GetString(true)));
model.AddElement(photoType);
var photoSet = new EdmEntitySet(defaultContainer, "Photos", photoType);
defaultContainer.AddElement(photoSet);
var personType = new EdmEntityType(ns, "Person", null, false, /* isOpen */ true);
var personIdProperty = new EdmStructuralProperty(personType, "UserName", EdmCoreModel.Instance.GetString(false));
personType.AddProperty(personIdProperty);
personType.AddKeys(personIdProperty);
personType.AddProperty(new EdmStructuralProperty(personType, "FirstName", EdmCoreModel.Instance.GetString(false)));
personType.AddProperty(new EdmStructuralProperty(personType, "LastName", EdmCoreModel.Instance.GetString(false)));
personType.AddProperty(new EdmStructuralProperty(personType, "Emails", new EdmCollectionTypeReference(new EdmCollectionType(EdmCoreModel.Instance.GetString(true)))));
personType.AddProperty(new EdmStructuralProperty(personType, "AddressInfo", new EdmCollectionTypeReference(new EdmCollectionType(new EdmComplexTypeReference(locationType, true)))));
personType.AddProperty(new EdmStructuralProperty(personType, "Gender", new EdmEnumTypeReference(genderType, true)));
personType.AddProperty(new EdmStructuralProperty(personType, "Concurrency", EdmCoreModel.Instance.GetInt64(false)));
model.AddElement(personType);
var personSet = new EdmEntitySet(defaultContainer, "People", personType);
defaultContainer.AddElement(personSet);
var airlineType = new EdmEntityType(ns, "Airline");
var airlineCodeProp = new EdmStructuralProperty(airlineType, "AirlineCode", EdmCoreModel.Instance.GetString(false));
airlineType.AddKeys(airlineCodeProp);
airlineType.AddProperty(airlineCodeProp);
airlineType.AddProperty(new EdmStructuralProperty(airlineType, "Name", EdmCoreModel.Instance.GetString(false)));
model.AddElement(airlineType);
var airlineSet = new EdmEntitySet(defaultContainer, "Airlines", airlineType);
defaultContainer.AddElement(airlineSet);
var airportType = new EdmEntityType(ns, "Airport");
var airportIdType = new EdmStructuralProperty(airportType, "IcaoCode", EdmCoreModel.Instance.GetString(false));
airportType.AddProperty(airportIdType);
airportType.AddKeys(airportIdType);
airportType.AddProperty(new EdmStructuralProperty(airportType, "Name", EdmCoreModel.Instance.GetString(false)));
airportType.AddProperty(new EdmStructuralProperty(airportType, "IataCode", EdmCoreModel.Instance.GetString(false)));
airportType.AddProperty(new EdmStructuralProperty(airportType, "Location", new EdmComplexTypeReference(airportLocationType, false)));
model.AddElement(airportType);
var airportSet = new EdmEntitySet(defaultContainer, "Airports", airportType);
defaultContainer.AddElement(airportSet);
var planItemType = new EdmEntityType(ns, "PlanItem");
var planItemIdType = new EdmStructuralProperty(planItemType, "PlanItemId", EdmCoreModel.Instance.GetInt32(false));
planItemType.AddProperty(planItemIdType);
planItemType.AddKeys(planItemIdType);
planItemType.AddProperty(new EdmStructuralProperty(planItemType, "ConfirmationCode", EdmCoreModel.Instance.GetString(true)));
planItemType.AddProperty(new EdmStructuralProperty(planItemType, "StartsAt", EdmCoreModel.Instance.GetDateTimeOffset(true)));
planItemType.AddProperty(new EdmStructuralProperty(planItemType, "EndsAt", EdmCoreModel.Instance.GetDateTimeOffset(true)));
planItemType.AddProperty(new EdmStructuralProperty(planItemType, "Duration", EdmCoreModel.Instance.GetDuration(true)));
model.AddElement(planItemType);
var publicTransportationType = new EdmEntityType(ns, "PublicTransportation", planItemType);
publicTransportationType.AddProperty(new EdmStructuralProperty(publicTransportationType, "SeatNumber", EdmCoreModel.Instance.GetString(true)));
model.AddElement(publicTransportationType);
var flightType = new EdmEntityType(ns, "Flight", publicTransportationType);
var flightNumberType = new EdmStructuralProperty(flightType, "FlightNumber", EdmCoreModel.Instance.GetString(false));
flightType.AddProperty(flightNumberType);
model.AddElement(flightType);
var eventType = new EdmEntityType(ns, "Event", planItemType, false, true);
eventType.AddProperty(new EdmStructuralProperty(eventType, "Description", EdmCoreModel.Instance.GetString(true)));
eventType.AddProperty(new EdmStructuralProperty(eventType, "OccursAt", new EdmComplexTypeReference(eventLocationType, false)));
model.AddElement(eventType);
var tripType = new EdmEntityType(ns, "Trip");
var tripIdType = new EdmStructuralProperty(tripType, "TripId", EdmCoreModel.Instance.GetInt32(false));
tripType.AddProperty(tripIdType);
tripType.AddKeys(tripIdType);
tripType.AddProperty(new EdmStructuralProperty(tripType, "ShareId", EdmCoreModel.Instance.GetGuid(true)));
tripType.AddProperty(new EdmStructuralProperty(tripType, "Description", EdmCoreModel.Instance.GetString(true)));
tripType.AddProperty(new EdmStructuralProperty(tripType, "Name", EdmCoreModel.Instance.GetString(false)));
tripType.AddProperty(new EdmStructuralProperty(tripType, "Budget", EdmCoreModel.Instance.GetSingle(false)));
tripType.AddProperty(new EdmStructuralProperty(tripType, "StartsAt", EdmCoreModel.Instance.GetDateTimeOffset(false)));
tripType.AddProperty(new EdmStructuralProperty(tripType, "EndsAt", EdmCoreModel.Instance.GetDateTimeOffset(false)));
tripType.AddProperty(new EdmStructuralProperty(tripType, "Tags", new EdmCollectionTypeReference(new EdmCollectionType(EdmCoreModel.Instance.GetString(false)))));
model.AddElement(tripType);
var friendsnNavigation = personType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo()
{
Name = "Friends",
Target = personType,
TargetMultiplicity = EdmMultiplicity.Many
});
var personTripNavigation = personType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo()
{
Name = "Trips",
Target = tripType,
TargetMultiplicity = EdmMultiplicity.Many,
ContainsTarget = true
});
var personPhotoNavigation = personType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo()
{
Name = "Photo",
Target = photoType,
TargetMultiplicity = EdmMultiplicity.ZeroOrOne,
});
var tripPhotosNavigation = tripType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo()
{
Name = "Photos",
Target = photoType,
TargetMultiplicity = EdmMultiplicity.Many,
});
var tripItemNavigation = tripType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo()
{
Name = "PlanItems",
Target = planItemType,
ContainsTarget = true,
TargetMultiplicity = EdmMultiplicity.Many
});
var flightFromAirportNavigation = flightType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo()
{
Name = "From",
Target = airportType,
TargetMultiplicity = EdmMultiplicity.One
});
var flightToAirportNavigation = flightType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo()
{
Name = "To",
Target = airportType,
TargetMultiplicity = EdmMultiplicity.One
});
var flightAirlineNavigation = flightType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo()
{
Name = "Airline",
Target = airlineType,
TargetMultiplicity = EdmMultiplicity.One
});
var me = new EdmSingleton(defaultContainer, "Me", personType);
defaultContainer.AddElement(me);
personSet.AddNavigationTarget(friendsnNavigation, personSet);
me.AddNavigationTarget(friendsnNavigation, personSet);
personSet.AddNavigationTarget(flightAirlineNavigation, airlineSet);
me.AddNavigationTarget(flightAirlineNavigation, airlineSet);
personSet.AddNavigationTarget(flightFromAirportNavigation, airportSet);
me.AddNavigationTarget(flightFromAirportNavigation, airportSet);
personSet.AddNavigationTarget(flightToAirportNavigation, airportSet);
me.AddNavigationTarget(flightToAirportNavigation, airportSet);
personSet.AddNavigationTarget(personPhotoNavigation, photoSet);
me.AddNavigationTarget(personPhotoNavigation, photoSet);
personSet.AddNavigationTarget(tripPhotosNavigation, photoSet);
me.AddNavigationTarget(tripPhotosNavigation, photoSet);
var getFavoriteAirlineFunction = new EdmFunction(ns, "GetFavoriteAirline",
new EdmEntityTypeReference(airlineType, false), true,
new EdmPathExpression("person/Trips/PlanItems/Microsoft.OData.SampleService.Models.TripPin.Flight/Airline"), true);
getFavoriteAirlineFunction.AddParameter("person", new EdmEntityTypeReference(personType, false));
model.AddElement(getFavoriteAirlineFunction);
var getInvolvedPeopleFunction = new EdmFunction(ns, "GetInvolvedPeople",
new EdmCollectionTypeReference(new EdmCollectionType(new EdmEntityTypeReference(personType, false))), true, null, true);
getInvolvedPeopleFunction.AddParameter("trip", new EdmEntityTypeReference(tripType, false));
model.AddElement(getInvolvedPeopleFunction);
var getFriendsTripsFunction = new EdmFunction(ns, "GetFriendsTrips",
new EdmCollectionTypeReference(new EdmCollectionType(new EdmEntityTypeReference(tripType, false))),
true, new EdmPathExpression("person/Friends/Trips"), true);
getFriendsTripsFunction.AddParameter("person", new EdmEntityTypeReference(personType, false));
getFriendsTripsFunction.AddParameter("userName", EdmCoreModel.Instance.GetString(false));
model.AddElement(getFriendsTripsFunction);
var getNearestAirport = new EdmFunction(ns, "GetNearestAirport",
new EdmEntityTypeReference(airportType, false),
false, null, true);
getNearestAirport.AddParameter("lat", EdmCoreModel.Instance.GetDouble(false));
getNearestAirport.AddParameter("lon", EdmCoreModel.Instance.GetDouble(false));
model.AddElement(getNearestAirport);
var getNearestAirportFunctionImport = (IEdmFunctionImport)defaultContainer.AddFunctionImport("GetNearestAirport", getNearestAirport, new EdmEntitySetReferenceExpression(airportSet), true);
var resetDataSourceAction = new EdmAction(ns, "ResetDataSource", null, false, null);
model.AddElement(resetDataSourceAction);
defaultContainer.AddActionImport(resetDataSourceAction);
var shareTripAction = new EdmAction(ns, "ShareTrip", null, true, null);
shareTripAction.AddParameter("person", new EdmEntityTypeReference(personType, false));
shareTripAction.AddParameter("userName", EdmCoreModel.Instance.GetString(false));
shareTripAction.AddParameter("tripId", EdmCoreModel.Instance.GetInt32(false));
model.AddElement(shareTripAction);
model.SetDescriptionAnnotation(defaultContainer, "TripPin service is a sample service for OData V4.");
model.SetOptimisticConcurrencyAnnotation(personSet, personType.StructuralProperties().Where(p => p.Name == "Concurrency"));
// TODO: currently singleton does not support ETag feature
// model.SetOptimisticConcurrencyAnnotation(me, personType.StructuralProperties().Where(p => p.Name == "Concurrency"));
model.SetResourcePathCoreAnnotation(personSet, "People");
model.SetResourcePathCoreAnnotation(me, "Me");
model.SetResourcePathCoreAnnotation(airlineSet, "Airlines");
model.SetResourcePathCoreAnnotation(airportSet, "Airports");
model.SetResourcePathCoreAnnotation(photoSet, "Photos");
model.SetResourcePathCoreAnnotation(getNearestAirportFunctionImport, "Microsoft.OData.SampleService.Models.TripPin.GetNearestAirport");
model.SetDereferenceableIDsCoreAnnotation(defaultContainer, true);
model.SetConventionalIDsCoreAnnotation(defaultContainer, true);
model.SetPermissionsCoreAnnotation(personType.FindProperty("UserName"), CorePermission.Read);
model.SetPermissionsCoreAnnotation(airlineType.FindProperty("AirlineCode"), CorePermission.Read);
model.SetPermissionsCoreAnnotation(airportType.FindProperty("IcaoCode"), CorePermission.Read);
model.SetPermissionsCoreAnnotation(planItemType.FindProperty("PlanItemId"), CorePermission.Read);
model.SetPermissionsCoreAnnotation(tripType.FindProperty("TripId"), CorePermission.Read);
model.SetPermissionsCoreAnnotation(photoType.FindProperty("Id"), CorePermission.Read);
model.SetImmutableCoreAnnotation(airportType.FindProperty("IataCode"), true);
model.SetComputedCoreAnnotation(personType.FindProperty("Concurrency"), true);
model.SetAcceptableMediaTypesCoreAnnotation(photoType, new[] { "image/jpeg" });
model.SetConformanceLevelCapabilitiesAnnotation(defaultContainer, CapabilitiesConformanceLevelType.Advanced);
model.SetSupportedFormatsCapabilitiesAnnotation(defaultContainer, new[] { "application/json;odata.metadata=full;IEEE754Compatible=false;odata.streaming=true", "application/json;odata.metadata=minimal;IEEE754Compatible=false;odata.streaming=true", "application/json;odata.metadata=none;IEEE754Compatible=false;odata.streaming=true" });
model.SetAsynchronousRequestsSupportedCapabilitiesAnnotation(defaultContainer, true);
model.SetBatchContinueOnErrorSupportedCapabilitiesAnnotation(defaultContainer, false);
model.SetNavigationRestrictionsCapabilitiesAnnotation(personSet, CapabilitiesNavigationType.None, new[] { new Tuple<IEdmNavigationProperty, CapabilitiesNavigationType>(friendsnNavigation, CapabilitiesNavigationType.Recursive) });
model.SetFilterFunctionsCapabilitiesAnnotation(defaultContainer, new[] { "contains", "endswith", "startswith", "length", "indexof", "substring", "tolower", "toupper", "trim", "concat", "year", "month", "day", "hour", "minute", "second", "round", "floor", "ceiling", "cast", "isof" });
model.SetSearchRestrictionsCapabilitiesAnnotation(personSet, true, CapabilitiesSearchExpressions.None);
model.SetSearchRestrictionsCapabilitiesAnnotation(airlineSet, true, CapabilitiesSearchExpressions.None);
model.SetSearchRestrictionsCapabilitiesAnnotation(airportSet, true, CapabilitiesSearchExpressions.None);
model.SetSearchRestrictionsCapabilitiesAnnotation(photoSet, true, CapabilitiesSearchExpressions.None);
model.SetInsertRestrictionsCapabilitiesAnnotation(personSet, true, new[] { personTripNavigation, friendsnNavigation });
model.SetInsertRestrictionsCapabilitiesAnnotation(airlineSet, true, null);
model.SetInsertRestrictionsCapabilitiesAnnotation(airportSet, false, null);
model.SetInsertRestrictionsCapabilitiesAnnotation(photoSet, true, null);
// TODO: model.SetUpdateRestrictionsCapabilitiesAnnotation();
model.SetDeleteRestrictionsCapabilitiesAnnotation(airportSet, false, null);
model.SetISOCurrencyMeasuresAnnotation(tripType.FindProperty("Budget"), "USD");
model.SetScaleMeasuresAnnotation(tripType.FindProperty("Budget"), 2);
return model;
}
private EdmModel CreateEdmModelWithEntity()
{
var model = new EdmModel();
var entityType = new EdmEntityType("TestNamespace", "Customer");
entityType.AddStructuralProperty("Name", EdmPrimitiveTypeKind.String);
EdmStructuralProperty id = new EdmStructuralProperty(entityType, "FloatId", EdmCoreModel.Instance.GetSingle(false));
entityType.AddKeys(id);
entityType.AddProperty(id);
model.AddElement(entityType);
var defaultContainer = new EdmEntityContainer("TestNamespace", "DefaultContainer_sub");
var entitySet = new EdmEntitySet(defaultContainer, "Customers", entityType);
defaultContainer.AddEntitySet(entitySet.Name, entityType);
model.AddElement(defaultContainer);
return model;
}
public void WriteOpenEntry()
{
EdmEntityType entityType = new EdmEntityType("NS", "Entity", null, false, true);
IEdmStructuralProperty keyProp = new EdmStructuralProperty(entityType, "Id", EdmCoreModel.Instance.GetInt32(false));
entityType.AddProperty(keyProp);
entityType.AddKeys(keyProp);
EdmOperation operation = new EdmFunction("NS", "Foo", EdmCoreModel.Instance.GetInt16(true));
operation.AddParameter("entry", new EdmEntityTypeReference(entityType, false));
Action<ODataJsonLightOutputContext> test = outputContext =>
{
var entry = new ODataEntry();
entry.Properties = new List<ODataProperty>() { new ODataProperty() { Name = "ID", Value = 1 }, new ODataProperty() { Name = "DynamicProperty", Value = "DynamicValue" } };
var parameterWriter = new ODataJsonLightParameterWriter(outputContext, operation);
parameterWriter.WriteStart();
var entryWriter = parameterWriter.CreateEntryWriter("entry");
entryWriter.WriteStart(entry);
entryWriter.WriteEnd();
parameterWriter.WriteEnd();
parameterWriter.Flush();
};
WriteAndValidate(test, "{\"entry\":{\"ID\":1,\"DynamicProperty\":\"DynamicValue\"}}", writingResponse: false);
}
public void ConstructibleModelODataTestModelDefaultModel()
{
EdmModel model = new EdmModel();
EdmComplexType aliases = new EdmComplexType("DefaultNamespace", "Aliases");
EdmStructuralProperty aliasesAlternativeNames = aliases.AddStructuralProperty("AlternativeNames", EdmCoreModel.GetCollection(EdmCoreModel.Instance.GetString(false, 10, null, false)));
model.AddElement(aliases);
EdmComplexType phone = new EdmComplexType("DefaultNamespace", "Phone");
EdmStructuralProperty phoneNumber = phone.AddStructuralProperty("PhoneNumber", EdmCoreModel.Instance.GetString(false, 16, null, false));
EdmStructuralProperty phoneExtension = phone.AddStructuralProperty("Extension", EdmCoreModel.Instance.GetString(false, 16, null, true));
model.AddElement(phone);
EdmComplexType contact = new EdmComplexType("DefaultNamespace", "ContactDetails");
EdmStructuralProperty contactEmailBag = contact.AddStructuralProperty("EmailBag", EdmCoreModel.GetCollection(EdmCoreModel.Instance.GetString(false, 32, null, false)));
EdmStructuralProperty contactAlternativeNames = contact.AddStructuralProperty("AlternativeNames", EdmCoreModel.GetCollection(EdmCoreModel.Instance.GetString(false, 10, null, false)));
EdmStructuralProperty contactAlias = contact.AddStructuralProperty("ContactAlias", new EdmComplexTypeReference(aliases, false));
EdmStructuralProperty contactHomePhone = contact.AddStructuralProperty("HomePhone", new EdmComplexTypeReference(phone, false));
EdmStructuralProperty contactWorkPhone = contact.AddStructuralProperty("WorkPhone", new EdmComplexTypeReference(phone, false));
EdmStructuralProperty contactMobilePhoneBag = contact.AddStructuralProperty("MobilePhoneBag", EdmCoreModel.GetCollection(new EdmComplexTypeReference(phone, false)));
model.AddElement(contact);
EdmComplexType category = new EdmComplexType("DefaultNamespace", "ComplexToCategory");
EdmStructuralProperty categoryTerm = category.AddStructuralProperty("Term", EdmCoreModel.Instance.GetString(false));
EdmStructuralProperty categoryScheme = category.AddStructuralProperty("Scheme", EdmCoreModel.Instance.GetString(false));
EdmStructuralProperty categoryLabel = category.AddStructuralProperty("Label", EdmCoreModel.Instance.GetString(false));
model.AddElement(category);
EdmComplexType dimensions = new EdmComplexType("DefaultNamespace", "Dimensions");
EdmStructuralProperty dimensionsWidth = dimensions.AddStructuralProperty("Width", EdmCoreModel.Instance.GetDecimal(10, 3, false));
EdmStructuralProperty dimensionsHeight = dimensions.AddStructuralProperty("Height", EdmCoreModel.Instance.GetDecimal(10, 3, false));
EdmStructuralProperty dimensionsDepth = dimensions.AddStructuralProperty("Depth", EdmCoreModel.Instance.GetDecimal(10, 3, false));
model.AddElement(dimensions);
EdmComplexType concurrency = new EdmComplexType("DefaultNamespace", "ConcurrencyInfo");
EdmStructuralProperty concurrencyToken = concurrency.AddStructuralProperty("Token", EdmCoreModel.Instance.GetString(false, 20, null, false));
EdmStructuralProperty concurrencyQueriedDateTime = concurrency.AddStructuralProperty("QueriedDateTime", EdmCoreModel.Instance.GetDateTimeOffset(true));
model.AddElement(concurrency);
EdmComplexType audit = new EdmComplexType("DefaultNamespace", "AuditInfo");
EdmStructuralProperty auditModifiedDate = audit.AddStructuralProperty("ModifiedDate", EdmCoreModel.Instance.GetDateTimeOffset(false));
EdmStructuralProperty auditModifiedBy = audit.AddStructuralProperty("ModifiedBy", EdmCoreModel.Instance.GetString(false, 50, null, false));
EdmStructuralProperty auditConcurrency = audit.AddStructuralProperty("Concurrency", new EdmComplexTypeReference(concurrency, false));
model.AddElement(audit);
EdmEntityType customer = new EdmEntityType("DefaultNamespace", "Customer");
EdmStructuralProperty customerId = customer.AddStructuralProperty("CustomerId", EdmCoreModel.Instance.GetInt32(false));
customer.AddKeys(customerId);
EdmStructuralProperty customerName = customer.AddStructuralProperty("Name", EdmCoreModel.Instance.GetString(false, 100, null, false));
EdmStructuralProperty customerPrimaryContact = customer.AddStructuralProperty("PrimaryContactInfo", new EdmComplexTypeReference(contact, false));
EdmStructuralProperty customerBackupContact = customer.AddStructuralProperty("BackupContactInfo", EdmCoreModel.GetCollection(new EdmComplexTypeReference(contact, false)));
EdmStructuralProperty customerAuditing = customer.AddStructuralProperty("Auditing", new EdmComplexTypeReference(audit, false));
EdmStructuralProperty customerThumbnail = customer.AddStructuralProperty("Thumbnail", EdmCoreModel.Instance.GetStream(false));
EdmStructuralProperty customerVideo = customer.AddStructuralProperty("Video", EdmCoreModel.Instance.GetStream(false));
model.AddElement(customer);
EdmEntityType barcode = new EdmEntityType("DefaultNamespace", "Barcode");
EdmStructuralProperty barcodeCode = barcode.AddStructuralProperty("Code", EdmCoreModel.Instance.GetInt32(false));
barcode.AddKeys(barcodeCode);
EdmStructuralProperty barcodeProductId = barcode.AddStructuralProperty("ProductId", EdmCoreModel.Instance.GetInt32(false));
EdmStructuralProperty barcodeText = barcode.AddStructuralProperty("Text", EdmCoreModel.Instance.GetString(false));
model.AddElement(barcode);
EdmEntityType incorrectScan = new EdmEntityType("DefaultNamespace", "IncorrectScan");
EdmStructuralProperty incorrectScanId = incorrectScan.AddStructuralProperty("IncorrectScanId", EdmCoreModel.Instance.GetInt32(false));
incorrectScan.AddKeys(incorrectScanId);
EdmStructuralProperty incorrectScanExpectedCode = incorrectScan.AddStructuralProperty("ExpectedCode", EdmCoreModel.Instance.GetInt32(false));
EdmStructuralProperty incorrectScanActualCode = incorrectScan.AddStructuralProperty("ActualCode", EdmCoreModel.Instance.GetInt32(true));
EdmStructuralProperty incorrectScanDate = incorrectScan.AddStructuralProperty("ScanDate", EdmCoreModel.GetCollection(EdmCoreModel.Instance.GetDateTimeOffset(false)));
EdmStructuralProperty incorrectScanDetails = incorrectScan.AddStructuralProperty("Details", EdmCoreModel.Instance.GetString(false));
model.AddElement(incorrectScan);
EdmEntityType barcodeDetail = new EdmEntityType("DefaultNamespace", "BarcodeDetail");
EdmStructuralProperty barcodeDetailCode = barcodeDetail.AddStructuralProperty("Code", EdmCoreModel.Instance.GetInt32(false));
barcodeDetail.AddKeys(barcodeDetailCode);
EdmStructuralProperty barcodeDetailRegisteredTo = barcodeDetail.AddStructuralProperty("RegisteredTo", EdmCoreModel.Instance.GetString(false));
model.AddElement(barcodeDetail);
EdmEntityType complaint = new EdmEntityType("DefaultNamespace", "Complaint");
EdmStructuralProperty complaintId = complaint.AddStructuralProperty("ComplaintId", EdmCoreModel.Instance.GetInt32(false));
complaint.AddKeys(complaintId);
EdmStructuralProperty complaintCustomerId = complaint.AddStructuralProperty("CustomerId", EdmCoreModel.Instance.GetInt32(true));
EdmStructuralProperty complaintLogged = complaint.AddStructuralProperty("Logged", EdmCoreModel.Instance.GetDateTimeOffset(false));
EdmStructuralProperty complaintDetails = complaint.AddStructuralProperty("Details", EdmCoreModel.Instance.GetString(false));
model.AddElement(complaint);
EdmEntityType resolution = new EdmEntityType("DefaultNamespace", "Resolution");
EdmStructuralProperty resolutionId = resolution.AddStructuralProperty("ResolutionId", EdmCoreModel.Instance.GetInt32(false));
resolution.AddKeys(resolutionId);
EdmStructuralProperty resolutionDetails = resolution.AddStructuralProperty("Details", EdmCoreModel.Instance.GetString(false));
model.AddElement(resolution);
EdmEntityType login = new EdmEntityType("DefaultNamespace", "Login");
EdmStructuralProperty loginUsername = login.AddStructuralProperty("Username", EdmCoreModel.Instance.GetString(false, 50, null, false));
login.AddKeys(loginUsername);
EdmStructuralProperty loginCustomerId = login.AddStructuralProperty("CustomerId", EdmCoreModel.Instance.GetInt32(false));
model.AddElement(login);
EdmEntityType suspiciousActivity = new EdmEntityType("DefaultNamespace", "SuspiciousActivity");
EdmStructuralProperty suspiciousActivityId = suspiciousActivity.AddStructuralProperty("SuspiciousActivityId", EdmCoreModel.Instance.GetInt32(false));
suspiciousActivity.AddKeys(suspiciousActivityId);
EdmStructuralProperty suspiciousActivityProperty = suspiciousActivity.AddStructuralProperty("Activity", EdmCoreModel.Instance.GetString(false));
model.AddElement(suspiciousActivity);
EdmEntityType smartCard = new EdmEntityType("DefaultNamespace", "SmartCard");
EdmStructuralProperty smartCardUsername = smartCard.AddStructuralProperty("Username", EdmCoreModel.Instance.GetString(false, 50, null, false));
smartCard.AddKeys(smartCardUsername);
EdmStructuralProperty smartCardSerial = smartCard.AddStructuralProperty("CardSerial", EdmCoreModel.Instance.GetString(false));
EdmStructuralProperty smartCardIssued = smartCard.AddStructuralProperty("Issued", EdmCoreModel.Instance.GetDateTimeOffset(false));
model.AddElement(smartCard);
EdmEntityType rsaToken = new EdmEntityType("DefaultNamespace", "RSAToken");
EdmStructuralProperty rsaTokenSerial = rsaToken.AddStructuralProperty("Serial", EdmCoreModel.Instance.GetString(false, 20, null, false));
rsaToken.AddKeys(rsaTokenSerial);
EdmStructuralProperty rsaTokenIssued = rsaToken.AddStructuralProperty("Issued", EdmCoreModel.Instance.GetDateTimeOffset(false));
model.AddElement(rsaToken);
EdmEntityType passwordReset = new EdmEntityType("DefaultNamespace", "PasswordReset");
EdmStructuralProperty passwordResetNo = passwordReset.AddStructuralProperty("ResetNo", EdmCoreModel.Instance.GetInt32(false));
EdmStructuralProperty passwordResetUsername = passwordReset.AddStructuralProperty("Username", EdmCoreModel.Instance.GetString(false, 50, null, false));
passwordReset.AddKeys(passwordResetNo);
passwordReset.AddKeys(passwordResetUsername);
EdmStructuralProperty passwordResetTempPassword = passwordReset.AddStructuralProperty("TempPassword", EdmCoreModel.Instance.GetString(false));
EdmStructuralProperty passwordResetEmailedTo = passwordReset.AddStructuralProperty("EmailedTo", EdmCoreModel.Instance.GetString(false));
model.AddElement(passwordReset);
EdmEntityType pageView = new EdmEntityType("DefaultNamespace", "PageView");
EdmStructuralProperty pageViewId = pageView.AddStructuralProperty("PageViewId", EdmCoreModel.Instance.GetInt32(false));
pageView.AddKeys(pageViewId);
EdmStructuralProperty pageViewUsername = pageView.AddStructuralProperty("Username", EdmCoreModel.Instance.GetString(false, 50, null, false));
EdmStructuralProperty pageViewed = pageView.AddStructuralProperty("Viewed", EdmCoreModel.Instance.GetDateTimeOffset(false));
EdmStructuralProperty pageViewPageUrl = pageView.AddStructuralProperty("PageUrl", EdmCoreModel.Instance.GetString(false, 500, null, false));
model.AddElement(pageView);
EdmEntityType productPageView = new EdmEntityType("DefaultNamespace", "ProductPageView", pageView);
EdmStructuralProperty productPageViewId = productPageView.AddStructuralProperty("ProductId", EdmCoreModel.Instance.GetInt32(false));
model.AddElement(productPageView);
EdmEntityType lastLogin = new EdmEntityType("DefaultNamespace", "LastLogin");
EdmStructuralProperty lastLoginUsername = lastLogin.AddStructuralProperty("Username", EdmCoreModel.Instance.GetString(false, 50, null, false));
lastLogin.AddKeys(lastLoginUsername);
EdmStructuralProperty lastLoginLoggedIn = lastLogin.AddStructuralProperty("LoggedIn", EdmCoreModel.Instance.GetDateTimeOffset(false));
EdmStructuralProperty lastLoginLoggedOut = lastLogin.AddStructuralProperty("LoggedOut", EdmCoreModel.Instance.GetDateTimeOffset(true));
model.AddElement(lastLogin);
EdmEntityType message = new EdmEntityType("DefaultNamespace", "Message");
EdmStructuralProperty messageId = message.AddStructuralProperty("MessageId", EdmCoreModel.Instance.GetInt32(false));
EdmStructuralProperty messageFromUsername = message.AddStructuralProperty("FromUsername", EdmCoreModel.Instance.GetString(false, 50, null, false));
message.AddKeys(messageId);
message.AddKeys(messageFromUsername);
EdmStructuralProperty messageToUsername = message.AddStructuralProperty("ToUsername", EdmCoreModel.Instance.GetString(false, 50, null, false));
EdmStructuralProperty messageSent = message.AddStructuralProperty("Sent", EdmCoreModel.Instance.GetDateTimeOffset(false));
EdmStructuralProperty messageSubject = message.AddStructuralProperty("Subject", EdmCoreModel.Instance.GetString(false));
EdmStructuralProperty messageBody = message.AddStructuralProperty("Body", EdmCoreModel.Instance.GetString(true));
EdmStructuralProperty messageIsRead = message.AddStructuralProperty("IsRead", EdmCoreModel.Instance.GetBoolean(false));
model.AddElement(message);
EdmEntityType order = new EdmEntityType("DefaultNamespace", "Order");
EdmStructuralProperty orderId = order.AddStructuralProperty("OrderId", EdmCoreModel.Instance.GetInt32(false));
order.AddKeys(orderId);
EdmStructuralProperty orderCustomerId = order.AddStructuralProperty("CustomerId", EdmCoreModel.Instance.GetInt32(true));
EdmStructuralProperty orderConcurrency = order.AddStructuralProperty("Concurrency", new EdmComplexTypeReference(concurrency, false));
model.AddElement(order);
EdmEntityType orderNote = new EdmEntityType("DefaultNamespace", "OrderNote");
EdmStructuralProperty orderNoteId = orderNote.AddStructuralProperty("NoteId", EdmCoreModel.Instance.GetInt32(false));
orderNote.AddKeys(orderNoteId);
EdmStructuralProperty orderNoteDescription = orderNote.AddStructuralProperty("Note", EdmCoreModel.Instance.GetString(false));
model.AddElement(orderNote);
EdmEntityType orderQualityCheck = new EdmEntityType("DefaultNamespace", "OrderQualityCheck");
EdmStructuralProperty orderQualityCheckId = orderQualityCheck.AddStructuralProperty("OrderId", EdmCoreModel.Instance.GetInt32(false));
orderQualityCheck.AddKeys(orderQualityCheckId);
EdmStructuralProperty orderQualityCheckBy = orderQualityCheck.AddStructuralProperty("CheckedBy", EdmCoreModel.Instance.GetString(false));
EdmStructuralProperty orderQualityCheckDateTime = orderQualityCheck.AddStructuralProperty("CheckedDateTime", EdmCoreModel.Instance.GetDateTimeOffset(false));
model.AddElement(orderQualityCheck);
EdmEntityType orderLine = new EdmEntityType("DefaultNamespace", "OrderLine");
EdmStructuralProperty orderLineOrderId = orderLine.AddStructuralProperty("OrderId", EdmCoreModel.Instance.GetInt32(false));
EdmStructuralProperty orderLineProductId = orderLine.AddStructuralProperty("ProductId", EdmCoreModel.Instance.GetInt32(false));
orderLine.AddKeys(orderLineOrderId);
orderLine.AddKeys(orderLineProductId);
EdmStructuralProperty orderLineQuantity = orderLine.AddStructuralProperty("Quantity", EdmCoreModel.Instance.GetInt32(false));
EdmStructuralProperty orderLineConcurrencyToken = orderLine.AddStructuralProperty("ConcurrencyToken", EdmCoreModel.Instance.GetString(false), null, EdmConcurrencyMode.Fixed);
EdmStructuralProperty orderLineStream = orderLine.AddStructuralProperty("OrderLineStream", EdmCoreModel.Instance.GetStream(false));
model.AddElement(orderLine);
EdmEntityType backOrderLine = new EdmEntityType("DefaultNamespace", "BackOrderLine", orderLine);
model.AddElement(backOrderLine);
EdmEntityType backOrderLine2 = new EdmEntityType("DefaultNamespace", "BackOrderLine2", backOrderLine);
model.AddElement(backOrderLine2);
EdmEntityType product = new EdmEntityType("DefaultNamespace", "Product");
EdmStructuralProperty productId = product.AddStructuralProperty("ProductId", EdmCoreModel.Instance.GetInt32(false));
product.AddKeys(productId);
EdmStructuralProperty productDescription = product.AddStructuralProperty("Description", EdmCoreModel.Instance.GetString(false, 1000, true, true));
EdmStructuralProperty productDimensions = product.AddStructuralProperty("Dimensions", new EdmComplexTypeReference(dimensions, false));
EdmStructuralProperty productBaseConcurrency = new EdmStructuralProperty( product, "BaseConcurrency", EdmCoreModel.Instance.GetString(false), null, EdmConcurrencyMode.Fixed);
product.AddProperty(productBaseConcurrency);
EdmStructuralProperty productComplexConcurrency = product.AddStructuralProperty("ComplexConcurrency", new EdmComplexTypeReference(concurrency, false));
EdmStructuralProperty productNestedComplexConcurrency = product.AddStructuralProperty("NestedComplexConcurrency", new EdmComplexTypeReference(audit, false));
EdmStructuralProperty productPicture = product.AddStructuralProperty("Picture", EdmCoreModel.Instance.GetStream(false));
model.AddElement(product);
EdmEntityType discontinuedProduct = new EdmEntityType("DefaultNamespace", "DiscontinuedProduct", product);
EdmStructuralProperty discontinuedProductDate = discontinuedProduct.AddStructuralProperty("Discontinued", EdmCoreModel.Instance.GetDateTimeOffset(false));
EdmStructuralProperty discontinuedProductReplacementProductId = discontinuedProduct.AddStructuralProperty("ReplacementProductId", EdmCoreModel.Instance.GetInt32(true));
EdmStructuralProperty discontinuedProductDiscontinuedPhone = discontinuedProduct.AddStructuralProperty("DiscontinuedPhone", new EdmComplexTypeReference(phone, false));
model.AddElement(discontinuedProduct);
EdmEntityType productDetail = new EdmEntityType("DefaultNamespace", "ProductDetail");
EdmStructuralProperty productDetailProductId = productDetail.AddStructuralProperty("ProductId", EdmCoreModel.Instance.GetInt32(false));
productDetail.AddKeys(productDetailProductId);
EdmStructuralProperty productDetails = productDetail.AddStructuralProperty("Details", EdmCoreModel.Instance.GetString(false));
model.AddElement(productDetail);
EdmEntityType productReview = new EdmEntityType("DefaultNamespace", "ProductReview");
EdmStructuralProperty productReviewProductId = productReview.AddStructuralProperty("ProductId", EdmCoreModel.Instance.GetInt32(false));
EdmStructuralProperty productReviewId = productReview.AddStructuralProperty("ReviewId", EdmCoreModel.Instance.GetInt32(false));
productReview.AddKeys(productReviewProductId);
productReview.AddKeys(productReviewId);
EdmStructuralProperty productReviewDescription = productReview.AddStructuralProperty("Review", EdmCoreModel.Instance.GetString(false));
model.AddElement(productReview);
EdmEntityType productPhoto = new EdmEntityType("DefaultNamespace", "ProductPhoto");
EdmStructuralProperty productPhotoProductId = productPhoto.AddStructuralProperty("ProductId", EdmCoreModel.Instance.GetInt32(false));
EdmStructuralProperty productPhotoId = productPhoto.AddStructuralProperty("PhotoId", EdmCoreModel.Instance.GetInt32(false));
productPhoto.AddKeys(productPhotoProductId);
productPhoto.AddKeys(productPhotoId);
EdmStructuralProperty productPhotoBinary = productPhoto.AddStructuralProperty("Photo", EdmCoreModel.Instance.GetBinary(false));
model.AddElement(productPhoto);
EdmEntityType productWebFeature = new EdmEntityType("DefaultNamespace", "ProductWebFeature");
EdmStructuralProperty productWebFeatureId = productWebFeature.AddStructuralProperty("FeatureId", EdmCoreModel.Instance.GetInt32(false));
productWebFeature.AddKeys(productWebFeatureId);
EdmStructuralProperty productWebFeatureProductId = productWebFeature.AddStructuralProperty("ProductId", EdmCoreModel.Instance.GetInt32(true));
EdmStructuralProperty productWebFeaturePhotoId = productWebFeature.AddStructuralProperty("PhotoId", EdmCoreModel.Instance.GetInt32(true));
EdmStructuralProperty productWebFeatureReviewId = productWebFeature.AddStructuralProperty("ReviewId", EdmCoreModel.Instance.GetInt32(false));
EdmStructuralProperty productWebFeatureHeading = productWebFeature.AddStructuralProperty("Heading", EdmCoreModel.Instance.GetString(false));
model.AddElement(productWebFeature);
EdmEntityType supplier = new EdmEntityType("DefaultNamespace", "Supplier");
EdmStructuralProperty supplierId = supplier.AddStructuralProperty("SupplierId", EdmCoreModel.Instance.GetInt32(false));
supplier.AddKeys(supplierId);
EdmStructuralProperty supplierName = supplier.AddStructuralProperty("Name", EdmCoreModel.Instance.GetString(false));
model.AddElement(supplier);
EdmEntityType supplierLogo = new EdmEntityType("DefaultNamespace", "SupplierLogo");
EdmStructuralProperty supplierLogoSupplierId = supplierLogo.AddStructuralProperty("SupplierId", EdmCoreModel.Instance.GetInt32(false));
supplierLogo.AddKeys(supplierLogoSupplierId);
EdmStructuralProperty supplierLogoBinary = supplierLogo.AddStructuralProperty("Logo", EdmCoreModel.Instance.GetBinary(false, 500, false));
model.AddElement(supplierLogo);
EdmEntityType supplierInfo = new EdmEntityType("DefaultNamespace", "SupplierInfo");
EdmStructuralProperty supplierInfoId = supplierInfo.AddStructuralProperty("SupplierInfoId", EdmCoreModel.Instance.GetInt32(false));
supplierInfo.AddKeys(supplierInfoId);
EdmStructuralProperty supplierInfoDescription = supplierInfo.AddStructuralProperty("Information", EdmCoreModel.Instance.GetString(false));
model.AddElement(supplierInfo);
EdmEntityType customerInfo = new EdmEntityType("DefaultNamespace", "CustomerInfo");
EdmStructuralProperty customerInfoId = customerInfo.AddStructuralProperty("CustomerInfoId", EdmCoreModel.Instance.GetInt32(false));
customerInfo.AddKeys(customerInfoId);
EdmStructuralProperty customerInfoDescription = customerInfo.AddStructuralProperty("Information", EdmCoreModel.Instance.GetString(true));
model.AddElement(customerInfo);
EdmEntityType computer = new EdmEntityType("DefaultNamespace", "Computer");
EdmStructuralProperty computerId = computer.AddStructuralProperty("ComputerId", EdmCoreModel.Instance.GetInt32(false));
computer.AddKeys(computerId);
EdmStructuralProperty computerName = computer.AddStructuralProperty("Name", EdmCoreModel.Instance.GetString(false));
model.AddElement(computer);
EdmEntityType computerDetail = new EdmEntityType("DefaultNamespace", "ComputerDetail");
EdmStructuralProperty computerDetailId = computerDetail.AddStructuralProperty("ComputerDetailId", EdmCoreModel.Instance.GetInt32(false));
computerDetail.AddKeys(computerDetailId);
EdmStructuralProperty computerDetailManufacturer = computerDetail.AddStructuralProperty("Manufacturer", EdmCoreModel.Instance.GetString(false));
EdmStructuralProperty computerDetailModel = computerDetail.AddStructuralProperty("Model", EdmCoreModel.Instance.GetString(false));
EdmStructuralProperty computerDetailSerial = computerDetail.AddStructuralProperty("Serial", EdmCoreModel.Instance.GetString(false));
EdmStructuralProperty computerDetailSpecificationsBag = computerDetail.AddStructuralProperty("SpecificationsBag", EdmCoreModel.GetCollection(EdmCoreModel.Instance.GetString(false)));
EdmStructuralProperty computerDetailPurchaseDate = computerDetail.AddStructuralProperty("PurchaseDate", EdmCoreModel.Instance.GetDateTimeOffset(false));
EdmStructuralProperty computerDetailDimensions = computerDetail.AddStructuralProperty("Dimensions", new EdmComplexTypeReference(dimensions, false));
model.AddElement(computerDetail);
EdmEntityType driver = new EdmEntityType("DefaultNamespace", "Driver");
EdmStructuralProperty driverName = driver.AddStructuralProperty("Name", EdmCoreModel.Instance.GetString(false, 100, null, false));
driver.AddKeys(driverName);
EdmStructuralProperty driverBirthDate = driver.AddStructuralProperty("BirthDate", EdmCoreModel.Instance.GetDateTimeOffset(false));
model.AddElement(driver);
EdmEntityType license = new EdmEntityType("DefaultNamespace", "License");
EdmStructuralProperty licenseName = license.AddStructuralProperty("Name", EdmCoreModel.Instance.GetString(false, 100, null, false));
license.AddKeys(licenseName);
EdmStructuralProperty licenseNumber = license.AddStructuralProperty("LicenseNumber", EdmCoreModel.Instance.GetString(false));
EdmStructuralProperty licenseClass = license.AddStructuralProperty("LicenseClass", EdmCoreModel.Instance.GetString(false));
EdmStructuralProperty licenseRestrictions = license.AddStructuralProperty("Restrictions", EdmCoreModel.Instance.GetString(false));
EdmStructuralProperty licenseExpiration = license.AddStructuralProperty("ExpirationDate", EdmCoreModel.Instance.GetDateTimeOffset(false));
model.AddElement(license);
EdmEntityType mappedEntity = new EdmEntityType("DefaultNamespace", "MappedEntityType");
EdmStructuralProperty mappedEntityId = mappedEntity.AddStructuralProperty("Id", EdmCoreModel.Instance.GetInt32(false));
mappedEntity.AddKeys(mappedEntityId);
EdmStructuralProperty mappedEntityHref = mappedEntity.AddStructuralProperty("Href", EdmCoreModel.Instance.GetString(false));
EdmStructuralProperty mappedEntityTitle = mappedEntity.AddStructuralProperty("Title", EdmCoreModel.Instance.GetString(false));
EdmStructuralProperty mappedEntityHrefLang = mappedEntity.AddStructuralProperty("HrefLang", EdmCoreModel.Instance.GetString(false));
EdmStructuralProperty mappedEntityType = mappedEntity.AddStructuralProperty("Type", EdmCoreModel.Instance.GetString(false));
EdmStructuralProperty mappedEntityLength = mappedEntity.AddStructuralProperty("Length", EdmCoreModel.Instance.GetInt32(false));
EdmStructuralProperty mappedEntityBagOfPrimitiveToLinks = mappedEntity.AddStructuralProperty("BagOfPrimitiveToLinks", EdmCoreModel.GetCollection(EdmCoreModel.Instance.GetString(false)));
EdmStructuralProperty mappedEntityBagOfDecimals = mappedEntity.AddStructuralProperty("BagOfDecimals", EdmCoreModel.GetCollection(EdmCoreModel.Instance.GetDecimal(false)));
EdmStructuralProperty mappedEntityBagOfDoubles = mappedEntity.AddStructuralProperty("BagOfDoubles", EdmCoreModel.GetCollection(EdmCoreModel.Instance.GetDouble(false)));
EdmStructuralProperty mappedEntityBagOfSingles = mappedEntity.AddStructuralProperty("BagOfSingles", EdmCoreModel.GetCollection(EdmCoreModel.Instance.GetSingle(false)));
EdmStructuralProperty mappedEntityBagOfBytes = mappedEntity.AddStructuralProperty("BagOfBytes", EdmCoreModel.GetCollection(EdmCoreModel.Instance.GetByte(false)));
EdmStructuralProperty mappedEntityBagOfInt16s = mappedEntity.AddStructuralProperty("BagOfInt16s", EdmCoreModel.GetCollection(EdmCoreModel.Instance.GetInt16(false)));
EdmStructuralProperty mappedEntityBagOfInt32s = mappedEntity.AddStructuralProperty("BagOfInt32s", EdmCoreModel.GetCollection(EdmCoreModel.Instance.GetInt32(false)));
EdmStructuralProperty mappedEntityBagOfInt64s = mappedEntity.AddStructuralProperty("BagOfInt64s", EdmCoreModel.GetCollection(EdmCoreModel.Instance.GetInt64(false)));
EdmStructuralProperty mappedEntityBagOfGuids = mappedEntity.AddStructuralProperty("BagOfGuids", EdmCoreModel.GetCollection(EdmCoreModel.Instance.GetGuid(false)));
EdmStructuralProperty mappedEntityBagOfComplexToCategories = mappedEntity.AddStructuralProperty("BagOfComplexToCategories", EdmCoreModel.GetCollection(new EdmComplexTypeReference(category, false)));
model.AddElement(mappedEntity);
EdmEntityType car = new EdmEntityType("DefaultNamespace", "Car");
EdmStructuralProperty carVin = car.AddStructuralProperty("VIN", EdmCoreModel.Instance.GetInt32(false));
car.AddKeys(carVin);
EdmStructuralProperty carDescription = car.AddStructuralProperty("Description", EdmCoreModel.Instance.GetString(false, 100, null, true));
EdmStructuralProperty carPhoto = car.AddStructuralProperty("Photo", EdmCoreModel.Instance.GetStream(false));
EdmStructuralProperty carVideo = car.AddStructuralProperty("Video", EdmCoreModel.Instance.GetStream(false));
model.AddElement(car);
EdmEntityType person = new EdmEntityType("DefaultNamespace", "Person");
EdmStructuralProperty personId = person.AddStructuralProperty("PersonId", EdmCoreModel.Instance.GetInt32(false));
person.AddKeys(personId);
EdmStructuralProperty personName = person.AddStructuralProperty("Name", EdmCoreModel.Instance.GetString(false));
model.AddElement(person);
EdmEntityType employee = new EdmEntityType("DefaultNamespace", "Employee", person);
EdmStructuralProperty employeeManagerId = employee.AddStructuralProperty("ManagersPersonId", EdmCoreModel.Instance.GetInt32(false));
EdmStructuralProperty employeeSalary = employee.AddStructuralProperty("Salary", EdmCoreModel.Instance.GetInt32(false));
EdmStructuralProperty employeeTitle = employee.AddStructuralProperty("Title", EdmCoreModel.Instance.GetString(false));
model.AddElement(employee);
EdmEntityType specialEmployee = new EdmEntityType("DefaultNamespace", "SpecialEmployee", employee);
EdmStructuralProperty specialEmployeeCarsVIN = specialEmployee.AddStructuralProperty("CarsVIN", EdmCoreModel.Instance.GetInt32(false));
EdmStructuralProperty specialEmployeeBonus = specialEmployee.AddStructuralProperty("Bonus", EdmCoreModel.Instance.GetInt32(false));
EdmStructuralProperty specialEmployeeIsFullyVested = specialEmployee.AddStructuralProperty("IsFullyVested", EdmCoreModel.Instance.GetBoolean(false));
model.AddElement(specialEmployee);
EdmEntityType personMetadata = new EdmEntityType("DefaultNamespace", "PersonMetadata");
EdmStructuralProperty personMetadataId = personMetadata.AddStructuralProperty("PersonMetadataId", EdmCoreModel.Instance.GetInt32(false));
personMetadata.AddKeys(personMetadataId);
EdmStructuralProperty personMetadataPersonId = personMetadata.AddStructuralProperty("PersonId", EdmCoreModel.Instance.GetInt32(false));
EdmStructuralProperty personMetadataPropertyName = personMetadata.AddStructuralProperty("PropertyName", EdmCoreModel.Instance.GetString(false));
EdmStructuralProperty personMetadataPropertyValue = personMetadata.AddStructuralProperty("PropertyValue", EdmCoreModel.Instance.GetString(false));
model.AddElement(personMetadata);
EdmNavigationProperty customerToOrders = customer.AddBidirectionalNavigation(
new EdmNavigationPropertyInfo() { Name = "Orders", Target = order, TargetMultiplicity = EdmMultiplicity.Many },
new EdmNavigationPropertyInfo() { Name = "Customer", TargetMultiplicity = EdmMultiplicity.ZeroOrOne, DependentProperties = new[] { orderCustomerId }, PrincipalProperties = customer.Key() });
EdmNavigationProperty customerToLogins = customer.AddBidirectionalNavigation(
new EdmNavigationPropertyInfo() { Name = "Logins", Target = login, TargetMultiplicity = EdmMultiplicity.Many },
new EdmNavigationPropertyInfo() { Name = "Customer", TargetMultiplicity = EdmMultiplicity.One, DependentProperties = new [] { loginCustomerId }, PrincipalProperties = customer.Key()});
EdmNavigationProperty customerToHusband = customer.AddBidirectionalNavigation(
new EdmNavigationPropertyInfo() { Name = "Husband", Target = customer, TargetMultiplicity = EdmMultiplicity.ZeroOrOne },
new EdmNavigationPropertyInfo() { Name = "Wife", TargetMultiplicity = EdmMultiplicity.ZeroOrOne });
EdmNavigationProperty customerToInfo = customer.AddBidirectionalNavigation(
new EdmNavigationPropertyInfo() { Name = "Info", Target = customerInfo, TargetMultiplicity = EdmMultiplicity.ZeroOrOne },
new EdmNavigationPropertyInfo() { Name = "Customer", TargetMultiplicity = EdmMultiplicity.One });
EdmNavigationProperty customerToComplaint = customer.AddBidirectionalNavigation(
new EdmNavigationPropertyInfo() { Name = "Complaints", Target = complaint, TargetMultiplicity = EdmMultiplicity.Many },
new EdmNavigationPropertyInfo() { Name = "Customer", TargetMultiplicity = EdmMultiplicity.ZeroOrOne, DependentProperties = new[] { complaintCustomerId }, PrincipalProperties = customer.Key() });
EdmNavigationProperty barcodeToProduct = barcode.AddBidirectionalNavigation(
new EdmNavigationPropertyInfo() { Name = "Product", Target = product, TargetMultiplicity = EdmMultiplicity.One, DependentProperties = new[] { barcodeProductId }, PrincipalProperties = product.Key() },
new EdmNavigationPropertyInfo() { Name = "Barcodes", TargetMultiplicity = EdmMultiplicity.Many });
EdmNavigationProperty barcodeToExpectedIncorrectScans = barcode.AddBidirectionalNavigation(
new EdmNavigationPropertyInfo() { Name = "BadScans", Target = incorrectScan, TargetMultiplicity = EdmMultiplicity.Many },
new EdmNavigationPropertyInfo() { Name = "ExpectedBarcode", TargetMultiplicity = EdmMultiplicity.One, DependentProperties = new[] { incorrectScanExpectedCode }, PrincipalProperties = barcode.Key() });
EdmNavigationProperty barcodeToActualIncorrectScans = barcode.AddBidirectionalNavigation(
new EdmNavigationPropertyInfo() { Name = "GoodScans", Target = incorrectScan, TargetMultiplicity = EdmMultiplicity.Many },
new EdmNavigationPropertyInfo() { Name = "ActualBarcode", TargetMultiplicity = EdmMultiplicity.ZeroOrOne, DependentProperties = new[] { incorrectScanActualCode }, PrincipalProperties = barcode.Key()});
EdmNavigationProperty barcodeToBarcodeDetail = barcode.AddBidirectionalNavigation(
new EdmNavigationPropertyInfo() { Name = "Detail", Target = barcodeDetail, TargetMultiplicity = EdmMultiplicity.ZeroOrOne },
new EdmNavigationPropertyInfo() { Name = "Barcode", TargetMultiplicity = EdmMultiplicity.One, DependentProperties = new[] { barcodeDetailCode }, PrincipalProperties = barcode.Key()});
EdmNavigationProperty complaintToResolution = complaint.AddBidirectionalNavigation(
new EdmNavigationPropertyInfo() { Name = "Resolution", Target = resolution, TargetMultiplicity = EdmMultiplicity.ZeroOrOne },
new EdmNavigationPropertyInfo() { Name = "Complaint", TargetMultiplicity = EdmMultiplicity.One });
EdmNavigationProperty loginToLastLogin = login.AddBidirectionalNavigation(
new EdmNavigationPropertyInfo() { Name = "LastLogin", Target = lastLogin, TargetMultiplicity = EdmMultiplicity.ZeroOrOne },
new EdmNavigationPropertyInfo() { Name = "Login", TargetMultiplicity = EdmMultiplicity.One, DependentProperties = new[] { lastLoginUsername }, PrincipalProperties = login.Key()});
EdmNavigationProperty loginToSentMessages = login.AddBidirectionalNavigation(
new EdmNavigationPropertyInfo() { Name = "SentMessages", Target = message, TargetMultiplicity = EdmMultiplicity.Many },
new EdmNavigationPropertyInfo() { Name = "Sender", TargetMultiplicity = EdmMultiplicity.One, DependentProperties = new[] { messageFromUsername }, PrincipalProperties = login.Key()});
EdmNavigationProperty loginToReceivedMessages = login.AddBidirectionalNavigation(
new EdmNavigationPropertyInfo() { Name = "ReceivedMessages", Target = message, TargetMultiplicity = EdmMultiplicity.Many },
new EdmNavigationPropertyInfo() { Name = "Recipient", TargetMultiplicity = EdmMultiplicity.One, DependentProperties = new[] { messageToUsername }, PrincipalProperties = login.Key()});
EdmNavigationProperty loginToOrders = login.AddBidirectionalNavigation(
new EdmNavigationPropertyInfo() { Name = "Orders", Target = order, TargetMultiplicity = EdmMultiplicity.Many },
new EdmNavigationPropertyInfo() { Name = "Login", TargetMultiplicity = EdmMultiplicity.ZeroOrOne });
EdmNavigationProperty loginToSmartCard = login.AddBidirectionalNavigation(
new EdmNavigationPropertyInfo() { Name = "SmartCard", Target = smartCard, TargetMultiplicity = EdmMultiplicity.ZeroOrOne },
new EdmNavigationPropertyInfo() { Name = "Login", TargetMultiplicity = EdmMultiplicity.One, DependentProperties = new[] { smartCardUsername }, PrincipalProperties = login.Key()});
EdmNavigationProperty loginToRsaToken = login.AddBidirectionalNavigation(
new EdmNavigationPropertyInfo() { Name = "RSAToken", Target = rsaToken, TargetMultiplicity = EdmMultiplicity.ZeroOrOne },
new EdmNavigationPropertyInfo() { Name = "Login", TargetMultiplicity = EdmMultiplicity.One });
EdmNavigationProperty loginToPasswordReset = login.AddBidirectionalNavigation(
new EdmNavigationPropertyInfo() { Name = "PasswordResets", Target = passwordReset, TargetMultiplicity = EdmMultiplicity.Many },
new EdmNavigationPropertyInfo() { Name = "Login", TargetMultiplicity = EdmMultiplicity.One, DependentProperties = new[] { passwordResetUsername }, PrincipalProperties = login.Key()});
EdmNavigationProperty loginToPageView = login.AddBidirectionalNavigation(
new EdmNavigationPropertyInfo() { Name = "PageViews", Target = pageView, TargetMultiplicity = EdmMultiplicity.Many },
new EdmNavigationPropertyInfo() { Name = "Login", TargetMultiplicity = EdmMultiplicity.One, DependentProperties = new[] { pageViewUsername }, PrincipalProperties = login.Key()});
EdmNavigationProperty loginToSuspiciousActivity = login.AddBidirectionalNavigation(
new EdmNavigationPropertyInfo() { Name = "SuspiciousActivity", Target = suspiciousActivity, TargetMultiplicity = EdmMultiplicity.Many },
new EdmNavigationPropertyInfo() { Name = "Login", TargetMultiplicity = EdmMultiplicity.ZeroOrOne });
EdmNavigationProperty smartCardToLastLogin = smartCard.AddBidirectionalNavigation(
new EdmNavigationPropertyInfo() { Name = "LastLogin", Target = lastLogin, TargetMultiplicity = EdmMultiplicity.ZeroOrOne },
new EdmNavigationPropertyInfo() { Name = "SmartCard", TargetMultiplicity = EdmMultiplicity.ZeroOrOne });
EdmNavigationProperty orderToOrderLines = order.AddBidirectionalNavigation(
new EdmNavigationPropertyInfo() { Name = "OrderLines", Target = orderLine, TargetMultiplicity = EdmMultiplicity.Many },
new EdmNavigationPropertyInfo() { Name = "Order", TargetMultiplicity = EdmMultiplicity.One, DependentProperties = new[] { orderLineOrderId }, PrincipalProperties = order.Key()});
EdmNavigationProperty orderToOrderNotes = EdmNavigationProperty.CreateNavigationPropertyWithPartner(
new EdmNavigationPropertyInfo() { Name = "Notes", Target = orderNote, TargetMultiplicity = EdmMultiplicity.Many, OnDelete = EdmOnDeleteAction.Cascade },
new EdmNavigationPropertyInfo() { Name = "Order", Target = order, TargetMultiplicity = EdmMultiplicity.One });
order.AddProperty(orderToOrderNotes);
orderNote.AddProperty(orderToOrderNotes.Partner);
EdmNavigationProperty orderToOrderQualityCheck = order.AddBidirectionalNavigation(
new EdmNavigationPropertyInfo() { Name = "OrderQualityCheck", Target = orderQualityCheck, TargetMultiplicity = EdmMultiplicity.ZeroOrOne },
new EdmNavigationPropertyInfo() { Name = "Order", TargetMultiplicity = EdmMultiplicity.One, DependentProperties = new[] { orderQualityCheckId }, PrincipalProperties = order.Key()});
EdmNavigationProperty orderLineToProduct = orderLine.AddBidirectionalNavigation(
new EdmNavigationPropertyInfo() { Name = "Product", Target = product, TargetMultiplicity = EdmMultiplicity.One, DependentProperties = new[] { orderLineProductId }, PrincipalProperties = product.Key()},
new EdmNavigationPropertyInfo() { Name = "OrderLines", TargetMultiplicity = EdmMultiplicity.Many });
EdmNavigationProperty productToRelatedProducts = product.AddBidirectionalNavigation(
new EdmNavigationPropertyInfo() { Name = "RelatedProducts", Target = product, TargetMultiplicity = EdmMultiplicity.Many },
new EdmNavigationPropertyInfo() { Name = "ProductToRelatedProducts", TargetMultiplicity = EdmMultiplicity.One });
EdmNavigationProperty productToSuppliers = product.AddBidirectionalNavigation(
new EdmNavigationPropertyInfo() { Name = "Suppliers", Target = supplier, TargetMultiplicity = EdmMultiplicity.Many },
new EdmNavigationPropertyInfo() { Name = "Products", TargetMultiplicity = EdmMultiplicity.Many });
EdmNavigationProperty productToProductDetail = product.AddBidirectionalNavigation(
new EdmNavigationPropertyInfo() { Name = "Detail", Target = productDetail, TargetMultiplicity = EdmMultiplicity.ZeroOrOne },
new EdmNavigationPropertyInfo() { Name = "Product", TargetMultiplicity = EdmMultiplicity.One, DependentProperties = new[] { productDetailProductId }, PrincipalProperties = product.Key()});
EdmNavigationProperty productToProductReviews = product.AddBidirectionalNavigation(
new EdmNavigationPropertyInfo() { Name = "Reviews", Target = productReview, TargetMultiplicity = EdmMultiplicity.Many },
new EdmNavigationPropertyInfo() { Name = "Product", TargetMultiplicity = EdmMultiplicity.One, DependentProperties = new[] { productReviewProductId }, PrincipalProperties = product.Key()});
EdmNavigationProperty productToProductPhotos = product.AddBidirectionalNavigation(
new EdmNavigationPropertyInfo() { Name = "Photos", Target = productPhoto, TargetMultiplicity = EdmMultiplicity.Many },
new EdmNavigationPropertyInfo() { Name = "Product", TargetMultiplicity = EdmMultiplicity.One, DependentProperties = new[] { productPhotoProductId }, PrincipalProperties = product.Key()});
EdmNavigationProperty productReviewToProductWebFeatures = productReview.AddBidirectionalNavigation(
new EdmNavigationPropertyInfo() { Name = "Features", Target = productWebFeature, TargetMultiplicity = EdmMultiplicity.Many },
new EdmNavigationPropertyInfo() { Name = "Review", TargetMultiplicity = EdmMultiplicity.ZeroOrOne, DependentProperties = new[] { productWebFeatureReviewId, productWebFeatureProductId }, PrincipalProperties = productReview.Key()});
EdmNavigationProperty productPhotoToProductWebFeatures = productPhoto.AddBidirectionalNavigation(
new EdmNavigationPropertyInfo() { Name = "Features", Target = productWebFeature, TargetMultiplicity = EdmMultiplicity.Many },
new EdmNavigationPropertyInfo() { Name = "Photo", TargetMultiplicity = EdmMultiplicity.ZeroOrOne, DependentProperties = new[] { productWebFeaturePhotoId, productWebFeatureProductId }, PrincipalProperties = productPhoto.Key()});
EdmNavigationProperty supplierToSupplierLogo = supplier.AddBidirectionalNavigation(
new EdmNavigationPropertyInfo() { Name = "Logo", Target = supplierLogo, TargetMultiplicity = EdmMultiplicity.ZeroOrOne },
new EdmNavigationPropertyInfo() { Name = "Supplier", TargetMultiplicity = EdmMultiplicity.One, DependentProperties = new[] { supplierLogoSupplierId }, PrincipalProperties = supplier.Key()});
EdmNavigationProperty supplierToSupplierInfo = EdmNavigationProperty.CreateNavigationPropertyWithPartner(
new EdmNavigationPropertyInfo() { Name = "SupplierInfo", Target = supplierInfo, TargetMultiplicity = EdmMultiplicity.Many, OnDelete = EdmOnDeleteAction.Cascade },
new EdmNavigationPropertyInfo() { Name = "Supplier", Target = supplier, TargetMultiplicity = EdmMultiplicity.One });
supplier.AddProperty(supplierToSupplierInfo);
supplierInfo.AddProperty(supplierToSupplierInfo.Partner);
EdmNavigationProperty computerToComputerDetail = computer.AddBidirectionalNavigation(
new EdmNavigationPropertyInfo() { Name = "ComputerDetail", Target = computerDetail, TargetMultiplicity = EdmMultiplicity.One },
new EdmNavigationPropertyInfo() { Name = "Computer", TargetMultiplicity = EdmMultiplicity.One });
EdmNavigationProperty driverTolicense = driver.AddBidirectionalNavigation(
new EdmNavigationPropertyInfo() { Name = "License", Target = license, TargetMultiplicity = EdmMultiplicity.One },
new EdmNavigationPropertyInfo() { Name = "Driver", TargetMultiplicity = EdmMultiplicity.One, DependentProperties = new[] { licenseName }, PrincipalProperties = driver.Key()});
EdmNavigationProperty personToPersonMetadata = person.AddBidirectionalNavigation(
new EdmNavigationPropertyInfo() { Name = "PersonMetadata", Target = personMetadata, TargetMultiplicity = EdmMultiplicity.Many },
new EdmNavigationPropertyInfo() { Name = "Person", TargetMultiplicity = EdmMultiplicity.One, DependentProperties = new[] { personMetadataPersonId }, PrincipalProperties = person.Key()});
EdmNavigationProperty employeeToManager = employee.AddBidirectionalNavigation(
new EdmNavigationPropertyInfo() { Name = "Manager", Target = employee, TargetMultiplicity = EdmMultiplicity.One, DependentProperties = new[] { employeeManagerId }, PrincipalProperties = employee.Key()},
new EdmNavigationPropertyInfo() { Name = "EmployeeToManager", TargetMultiplicity = EdmMultiplicity.Many });
EdmNavigationProperty specialEmployeeToCar = specialEmployee.AddBidirectionalNavigation(
new EdmNavigationPropertyInfo() { Name = "Car", Target = car, TargetMultiplicity = EdmMultiplicity.One, DependentProperties = new[] { specialEmployeeCarsVIN }, PrincipalProperties = car.Key()},
new EdmNavigationPropertyInfo() { Name = "SpecialEmployee", TargetMultiplicity = EdmMultiplicity.Many });
EdmOperation getPrimitiveString = new EdmFunction("DefaultNamespace", "GetPrimitiveString", EdmCoreModel.Instance.GetString(true));
model.AddElement(getPrimitiveString);
EdmOperation getSpecificCustomer = new EdmFunction("DefaultNamespace", "GetSpecificCustomer", EdmCoreModel.GetCollection(new EdmEntityTypeReference(customer, true)));
getSpecificCustomer.AddParameter("Name", EdmCoreModel.Instance.GetString(false));
model.AddElement(getSpecificCustomer);
EdmOperation getCustomerCount = new EdmFunction("DefaultNamespace", "GetCustomerCount", EdmCoreModel.Instance.GetInt32(true));
model.AddElement(getCustomerCount);
EdmOperation getArgumentPlusOne = new EdmFunction("DefaultNamespace", "GetArgumentPlusOne", EdmCoreModel.Instance.GetInt32(true));
getArgumentPlusOne.AddParameter("arg1", EdmCoreModel.Instance.GetInt32(false));
model.AddElement(getArgumentPlusOne);
EdmOperation entityProjectionReturnsCollectionOfComplexTypes = new EdmFunction("DefaultNamespace", "EntityProjectionReturnsCollectionOfComplexTypes", EdmCoreModel.GetCollection(new EdmComplexTypeReference(contact, true)));
model.AddElement(entityProjectionReturnsCollectionOfComplexTypes);
EdmOperation setArgumentPlusOne = new EdmAction("DefaultNamespace", "SetArgumentPlusOne", EdmCoreModel.Instance.GetInt32(true));
setArgumentPlusOne.AddParameter("arg1", EdmCoreModel.Instance.GetInt32(false));
model.AddElement(setArgumentPlusOne);
EdmEntityContainer container = new EdmEntityContainer("DefaultNamespace", "DefaultContainer");
model.AddElement(container);
EdmEntitySet carSet = container.AddEntitySet("Car", car);
EdmEntitySet customerSet = container.AddEntitySet("Customer", customer);
EdmEntitySet barcodeSet = container.AddEntitySet("Barcode", barcode);
EdmEntitySet incorrectScanSet = container.AddEntitySet("IncorrectScan", incorrectScan);
EdmEntitySet barcodeDetailSet = container.AddEntitySet("BarcodeDetail", barcodeDetail);
EdmEntitySet complaintSet = container.AddEntitySet("Complaint", complaint);
EdmEntitySet resolutionSet = container.AddEntitySet("Resolution", resolution);
EdmEntitySet loginSet = container.AddEntitySet("Login", login);
EdmEntitySet suspiciousActivitySet = container.AddEntitySet("SuspiciousActivity", suspiciousActivity);
EdmEntitySet smartCardSet = container.AddEntitySet("SmartCard", smartCard);
EdmEntitySet rsaTokenSet = container.AddEntitySet("RSAToken", rsaToken);
EdmEntitySet passwordResetSet = container.AddEntitySet("PasswordReset", passwordReset);
EdmEntitySet pageViewSet = container.AddEntitySet("PageView", pageView);
EdmEntitySet lastLoginSet = container.AddEntitySet("LastLogin", lastLogin);
EdmEntitySet messageSet = container.AddEntitySet("Message", message);
EdmEntitySet orderSet = container.AddEntitySet("Order", order);
EdmEntitySet orderNoteSet = container.AddEntitySet("OrderNote", orderNote);
EdmEntitySet orderQualityCheckSet = container.AddEntitySet("OrderQualityCheck", orderQualityCheck);
EdmEntitySet orderLineSet = container.AddEntitySet("OrderLine", orderLine);
EdmEntitySet productSet = container.AddEntitySet("Product", product);
EdmEntitySet productDetailSet = container.AddEntitySet("ProductDetail", productDetail);
EdmEntitySet productReviewSet = container.AddEntitySet("ProductReview", productReview);
EdmEntitySet productPhotoSet = container.AddEntitySet("ProductPhoto", productPhoto);
EdmEntitySet productWebFeatureSet = container.AddEntitySet("ProductWebFeature", productWebFeature);
EdmEntitySet supplierSet = container.AddEntitySet("Supplier", supplier);
EdmEntitySet supplierLogoSet = container.AddEntitySet("SupplierLogo", supplierLogo);
EdmEntitySet supplierInfoSet = container.AddEntitySet("SupplierInfo", supplierInfo);
EdmEntitySet customerInfoSet = container.AddEntitySet("CustomerInfo", customerInfo);
EdmEntitySet computerSet = container.AddEntitySet("Computer", computer);
EdmEntitySet computerDetailSet = container.AddEntitySet("ComputerDetail", computerDetail);
EdmEntitySet driverSet = container.AddEntitySet("Driver", driver);
EdmEntitySet licenseSet = container.AddEntitySet("License", license);
EdmEntitySet mappedEntitySet = container.AddEntitySet("MappedEntityType", mappedEntity);
EdmEntitySet personSet = container.AddEntitySet("Person", person);
EdmEntitySet personMetadataSet = container.AddEntitySet("PersonMetadata", personMetadata);
complaintSet.AddNavigationTarget(customerToComplaint.Partner, customerSet);
loginSet.AddNavigationTarget(loginToSentMessages, messageSet);
loginSet.AddNavigationTarget(loginToReceivedMessages, messageSet);
customerInfoSet.AddNavigationTarget(customerToInfo.Partner, customerSet);
supplierSet.AddNavigationTarget(supplierToSupplierInfo, supplierInfoSet);
loginSet.AddNavigationTarget(loginToOrders, orderSet);
orderSet.AddNavigationTarget(orderToOrderNotes, orderNoteSet);
orderSet.AddNavigationTarget(orderToOrderQualityCheck, orderQualityCheckSet);
supplierSet.AddNavigationTarget(supplierToSupplierLogo, supplierLogoSet);
customerSet.AddNavigationTarget(customerToOrders, orderSet);
customerSet.AddNavigationTarget(customerToLogins, loginSet);
loginSet.AddNavigationTarget(loginToLastLogin, lastLoginSet);
lastLoginSet.AddNavigationTarget(smartCardToLastLogin.Partner, smartCardSet);
orderSet.AddNavigationTarget(orderToOrderLines, orderLineSet);
productSet.AddNavigationTarget(orderLineToProduct.Partner, orderLineSet);
productSet.AddNavigationTarget(productToRelatedProducts, productSet);
productSet.AddNavigationTarget(productToProductDetail, productDetailSet);
productSet.AddNavigationTarget(productToProductReviews, productReviewSet);
productSet.AddNavigationTarget(productToProductPhotos, productPhotoSet);
productWebFeatureSet.AddNavigationTarget(productPhotoToProductWebFeatures.Partner, productPhotoSet);
productWebFeatureSet.AddNavigationTarget(productReviewToProductWebFeatures.Partner, productReviewSet);
complaintSet.AddNavigationTarget(complaintToResolution, resolutionSet);
barcodeSet.AddNavigationTarget(barcodeToExpectedIncorrectScans, incorrectScanSet);
customerSet.AddNavigationTarget(customerToHusband.Partner, customerSet);
barcodeSet.AddNavigationTarget(barcodeToActualIncorrectScans, incorrectScanSet);
productSet.AddNavigationTarget(barcodeToProduct.Partner, barcodeSet);
barcodeSet.AddNavigationTarget(barcodeToBarcodeDetail, barcodeDetailSet);
loginSet.AddNavigationTarget(loginToSuspiciousActivity, suspiciousActivitySet);
loginSet.AddNavigationTarget(loginToRsaToken, rsaTokenSet);
loginSet.AddNavigationTarget(loginToSmartCard, smartCardSet);
loginSet.AddNavigationTarget(loginToPasswordReset, passwordResetSet);
loginSet.AddNavigationTarget(loginToPageView, pageViewSet);
computerSet.AddNavigationTarget(computerToComputerDetail, computerDetailSet);
driverSet.AddNavigationTarget(driverTolicense, licenseSet);
personSet.AddNavigationTarget(personToPersonMetadata, personMetadataSet);
productSet.AddNavigationTarget(productToSuppliers, supplierSet);
carSet.AddNavigationTarget(specialEmployeeToCar.Partner, personSet);
personSet.AddNavigationTarget(employeeToManager, personSet);
this.BasicConstructibleModelTestSerializingStockModel(ODataTestModelBuilder.ODataTestModelDefaultModel, model);
}
public void ConstructibleModelODataTestModelBasicTest()
{
EdmModel model = new EdmModel();
EdmComplexType address = new EdmComplexType("TestModel", "Address");
model.AddElement(address);
EdmStructuralProperty addressStreet = address.AddStructuralProperty("Street", EdmCoreModel.Instance.GetString(true));
EdmStructuralProperty addressZip = new EdmStructuralProperty(address, "Zip", EdmCoreModel.Instance.GetInt32(false));
address.AddProperty(addressZip);
EdmEntityType office = new EdmEntityType("TestModel", "OfficeType");
EdmStructuralProperty officeId = office.AddStructuralProperty("Id", EdmCoreModel.Instance.GetInt32(false));
office.AddKeys(officeId);
EdmStructuralProperty officeAddress = office.AddStructuralProperty("Address", new EdmComplexTypeReference(address, false));
model.AddElement(office);
EdmEntityType city = new EdmEntityType("TestModel", "CityType");
EdmStructuralProperty cityId = city.AddStructuralProperty("Id", EdmCoreModel.Instance.GetInt32(false));
city.AddKeys(cityId);
EdmStructuralProperty cityName = city.AddStructuralProperty("Name", EdmCoreModel.Instance.GetString(true));
EdmStructuralProperty citySkyline = city.AddStructuralProperty("Skyline", EdmCoreModel.Instance.GetStream(false));
EdmStructuralProperty cityMetroLanes = city.AddStructuralProperty("MetroLanes", EdmCoreModel.GetCollection(EdmCoreModel.Instance.GetString(true)));
EdmNavigationProperty cityHall = city.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo() { Name = "CityHall", Target = office, TargetMultiplicity = EdmMultiplicity.Many });
EdmNavigationProperty dol = city.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo() { Name = "DOL", Target = office, TargetMultiplicity = EdmMultiplicity.Many });
EdmNavigationProperty policeStation = city.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo() { Name = "PoliceStation", Target = office, TargetMultiplicity = EdmMultiplicity.One });
model.AddElement(city);
EdmEntityType cityWithMap = new EdmEntityType("TestModel", "CityWithMapType", city);
model.AddElement(cityWithMap);
EdmEntityType cityOpenType = new EdmEntityType("TestModel", "CityOpenType", city, false, true);
model.AddElement(cityOpenType);
EdmEntityType person = new EdmEntityType("TestModel", "Person");
EdmStructuralProperty personId = person.AddStructuralProperty("Id", EdmCoreModel.Instance.GetInt32(false));
person.AddKeys(personId);
model.AddElement(person);
EdmNavigationProperty friend = person.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo() { Name = "Friend", Target = person, TargetMultiplicity = EdmMultiplicity.Many });
EdmEntityType employee = new EdmEntityType("TestModel", "Employee", person);
EdmStructuralProperty companyName = employee.AddStructuralProperty("CompanyName", EdmCoreModel.Instance.GetString(true));
model.AddElement(employee);
EdmEntityType manager = new EdmEntityType("TestModel", "Manager", employee);
EdmStructuralProperty level = manager.AddStructuralProperty("Level", EdmCoreModel.Instance.GetInt32(false));
model.AddElement(manager);
EdmEntityContainer container = new EdmEntityContainer("TestModel", "DefaultContainer");
EdmEntitySet officeSet = new EdmEntitySet(container, "OfficeType", office);
container.AddElement(officeSet);
EdmEntitySet citySet = container.AddEntitySet("CityType", city);
EdmEntitySet personSet = container.AddEntitySet("Person", person);
citySet.AddNavigationTarget(cityHall, officeSet);
citySet.AddNavigationTarget(dol, officeSet);
citySet.AddNavigationTarget(policeStation, officeSet);
personSet.AddNavigationTarget(friend, personSet);
EdmAction serviceOperationAction = new EdmAction("TestModel", "ServiceOperation1", EdmCoreModel.Instance.GetInt32(true));
EdmOperationParameter a = new EdmOperationParameter(serviceOperationAction, "a", EdmCoreModel.Instance.GetInt32(true));
serviceOperationAction.AddParameter(a);
serviceOperationAction.AddParameter("b", EdmCoreModel.Instance.GetString(true));
model.AddElement(serviceOperationAction);
container.AddActionImport("ServiceOperation1", serviceOperationAction);
model.AddElement(container);
this.BasicConstructibleModelTestSerializingStockModel(ODataTestModelBuilder.ODataTestModelBasicTest, model);
}
public static IEdmModel CreateModel(string ns)
{
EdmModel model = new EdmModel();
var defaultContainer = new EdmEntityContainer(ns, "DefaultContainer");
model.AddElement(defaultContainer);
var nameType = new EdmTypeDefinition(ns, "Name", EdmPrimitiveTypeKind.String);
model.AddElement(nameType);
var addressType = new EdmComplexType(ns, "Address");
addressType.AddProperty(new EdmStructuralProperty(addressType, "Road", new EdmTypeDefinitionReference(nameType, false)));
addressType.AddProperty(new EdmStructuralProperty(addressType, "City", EdmCoreModel.Instance.GetString(false)));
model.AddElement(addressType);
var personType = new EdmEntityType(ns, "Person");
var personIdProperty = new EdmStructuralProperty(personType, "PersonId", EdmCoreModel.Instance.GetInt32(false));
personType.AddProperty(personIdProperty);
personType.AddKeys(new IEdmStructuralProperty[] { personIdProperty });
personType.AddProperty(new EdmStructuralProperty(personType, "FirstName", new EdmTypeDefinitionReference(nameType, false)));
personType.AddProperty(new EdmStructuralProperty(personType, "LastName", new EdmTypeDefinitionReference(nameType, false)));
personType.AddProperty(new EdmStructuralProperty(personType, "Address", new EdmComplexTypeReference(addressType, true)));
personType.AddProperty(new EdmStructuralProperty(personType, "Descriptions", new EdmCollectionTypeReference(new EdmCollectionType(new EdmTypeDefinitionReference(nameType, false)))));
model.AddElement(personType);
var peopleSet = new EdmEntitySet(defaultContainer, "People", personType);
defaultContainer.AddElement(peopleSet);
var numberComboType = new EdmComplexType(ns, "NumberCombo");
numberComboType.AddProperty(new EdmStructuralProperty(numberComboType, "Small", model.GetUInt16(ns, false)));
numberComboType.AddProperty(new EdmStructuralProperty(numberComboType, "Middle", model.GetUInt32(ns, false)));
numberComboType.AddProperty(new EdmStructuralProperty(numberComboType, "Large", model.GetUInt64(ns, false)));
model.AddElement(numberComboType);
var productType = new EdmEntityType(ns, "Product");
var productIdProperty = new EdmStructuralProperty(productType, "ProductId", model.GetUInt16(ns, false));
productType.AddProperty(productIdProperty);
productType.AddKeys(new IEdmStructuralProperty[] { productIdProperty });
productType.AddProperty(new EdmStructuralProperty(productType, "Quantity", model.GetUInt32(ns, false)));
productType.AddProperty(new EdmStructuralProperty(productType, "NullableUInt32", model.GetUInt32(ns, true)));
productType.AddProperty(new EdmStructuralProperty(productType, "LifeTimeInSeconds", model.GetUInt64(ns, false)));
productType.AddProperty(new EdmStructuralProperty(productType, "TheCombo", new EdmComplexTypeReference(numberComboType, true)));
productType.AddProperty(new EdmStructuralProperty(productType, "LargeNumbers", new EdmCollectionTypeReference(new EdmCollectionType(model.GetUInt64(ns, false)))));
model.AddElement(productType);
var productsSet = new EdmEntitySet(defaultContainer, "Products", productType);
defaultContainer.AddElement(productsSet);
//Bound Function: bound to entity, return defined type
var getFullNameFunction = new EdmFunction(ns, "GetFullName", new EdmTypeDefinitionReference(nameType, false), true, null, false);
getFullNameFunction.AddParameter("person", new EdmEntityTypeReference(personType, false));
getFullNameFunction.AddParameter("nickname", new EdmTypeDefinitionReference(nameType, false));
model.AddElement(getFullNameFunction);
//Bound Action: bound to entity, return UInt64
var extendLifeTimeAction = new EdmAction(ns, "ExtendLifeTime", model.GetUInt64(ns, false), true, null);
extendLifeTimeAction.AddParameter("product", new EdmEntityTypeReference(productType, false));
extendLifeTimeAction.AddParameter("seconds", model.GetUInt32(ns, false));
model.AddElement(extendLifeTimeAction);
//UnBound Action: ResetDataSource
var resetDataSourceAction = new EdmAction(ns, "ResetDataSource", null, false, null);
model.AddElement(resetDataSourceAction);
defaultContainer.AddActionImport(resetDataSourceAction);
IEnumerable<EdmError> errors = null;
model.Validate(out errors);
return model;
}
/// <summary>
/// Creates an Edm property.
/// </summary>
/// <param name="declaringType">Type declaring this property.</param>
/// <param name="propertyInfo">PropertyInfo instance for this property.</param>
/// <returns>Returns a new instance of Edm property.</returns>
private IEdmProperty CreateEdmProperty(IEdmStructuredType declaringType, PropertyInfo propertyInfo)
{
IEdmType propertyEdmType = this.GetOrCreateEdmType(propertyInfo.PropertyType);
Debug.Assert(
propertyEdmType.TypeKind == EdmTypeKind.Entity ||
propertyEdmType.TypeKind == EdmTypeKind.Complex ||
propertyEdmType.TypeKind == EdmTypeKind.Enum ||
propertyEdmType.TypeKind == EdmTypeKind.Primitive ||
propertyEdmType.TypeKind == EdmTypeKind.Collection,
"Property kind should be Entity, Complex, Enum, Primitive or Collection.");
IEdmProperty edmProperty;
bool isPropertyNullable = ClientTypeUtil.CanAssignNull(propertyInfo.PropertyType);
if (propertyEdmType.TypeKind == EdmTypeKind.Entity || (propertyEdmType.TypeKind == EdmTypeKind.Collection && ((IEdmCollectionType)propertyEdmType).ElementType.TypeKind() == EdmTypeKind.Entity))
{
IEdmEntityType declaringEntityType = declaringType as IEdmEntityType;
if (declaringEntityType == null)
{
throw c.Error.InvalidOperation(c.Strings.ClientTypeCache_NonEntityTypeCannotContainEntityProperties(propertyInfo.Name, propertyInfo.DeclaringType.ToString()));
}
// Create a navigation property representing one side of an association.
// The partner representing the other side exists only inside this property and is not added to the target entity type,
// so it should not cause any name collisions.
edmProperty = EdmNavigationProperty.CreateNavigationPropertyWithPartner(
ClientTypeUtil.GetServerDefinedName(propertyInfo),
propertyEdmType.ToEdmTypeReference(isPropertyNullable),
/*dependentProperties*/ null,
/*principalProperties*/ null,
/*containsTarget*/ false,
EdmOnDeleteAction.None,
"Partner",
declaringEntityType.ToEdmTypeReference(true),
/*partnerDependentProperties*/ null,
/*partnerPrincipalProperties*/ null,
/*partnerContainsTarget*/ false,
EdmOnDeleteAction.None);
}
else
{
edmProperty = new EdmStructuralProperty(declaringType, ClientTypeUtil.GetServerDefinedName(propertyInfo), propertyEdmType.ToEdmTypeReference(isPropertyNullable));
}
edmProperty.SetClientPropertyAnnotation(new ClientPropertyAnnotation(edmProperty, propertyInfo, this));
return edmProperty;
}
public void WriteNullEntryWithOperation()
{
EdmEntityType entityType = new EdmEntityType("NS", "Entity");
IEdmStructuralProperty keyProp = new EdmStructuralProperty(entityType, "Id", EdmCoreModel.Instance.GetInt32(false));
entityType.AddProperty(keyProp);
entityType.AddKeys(keyProp);
EdmOperation operation = new EdmFunction("NS", "Foo", EdmCoreModel.Instance.GetInt16(true));
operation.AddParameter("entry", new EdmEntityTypeReference(entityType, true));
Action<ODataJsonLightOutputContext> test = outputContext =>
{
var parameterWriter = new ODataJsonLightParameterWriter(outputContext, operation);
parameterWriter.WriteStart();
var entryWriter = parameterWriter.CreateEntryWriter("entry");
entryWriter.WriteStart((ODataEntry)null);
entryWriter.WriteEnd();
parameterWriter.WriteEnd();
parameterWriter.Flush();
};
WriteAndValidate(test, "{\"entry\":null}", writingResponse: false);
}
public static IEdmModel CreateModel(string ns)
{
EdmModel model = new EdmModel();
var defaultContainer = new EdmEntityContainer(ns, "DefaultContainer");
model.AddElement(defaultContainer);
var orderDetail = new EdmComplexType(ns, "orderDetail");
orderDetail.AddProperty(new EdmStructuralProperty(orderDetail, "amount", EdmCoreModel.Instance.GetDecimal(false)));
orderDetail.AddProperty(new EdmStructuralProperty(orderDetail, "quantity", EdmCoreModel.Instance.GetInt32(false)));
model.AddElement(orderDetail);
var billingType = new EdmEnumType(ns, "billingType", EdmPrimitiveTypeKind.Int64, false);
billingType.AddMember("fund", new EdmIntegerConstant(0));
billingType.AddMember("refund", new EdmIntegerConstant(1));
billingType.AddMember("chargeback", new EdmIntegerConstant(2));
model.AddElement(billingType);
var category = new EdmEnumType(ns, "category", true);
category.AddMember("toy", new EdmIntegerConstant(1));
category.AddMember("food", new EdmIntegerConstant(2));
category.AddMember("cloth", new EdmIntegerConstant(4));
category.AddMember("drink", new EdmIntegerConstant(8));
category.AddMember("computer", new EdmIntegerConstant(16));
model.AddElement(category);
var namedObject = new EdmEntityType(ns, "namedObject");
var idProperty = new EdmStructuralProperty(namedObject, "id", EdmCoreModel.Instance.GetInt32(false));
namedObject.AddProperty(idProperty);
namedObject.AddKeys(idProperty);
namedObject.AddProperty(new EdmStructuralProperty(namedObject, "name", EdmCoreModel.Instance.GetString(false)));
model.AddElement(namedObject);
var order = new EdmEntityType(ns, "order", namedObject);
order.AddProperty(new EdmStructuralProperty(order, "description", EdmCoreModel.Instance.GetString(false)));
order.AddProperty(new EdmStructuralProperty(order, "detail", new EdmComplexTypeReference(orderDetail, true)));
order.AddProperty(new EdmStructuralProperty(order, "lineItems",
new EdmCollectionTypeReference(new EdmCollectionType(EdmCoreModel.Instance.GetString(false)))));
order.AddProperty(new EdmStructuralProperty(order, "categories", new EdmEnumTypeReference(category, false)));
model.AddElement(order);
var billingRecord = new EdmEntityType(ns, "billingRecord", namedObject);
billingRecord.AddProperty(new EdmStructuralProperty(billingRecord, "amount", EdmCoreModel.Instance.GetDecimal(false)));
billingRecord.AddProperty(new EdmStructuralProperty(billingRecord, "type", new EdmEnumTypeReference(billingType, false)));
model.AddElement(billingRecord);
var store = new EdmEntityType(ns, "store", namedObject);
store.AddProperty(new EdmStructuralProperty(store, "address", EdmCoreModel.Instance.GetString(false)));
model.AddElement(store);
var orders = new EdmEntitySet(defaultContainer, "orders", order);
defaultContainer.AddElement(orders);
var billingRecords = new EdmEntitySet(defaultContainer, "billingRecords", billingRecord);
defaultContainer.AddElement(billingRecords);
var myStore = new EdmSingleton(defaultContainer, "myStore", store);
defaultContainer.AddElement(myStore);
var order2billingRecord = order.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo
{
Name = "billingRecords",
Target = billingRecord,
TargetMultiplicity = EdmMultiplicity.Many
});
((EdmEntitySet)orders).AddNavigationTarget(order2billingRecord, billingRecords);
IEnumerable<EdmError> errors = null;
model.Validate(out errors);
return model;
}
private static IEdmModel BuildModel()
{
EdmModel model = new EdmModel();
var movieType = new EdmEntityType("TestModel", "Movie");
EdmStructuralProperty idProperty = new EdmStructuralProperty(movieType, "Id", EdmCoreModel.Instance.GetInt32(false));
movieType.AddProperty(idProperty);
movieType.AddKeys(idProperty);
movieType.AddProperty(new EdmStructuralProperty(movieType, "Name", EdmCoreModel.Instance.GetString(true)));
model.AddElement(movieType);
var tvMovieType = new EdmEntityType("TestModel", "TVMovie", movieType);
tvMovieType.AddProperty(new EdmStructuralProperty(tvMovieType, "Channel", EdmCoreModel.Instance.GetString(false)));
model.AddElement(tvMovieType);
EdmEntityContainer defaultContainer = new EdmEntityContainer("TestModel", "Default");
defaultContainer.AddEntitySet("Movies", movieType);
model.AddElement(defaultContainer);
EdmAction simpleAction = new EdmAction("TestModel", "SimpleAction", null /*returnType*/, false /*isBound*/, null /*entitySetPath*/);
model.AddElement(simpleAction);
defaultContainer.AddActionImport(simpleAction);
EdmAction checkoutAction1 = new EdmAction("TestModel", "Checkout", EdmCoreModel.Instance.GetInt32(false), false /*isBound*/, null /*entitySetPath*/);
checkoutAction1.AddParameter("movie", movieType.ToTypeReference());
checkoutAction1.AddParameter("duration", EdmCoreModel.Instance.GetInt32(false));
model.AddElement(checkoutAction1);
EdmAction rateAction1 = new EdmAction("TestModel", "Rate", null /*returnType*/, true /*isBound*/, null /*entitySetPath*/);
rateAction1.AddParameter("movie", movieType.ToTypeReference());
rateAction1.AddParameter("rating", EdmCoreModel.Instance.GetInt32(false));
model.AddElement(rateAction1);
EdmAction changeChannelAction1 = new EdmAction("TestModel", "ChangeChannel", null /*returnType*/, true /*isBound*/, null /*entitySetPath*/);
changeChannelAction1.AddParameter("movie", tvMovieType.ToTypeReference());
changeChannelAction1.AddParameter("channel", EdmCoreModel.Instance.GetString(false));
model.AddElement(changeChannelAction1);
EdmAction checkoutAction = new EdmAction("TestModel", "Checkout", EdmCoreModel.Instance.GetInt32(false) /*returnType*/, false /*isBound*/, null /*entitySetPath*/);
checkoutAction.AddParameter("movie", movieType.ToTypeReference());
checkoutAction.AddParameter("duration", EdmCoreModel.Instance.GetInt32(false));
model.AddElement(checkoutAction);
var movieCollectionTypeReference = (new EdmCollectionType(movieType.ToTypeReference(nullable: false))).ToTypeReference(nullable:false);
EdmAction checkoutMultiple1Action = new EdmAction("TestModel", "CheckoutMultiple", EdmCoreModel.Instance.GetInt32(false), false /*isBound*/, null /*entitySetPath*/);
checkoutMultiple1Action.AddParameter("movies", movieCollectionTypeReference);
checkoutMultiple1Action.AddParameter("duration", EdmCoreModel.Instance.GetInt32(false));
model.AddElement(checkoutMultiple1Action);
EdmAction rateMultiple1Action = new EdmAction("TestModel", "RateMultiple", null /*returnType*/, true /*isBound*/, null /*entitySetPath*/);
rateMultiple1Action.AddParameter("movies", movieCollectionTypeReference);
rateMultiple1Action.AddParameter("rating", EdmCoreModel.Instance.GetInt32(false));
model.AddElement(rateMultiple1Action);
EdmAction checkoutMultiple2Action = new EdmAction("TestModel", "CheckoutMultiple", EdmCoreModel.Instance.GetInt32(false) /*returnType*/, false /*isBound*/, null /*entitySetPath*/);
checkoutMultiple2Action.AddParameter("movies", movieCollectionTypeReference);
checkoutMultiple2Action.AddParameter("duration", EdmCoreModel.Instance.GetInt32(false));
model.AddElement(checkoutMultiple2Action);
EdmAction rateMultiple2Action = new EdmAction("TestModel", "RateMultiple", null /*returnType*/, true /*isBound*/, null /*entitySetPath*/);
rateMultiple2Action.AddParameter("movies", movieCollectionTypeReference);
rateMultiple2Action.AddParameter("rating", EdmCoreModel.Instance.GetInt32(false));
model.AddElement(rateMultiple2Action);
return model;
}
public void WriteDerivedEntityInFeed()
{
EdmEntityType entityType = new EdmEntityType("NS", "Entity");
IEdmStructuralProperty keyProp = new EdmStructuralProperty(entityType, "Id", EdmCoreModel.Instance.GetInt32(false));
entityType.AddProperty(keyProp);
entityType.AddKeys(keyProp);
EdmEntityType derivedType = new EdmEntityType("NS", "DerivedType", entityType);
derivedType.AddProperty(new EdmStructuralProperty(derivedType, "Name", EdmCoreModel.Instance.GetString(false)));
EdmOperation operation = new EdmFunction("NS", "Foo", EdmCoreModel.Instance.GetInt16(true));
operation.AddParameter("feed", new EdmCollectionTypeReference(new EdmCollectionType(new EdmEntityTypeReference(entityType, false))));
Action<ODataJsonLightOutputContext> test = outputContext =>
{
var entry = new ODataEntry()
{
TypeName = "NS.DerivedType",
};
entry.Properties = new List<ODataProperty>()
{
new ODataProperty() { Name = "ID", Value = 1 },
new ODataProperty() { Name = "Name", Value = "TestName"}
};
var parameterWriter = new ODataJsonLightParameterWriter(outputContext, operation: null);
parameterWriter.WriteStart();
var entryWriter = parameterWriter.CreateFeedWriter("feed");
entryWriter.WriteStart(new ODataFeed());
entryWriter.WriteStart(entry);
entryWriter.WriteEnd();
entryWriter.WriteEnd();
parameterWriter.WriteEnd();
parameterWriter.Flush();
};
WriteAndValidate(test, "{\"feed\":[{\"@odata.type\":\"#NS.DerivedType\",\"ID\":1,\"Name\":\"TestName\"}]}", writingResponse: false);
}
