static InstanceAnnotationWriterIntegrationTests()
{
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
});
ComplexType = new EdmComplexType("TestNamespace", "Address");
Model.AddElement(ComplexType);
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);
Singleton = new EdmSingleton(defaultContainer, "TestSingleton", EntityType);
Singleton.AddNavigationTarget(resourceNavigationProperty, EntitySet);
Singleton.AddNavigationTarget(resourceSetNavigationProperty, EntitySet);
defaultContainer.AddElement(Singleton);
}
public void EdmSingletonBasicNavigationPropertyBindingTest()
{
var internalOrderProperty = customerType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo()
{
Name = "InternalOrder", Target = this.orderType, TargetMultiplicity = EdmMultiplicity.ZeroOrOne
});
var externalOrderProperty = customerType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo()
{
Name = "ExternalOrders", Target = this.orderType, TargetMultiplicity = EdmMultiplicity.Many
});
var customerProductProperty = customerType.AddBidirectionalNavigation(
new EdmNavigationPropertyInfo()
{
Name = "Products", Target = this.productType, TargetMultiplicity = EdmMultiplicity.Many
},
new EdmNavigationPropertyInfo()
{
Name = "Buyer", Target = this.customerType, TargetMultiplicity = EdmMultiplicity.One
});
var orderSet = new EdmEntitySet(this.entityContainer, "Orders", this.orderType);
var productSet = new EdmEntitySet(this.entityContainer, "Products", this.productType);
var vipCustomer = new EdmSingleton(this.entityContainer, "VIP", this.customerType);
Assert.Empty(vipCustomer.NavigationPropertyBindings);
vipCustomer.AddNavigationTarget(internalOrderProperty, orderSet);
vipCustomer.AddNavigationTarget(externalOrderProperty, orderSet);
vipCustomer.AddNavigationTarget(customerProductProperty, productSet);
Assert.Equal(3, vipCustomer.NavigationPropertyBindings.Count());
Assert.Contains(vipCustomer.NavigationPropertyBindings, m => m.NavigationProperty == internalOrderProperty && m.Target == orderSet);
Assert.Contains(vipCustomer.NavigationPropertyBindings, m => m.NavigationProperty == externalOrderProperty && m.Target == orderSet);
Assert.Contains(vipCustomer.NavigationPropertyBindings, m => m.NavigationProperty == customerProductProperty && m.Target == productSet);
Assert.Same(orderSet, vipCustomer.FindNavigationTarget(internalOrderProperty));
Assert.Same(orderSet, vipCustomer.FindNavigationTarget(externalOrderProperty));
Assert.Same(productSet, vipCustomer.FindNavigationTarget(customerProductProperty));
productSet.AddNavigationTarget(customerProductProperty.Partner, vipCustomer);
Assert.Same(vipCustomer, productSet.FindNavigationTarget(customerProductProperty.Partner));
}
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);
}
private static IEdmModel GetEdmModel()
{
EdmModel model = new EdmModel();
// Customer
EdmEntityType customer = new EdmEntityType("NS", "Customer");
customer.AddKeys(customer.AddStructuralProperty("ID", EdmPrimitiveTypeKind.String));
customer.AddStructuralProperty("Name", EdmPrimitiveTypeKind.String);
customer.AddStructuralProperty("Alias", EdmPrimitiveTypeKind.String);
model.AddElement(customer);
// Order
EdmEntityType order = new EdmEntityType("NS", "Order", null, false, true);
order.AddKeys(order.AddStructuralProperty("ID", EdmPrimitiveTypeKind.Int32));
model.AddElement(order);
// MyOrder
EdmEntityType myOrder = new EdmEntityType("NS", "MyOrder", order);
myOrder.AddKeys(myOrder.AddStructuralProperty("ID", EdmPrimitiveTypeKind.Int32));
myOrder.AddStructuralProperty("Title", EdmPrimitiveTypeKind.String);
model.AddElement(myOrder);
EdmNavigationProperty ordersNavProp = customer.AddUnidirectionalNavigation(
new EdmNavigationPropertyInfo
{
Name = "Orders",
TargetMultiplicity = EdmMultiplicity.Many,
Target = order
});
EdmEntityContainer container = new EdmEntityContainer("NS", "Default");
EdmEntitySet orders = container.AddEntitySet("Orders", order);
EdmEntitySet customers = container.AddEntitySet("Customers", customer);
customers.AddNavigationTarget(ordersNavProp, orders);
EdmSingleton vipCustomer = container.AddSingleton("VipCustomer", customer);
vipCustomer.AddNavigationTarget(ordersNavProp, orders);
model.AddElement(container);
return(model);
}
public CustomersModelWithInheritance()
{
EdmModel model = new EdmModel();
// Enum type simpleEnum
EdmEnumType simpleEnum = new EdmEnumType("NS", "SimpleEnum");
simpleEnum.AddMember(new EdmEnumMember(simpleEnum, "First", new EdmEnumMemberValue(0)));
simpleEnum.AddMember(new EdmEnumMember(simpleEnum, "Second", new EdmEnumMemberValue(1)));
simpleEnum.AddMember(new EdmEnumMember(simpleEnum, "Third", new EdmEnumMemberValue(2)));
model.AddElement(simpleEnum);
// complex type address
EdmComplexType address = new EdmComplexType("NS", "Address");
address.AddStructuralProperty("Street", EdmPrimitiveTypeKind.String);
address.AddStructuralProperty("City", EdmPrimitiveTypeKind.String);
address.AddStructuralProperty("State", EdmPrimitiveTypeKind.String);
address.AddStructuralProperty("ZipCode", EdmPrimitiveTypeKind.String);
address.AddStructuralProperty("CountryOrRegion", EdmPrimitiveTypeKind.String);
model.AddElement(address);
// open complex type "Account"
EdmComplexType account = new EdmComplexType("NS", "Account", null, false, true);
account.AddStructuralProperty("Bank", EdmPrimitiveTypeKind.String);
account.AddStructuralProperty("CardNum", EdmPrimitiveTypeKind.Int64);
account.AddStructuralProperty("BankAddress", new EdmComplexTypeReference(address, isNullable: true));
model.AddElement(account);
EdmComplexType specialAccount = new EdmComplexType("NS", "SpecialAccount", account, false, true);
specialAccount.AddStructuralProperty("SpecialCard", EdmPrimitiveTypeKind.String);
model.AddElement(specialAccount);
// entity type customer
EdmEntityType customer = new EdmEntityType("NS", "Customer");
customer.AddKeys(customer.AddStructuralProperty("ID", EdmPrimitiveTypeKind.Int32));
IEdmProperty customerName = customer.AddStructuralProperty("Name", EdmPrimitiveTypeKind.String);
customer.AddStructuralProperty("SimpleEnum", simpleEnum.ToEdmTypeReference(isNullable: false));
customer.AddStructuralProperty("Address", new EdmComplexTypeReference(address, isNullable: true));
customer.AddStructuralProperty("Account", new EdmComplexTypeReference(account, isNullable: true));
IEdmTypeReference primitiveTypeReference = EdmCoreModel.Instance.GetPrimitive(
EdmPrimitiveTypeKind.String,
isNullable: true);
var city = customer.AddStructuralProperty(
"City",
primitiveTypeReference,
defaultValue: null);
model.AddElement(customer);
// derived entity type special customer
EdmEntityType specialCustomer = new EdmEntityType("NS", "SpecialCustomer", customer);
specialCustomer.AddStructuralProperty("SpecialCustomerProperty", EdmPrimitiveTypeKind.Guid);
specialCustomer.AddStructuralProperty("SpecialAddress", new EdmComplexTypeReference(address, isNullable: true));
model.AddElement(specialCustomer);
// entity type order (open entity type)
EdmEntityType order = new EdmEntityType("NS", "Order", null, false, true);
// EdmEntityType order = new EdmEntityType("NS", "Order");
order.AddKeys(order.AddStructuralProperty("ID", EdmPrimitiveTypeKind.Int32));
order.AddStructuralProperty("City", EdmPrimitiveTypeKind.String);
order.AddStructuralProperty("Amount", EdmPrimitiveTypeKind.Int32);
model.AddElement(order);
// derived entity type special order
EdmEntityType specialOrder = new EdmEntityType("NS", "SpecialOrder", order, false, true);
specialOrder.AddStructuralProperty("SpecialOrderProperty", EdmPrimitiveTypeKind.Guid);
model.AddElement(specialOrder);
// test entity
EdmEntityType testEntity = new EdmEntityType("Microsoft.AspNet.OData.Test.Query.Expressions", "TestEntity");
testEntity.AddStructuralProperty("SampleProperty", EdmPrimitiveTypeKind.Binary);
model.AddElement(testEntity);
// containment
// my order
EdmEntityType myOrder = new EdmEntityType("NS", "MyOrder");
myOrder.AddKeys(myOrder.AddStructuralProperty("ID", EdmPrimitiveTypeKind.Int32));
myOrder.AddStructuralProperty("Name", EdmPrimitiveTypeKind.String);
model.AddElement(myOrder);
// order line
EdmEntityType orderLine = new EdmEntityType("NS", "OrderLine");
orderLine.AddKeys(orderLine.AddStructuralProperty("ID", EdmPrimitiveTypeKind.Int32));
orderLine.AddStructuralProperty("Name", EdmPrimitiveTypeKind.String);
model.AddElement(orderLine);
EdmNavigationProperty orderLinesNavProp = myOrder.AddUnidirectionalNavigation(
new EdmNavigationPropertyInfo
{
Name = "OrderLines",
TargetMultiplicity = EdmMultiplicity.Many,
Target = orderLine,
ContainsTarget = true,
});
EdmNavigationProperty nonContainedOrderLinesNavProp = myOrder.AddUnidirectionalNavigation(
new EdmNavigationPropertyInfo
{
Name = "NonContainedOrderLines",
TargetMultiplicity = EdmMultiplicity.Many,
Target = orderLine,
ContainsTarget = false,
});
EdmAction tag = new EdmAction("NS", "tag", returnType: null, isBound: true, entitySetPathExpression: null);
tag.AddParameter("entity", new EdmEntityTypeReference(orderLine, false));
model.AddElement(tag);
// entity sets
EdmEntityContainer container = new EdmEntityContainer("NS", "ModelWithInheritance");
model.AddElement(container);
EdmEntitySet customers = container.AddEntitySet("Customers", customer);
EdmEntitySet orders = container.AddEntitySet("Orders", order);
EdmEntitySet myOrders = container.AddEntitySet("MyOrders", myOrder);
// singletons
EdmSingleton vipCustomer = container.AddSingleton("VipCustomer", customer);
EdmSingleton mary = container.AddSingleton("Mary", customer);
EdmSingleton rootOrder = container.AddSingleton("RootOrder", order);
// annotations
model.SetOptimisticConcurrencyAnnotation(customers, new[] { city });
// containment
IEdmContainedEntitySet orderLines = (IEdmContainedEntitySet)myOrders.FindNavigationTarget(orderLinesNavProp);
// no-containment
IEdmNavigationSource nonContainedOrderLines = myOrders.FindNavigationTarget(nonContainedOrderLinesNavProp);
// actions
EdmAction upgrade = new EdmAction("NS", "upgrade", returnType: null, isBound: true, entitySetPathExpression: null);
upgrade.AddParameter("entity", new EdmEntityTypeReference(customer, false));
model.AddElement(upgrade);
EdmAction specialUpgrade =
new EdmAction("NS", "specialUpgrade", returnType: null, isBound: true, entitySetPathExpression: null);
specialUpgrade.AddParameter("entity", new EdmEntityTypeReference(specialCustomer, false));
model.AddElement(specialUpgrade);
// actions bound to collection
EdmAction upgradeAll = new EdmAction("NS", "UpgradeAll", returnType: null, isBound: true, entitySetPathExpression: null);
upgradeAll.AddParameter("entityset",
new EdmCollectionTypeReference(new EdmCollectionType(new EdmEntityTypeReference(customer, false))));
model.AddElement(upgradeAll);
EdmAction upgradeSpecialAll = new EdmAction("NS", "UpgradeSpecialAll", returnType: null, isBound: true, entitySetPathExpression: null);
upgradeSpecialAll.AddParameter("entityset",
new EdmCollectionTypeReference(new EdmCollectionType(new EdmEntityTypeReference(specialCustomer, false))));
model.AddElement(upgradeSpecialAll);
// functions
IEdmTypeReference returnType = EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.Boolean, isNullable: false);
IEdmTypeReference stringType = EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.String, isNullable: false);
IEdmTypeReference intType = EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.Int32, isNullable: false);
EdmFunction IsUpgraded = new EdmFunction(
"NS",
"IsUpgraded",
returnType,
isBound: true,
entitySetPathExpression: null,
isComposable: false);
IsUpgraded.AddParameter("entity", new EdmEntityTypeReference(customer, false));
model.AddElement(IsUpgraded);
EdmFunction orderByCityAndAmount = new EdmFunction(
"NS",
"OrderByCityAndAmount",
stringType,
isBound: true,
entitySetPathExpression: null,
isComposable: false);
orderByCityAndAmount.AddParameter("entity", new EdmEntityTypeReference(customer, false));
orderByCityAndAmount.AddParameter("city", stringType);
orderByCityAndAmount.AddParameter("amount", intType);
model.AddElement(orderByCityAndAmount);
EdmFunction getOrders = new EdmFunction(
"NS",
"GetOrders",
EdmCoreModel.GetCollection(order.ToEdmTypeReference(false)),
isBound: true,
entitySetPathExpression: null,
isComposable: true);
getOrders.AddParameter("entity", new EdmEntityTypeReference(customer, false));
getOrders.AddParameter("parameter", intType);
model.AddElement(getOrders);
EdmFunction IsSpecialUpgraded = new EdmFunction(
"NS",
"IsSpecialUpgraded",
returnType,
isBound: true,
entitySetPathExpression: null,
isComposable: false);
IsSpecialUpgraded.AddParameter("entity", new EdmEntityTypeReference(specialCustomer, false));
model.AddElement(IsSpecialUpgraded);
EdmFunction getSalary = new EdmFunction(
"NS",
"GetSalary",
stringType,
isBound: true,
entitySetPathExpression: null,
isComposable: false);
getSalary.AddParameter("entity", new EdmEntityTypeReference(customer, false));
model.AddElement(getSalary);
getSalary = new EdmFunction(
"NS",
"GetSalary",
stringType,
isBound: true,
entitySetPathExpression: null,
isComposable: false);
getSalary.AddParameter("entity", new EdmEntityTypeReference(specialCustomer, false));
model.AddElement(getSalary);
EdmFunction IsAnyUpgraded = new EdmFunction(
"NS",
"IsAnyUpgraded",
returnType,
isBound: true,
entitySetPathExpression: null,
isComposable: false);
EdmCollectionType edmCollectionType = new EdmCollectionType(new EdmEntityTypeReference(customer, false));
IsAnyUpgraded.AddParameter("entityset", new EdmCollectionTypeReference(edmCollectionType));
model.AddElement(IsAnyUpgraded);
EdmFunction isCustomerUpgradedWithParam = new EdmFunction(
"NS",
"IsUpgradedWithParam",
returnType,
isBound: true,
entitySetPathExpression: null,
isComposable: false);
isCustomerUpgradedWithParam.AddParameter("entity", new EdmEntityTypeReference(customer, false));
isCustomerUpgradedWithParam.AddParameter("city", EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.String, isNullable: false));
model.AddElement(isCustomerUpgradedWithParam);
EdmFunction isCustomerLocal = new EdmFunction(
"NS",
"IsLocal",
returnType,
isBound: true,
entitySetPathExpression: null,
isComposable: false);
isCustomerLocal.AddParameter("entity", new EdmEntityTypeReference(customer, false));
model.AddElement(isCustomerLocal);
EdmFunction entityFunction = new EdmFunction(
"NS",
"GetCustomer",
returnType,
isBound: true,
entitySetPathExpression: null,
isComposable: false);
entityFunction.AddParameter("entity", new EdmEntityTypeReference(customer, false));
entityFunction.AddParameter("customer", new EdmEntityTypeReference(customer, false));
model.AddElement(entityFunction);
EdmFunction getOrder = new EdmFunction(
"NS",
"GetOrder",
order.ToEdmTypeReference(false),
isBound: true,
entitySetPathExpression: null,
isComposable: true); // Composable
getOrder.AddParameter("entity", new EdmEntityTypeReference(customer, false));
getOrder.AddParameter("orderId", intType);
model.AddElement(getOrder);
// functions bound to collection
EdmFunction isAllUpgraded = new EdmFunction("NS", "IsAllUpgraded", returnType, isBound: true,
entitySetPathExpression: null, isComposable: false);
isAllUpgraded.AddParameter("entityset",
new EdmCollectionTypeReference(new EdmCollectionType(new EdmEntityTypeReference(customer, false))));
isAllUpgraded.AddParameter("param", intType);
model.AddElement(isAllUpgraded);
EdmFunction isSpecialAllUpgraded = new EdmFunction("NS", "IsSpecialAllUpgraded", returnType, isBound: true,
entitySetPathExpression: null, isComposable: false);
isSpecialAllUpgraded.AddParameter("entityset",
new EdmCollectionTypeReference(new EdmCollectionType(new EdmEntityTypeReference(specialCustomer, false))));
isSpecialAllUpgraded.AddParameter("param", intType);
model.AddElement(isSpecialAllUpgraded);
// navigation properties
EdmNavigationProperty ordersNavProp = customer.AddUnidirectionalNavigation(
new EdmNavigationPropertyInfo
{
Name = "Orders",
TargetMultiplicity = EdmMultiplicity.Many,
Target = order
});
mary.AddNavigationTarget(ordersNavProp, orders);
vipCustomer.AddNavigationTarget(ordersNavProp, orders);
customers.AddNavigationTarget(ordersNavProp, orders);
orders.AddNavigationTarget(
order.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo
{
Name = "Customer",
TargetMultiplicity = EdmMultiplicity.ZeroOrOne,
Target = customer
}),
customers);
// navigation properties on derived types.
EdmNavigationProperty specialOrdersNavProp = specialCustomer.AddUnidirectionalNavigation(
new EdmNavigationPropertyInfo
{
Name = "SpecialOrders",
TargetMultiplicity = EdmMultiplicity.Many,
Target = order
});
vipCustomer.AddNavigationTarget(specialOrdersNavProp, orders);
customers.AddNavigationTarget(specialOrdersNavProp, orders);
orders.AddNavigationTarget(
specialOrder.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo
{
Name = "SpecialCustomer",
TargetMultiplicity = EdmMultiplicity.ZeroOrOne,
Target = customer
}),
customers);
model.SetAnnotationValue <BindableOperationFinder>(model, new BindableOperationFinder(model));
// set properties
Model = model;
Container = container;
Customer = customer;
Order = order;
Address = address;
Account = account;
SpecialCustomer = specialCustomer;
SpecialOrder = specialOrder;
Orders = orders;
Customers = customers;
VipCustomer = vipCustomer;
Mary = mary;
RootOrder = rootOrder;
OrderLine = orderLine;
OrderLines = orderLines;
NonContainedOrderLines = nonContainedOrderLines;
UpgradeCustomer = upgrade;
UpgradeSpecialCustomer = specialUpgrade;
CustomerName = customerName;
IsCustomerUpgraded = isCustomerUpgradedWithParam;
IsSpecialCustomerUpgraded = IsSpecialUpgraded;
Tag = tag;
}
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);
}