internal bool TryGetEntityContainer(EdmEntityContainerItem item, out EdmEntityContainer container)
{
if (item != null)
{
return itemToContainerMap.TryGetValue(item, out container);
}
container = null;
return false;
}
public Task<IEdmModel> GetModelAsync(ModelContext context, CancellationToken cancellationToken)
{
var model = new EdmModel();
var dummyType = new EdmEntityType("NS", "Dummy");
model.AddElement(dummyType);
var container = new EdmEntityContainer("NS", "DefaultContainer");
container.AddEntitySet("Test", dummyType);
model.AddElement(container);
return Task.FromResult((IEdmModel) model);
}
public static EdmEntityContainer EnsureEntityContainer(this EdmModel model, Type apiType)
{
var container = (EdmEntityContainer)model.EntityContainer;
if (container == null)
{
container = new EdmEntityContainer(apiType.Namespace, DefaultEntityContainerName);
model.AddElement(container);
}
return container;
}
protected virtual void VisitEdmEntityContainer(EdmEntityContainer item)
{
VisitEdmNamedMetadataItem(item);
if (item != null)
{
if (item.HasEntitySets)
{
VisitEntitySets(item, item.EntitySets);
}
if (item.HasAssociationSets)
{
VisitAssociationSets(item, item.AssociationSets);
}
}
}
public UriParameterReaderIntegrationTests()
{
model = new EdmModel();
cityT = new EdmComplexType(ns, "City");
cityT.AddStructuralProperty("CityName", EdmPrimitiveTypeKind.String, false);
cityT.AddStructuralProperty("AreaCode", EdmPrimitiveTypeKind.String, true);
model.AddElement(cityT);
addressT = new EdmComplexType(ns, "Address");
addressT.AddStructuralProperty("City", new EdmComplexTypeReference(cityT, true));
model.AddElement(addressT);
companyAddressT = new EdmComplexType(ns, "CompanyAddress", addressT, false);
companyAddressT.AddStructuralProperty("CompanyName", EdmPrimitiveTypeKind.String);
model.AddElement(companyAddressT);
otherInfoT = new EdmComplexType(ns, "OtherInfo", null, false, true);
otherInfoT.AddStructuralProperty("Hight", EdmPrimitiveTypeKind.Int32);
model.AddElement(otherInfoT);
personT = new EdmEntityType("NS", "Person", null, false, true);
var Id = personT.AddStructuralProperty("Id", EdmCoreModel.Instance.GetInt32(false));
personT.AddKeys(Id);
personT.AddStructuralProperty("Address", new EdmComplexTypeReference(addressT, false));
personT.AddStructuralProperty("CompanyAddress", new EdmComplexTypeReference(companyAddressT, true));
billingAddressesT = new EdmCollectionType(new EdmComplexTypeReference(addressT, false));
personT.AddStructuralProperty("BillingAddresses", new EdmCollectionTypeReference(billingAddressesT));
model.AddElement(personT);
EdmEntityContainer container = new EdmEntityContainer(ns, "Container");
peopleSet = new EdmEntitySet(container, "people", personT);
model.AddElement(container);
}
public ODataReaderDerivedTypeConstraintTests()
{
// Create the basic model
edmModel = new EdmModel();
// Entity Type
edmCustomerType = new EdmEntityType("NS", "Customer");
edmCustomerType.AddKeys(edmCustomerType.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32));
edmVipCustomerType = new EdmEntityType("NS", "VipCustomer", edmCustomerType);
edmVipCustomerType.AddStructuralProperty("Vip", EdmPrimitiveTypeKind.String);
edmNormalCustomerType = new EdmEntityType("NS", "NormalCustomer", edmCustomerType);
edmNormalCustomerType.AddStructuralProperty("Email", EdmPrimitiveTypeKind.String);
edmModel.AddElements(new[] { edmCustomerType, edmVipCustomerType, edmNormalCustomerType });
// Complex type
edmAddressType = new EdmComplexType("NS", "Address");
edmAddressType.AddStructuralProperty("Street", EdmPrimitiveTypeKind.String);
edmUsAddressType = new EdmComplexType("NS", "UsAddress", edmAddressType);
edmUsAddressType.AddStructuralProperty("ZipCode", EdmPrimitiveTypeKind.Int32);
edmCnAddressType = new EdmComplexType("NS", "CnAddress", edmAddressType);
edmCnAddressType.AddStructuralProperty("PostCode", EdmPrimitiveTypeKind.String);
edmModel.AddElements(new[] { edmAddressType, edmUsAddressType, edmCnAddressType });
// EntityContainer
EdmEntityContainer container = new EdmEntityContainer("NS", "Default");
edmMe = container.AddSingleton("Me", edmCustomerType);
edmCustomers = container.AddEntitySet("Customers", edmCustomerType);
edmModel.AddElement(container);
}
public void GetTemplatesReturnsCorrectWithTwoSegments()
{
// Arrange
EdmEntityType entityType = new EdmEntityType("NS", "entity");
EdmEntityContainer container = new EdmEntityContainer("NS", "default");
EdmEntitySet entitySet = new EdmEntitySet(container, "set", entityType);
EdmAction action = new EdmAction("NS", "action", null, true, null);
ODataPathTemplate path = new ODataPathTemplate(new EntitySetSegmentTemplate(entitySet),
new ActionSegmentTemplate(action, null));
// Act
IEnumerable <string> templates = path.GetTemplates();
// Act & Assert
Assert.Collection(templates,
e =>
{
Assert.Equal("set/NS.action", e);
},
e =>
{
Assert.Equal("set/action", e);
});
}
public void ReadDateTimeOffsetWithCustomFormat()
{
EdmModel model = new EdmModel();
EdmEntityType entityType = new EdmEntityType("NS", "Person");
model.AddElement(entityType);
entityType.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32);
entityType.AddStructuralProperty("Birthday", EdmPrimitiveTypeKind.DateTimeOffset);
EdmEntityContainer container = new EdmEntityContainer("EntityNs", "MyContainer");
EdmEntitySet entitySet = container.AddEntitySet("People", entityType);
model.AddElement(container);
const string payload =
"{" +
"\"@odata.context\":\"http://www.example.com/$metadata#EntityNs.MyContainer.People/$entity\"," +
"\"@odata.id\":\"http://mytest\"," +
"\"Id\":0," +
"\"Birthday\":\"Thu, 12 Apr 2012 18:43:10 GMT\"" +
"}";
model.SetPayloadValueConverter(new DateTimeOffsetCustomFormatPrimitivePayloadValueConverter());
ODataEntry entry = null;
this.ReadEntryPayload(model, payload, entitySet, entityType, reader => { entry = entry ?? reader.Item as ODataEntry; });
Assert.NotNull(entry);
IList <ODataProperty> propertyList = entry.Properties.ToList();
var birthday = propertyList[1].Value as DateTimeOffset?;
birthday.HasValue.Should().BeTrue();
birthday.Value.Should().Be(new DateTimeOffset(2012, 4, 12, 18, 43, 10, TimeSpan.Zero));
}
public static IEdmModel BuildEdmModel(ODataModelBuilder builder)
{
if (builder == null)
{
throw Error.ArgumentNull("builder");
}
EdmModel model = new EdmModel();
EdmEntityContainer container = new EdmEntityContainer(builder.Namespace, builder.ContainerName);
// add types and sets, building an index on the way.
Dictionary <Type, IEdmType> edmTypeMap = model.AddTypes(builder.StructuralTypes, builder.EnumTypes);
// Add EntitySets and build the mapping between the EdmEntitySet and the NavigationSourceConfiguration
NavigationSourceAndAnnotations[] entitySets = container.AddEntitySetAndAnnotations(builder, edmTypeMap);
// Add Singletons and build the mapping between the EdmSingleton and the NavigationSourceConfiguration
NavigationSourceAndAnnotations[] singletons = container.AddSingletonAndAnnotations(builder, edmTypeMap);
// Merge EntitySets and Singletons together
IEnumerable <NavigationSourceAndAnnotations> navigationSources = entitySets.Concat(singletons);
// Build the navigation source map
IDictionary <string, EdmNavigationSource> navigationSourceMap = model.GetNavigationSourceMap(builder, edmTypeMap, navigationSources);
// add procedures
model.AddProcedures(builder.Procedures, container, edmTypeMap, navigationSourceMap);
// finish up
model.AddElement(container);
// build the map from IEdmEntityType to IEdmFunctionImport
model.SetAnnotationValue <BindableProcedureFinder>(model, new BindableProcedureFinder(model));
return(model);
}
public static IEdmModel SimpleCustomerOrderModel()
{
var model = new EdmModel();
var customerType = new EdmEntityType("Default", "Customer");
customerType.AddStructuralProperty("ID", EdmPrimitiveTypeKind.Int32);
customerType.AddStructuralProperty("FirstName", EdmPrimitiveTypeKind.String);
customerType.AddStructuralProperty("LastName", EdmPrimitiveTypeKind.String);
IEdmTypeReference primitiveTypeReference = EdmCoreModel.Instance.GetPrimitive(
EdmPrimitiveTypeKind.String,
isNullable: true);
customerType.AddStructuralProperty(
"City",
primitiveTypeReference,
defaultValue: null,
concurrencyMode: EdmConcurrencyMode.Fixed);
model.AddElement(customerType);
var specialCustomerType = new EdmEntityType("Default", "SpecialCustomer", customerType);
model.AddElement(specialCustomerType);
var orderType = new EdmEntityType("Default", "Order");
orderType.AddStructuralProperty("ID", EdmPrimitiveTypeKind.Int32);
orderType.AddStructuralProperty("Name", EdmPrimitiveTypeKind.String);
orderType.AddStructuralProperty("Shipment", EdmPrimitiveTypeKind.String);
model.AddElement(orderType);
var specialOrderType = new EdmEntityType("Default", "SpecialOrder", orderType);
model.AddElement(specialOrderType);
var addressType = new EdmComplexType("Default", "Address");
addressType.AddStructuralProperty("Street", EdmPrimitiveTypeKind.String);
addressType.AddStructuralProperty("City", EdmPrimitiveTypeKind.String);
addressType.AddStructuralProperty("State", EdmPrimitiveTypeKind.String);
addressType.AddStructuralProperty("Country", EdmPrimitiveTypeKind.String);
addressType.AddStructuralProperty("ZipCode", EdmPrimitiveTypeKind.String);
model.AddElement(addressType);
// Add navigations
customerType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo()
{
Name = "Orders", Target = orderType, TargetMultiplicity = EdmMultiplicity.Many
});
orderType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo()
{
Name = "Customer", Target = customerType, TargetMultiplicity = EdmMultiplicity.One
});
specialCustomerType.AddUnidirectionalNavigation(
new EdmNavigationPropertyInfo
{
Name = "SpecialOrders",
Target = specialOrderType,
TargetMultiplicity = EdmMultiplicity.Many
});
orderType.AddUnidirectionalNavigation(
new EdmNavigationPropertyInfo
{
Name = "SpecialCustomer",
Target = specialCustomerType,
TargetMultiplicity = EdmMultiplicity.One
});
// Add Entity set
var container = new EdmEntityContainer("Default", "Container");
var customerSet = container.AddEntitySet("Customers", customerType);
var orderSet = container.AddEntitySet("Orders", orderType);
customerSet.AddNavigationTarget(customerType.NavigationProperties().Single(np => np.Name == "Orders"), orderSet);
customerSet.AddNavigationTarget(
specialCustomerType.NavigationProperties().Single(np => np.Name == "SpecialOrders"),
orderSet);
orderSet.AddNavigationTarget(orderType.NavigationProperties().Single(np => np.Name == "Customer"), customerSet);
orderSet.AddNavigationTarget(
specialOrderType.NavigationProperties().Single(np => np.Name == "SpecialCustomer"),
customerSet);
NavigationSourceLinkBuilderAnnotation linkAnnotation = new MockNavigationSourceLinkBuilderAnnotation();
model.SetNavigationSourceLinkBuilder(customerSet, linkAnnotation);
model.SetNavigationSourceLinkBuilder(orderSet, linkAnnotation);
model.AddElement(container);
return(model);
}
private IEdmModel CreateEdmModel()
{
var model = new EdmModel();
EdmComplexType simpleComplexType = new EdmComplexType(DefaultNamespaceName, "SimplexComplexType");
simpleComplexType.AddProperty(new EdmStructuralProperty(simpleComplexType, "Name", StringTypeRef));
model.AddElement(simpleComplexType);
EdmComplexType simpleComplexType2 = new EdmComplexType(DefaultNamespaceName, "SimplexComplexType2");
simpleComplexType2.AddProperty(new EdmStructuralProperty(simpleComplexType2, "Value", Int32NullableTypeRef));
model.AddElement(simpleComplexType2);
EdmComplexType nestedComplexType = new EdmComplexType(DefaultNamespaceName, "NestedComplexType");
nestedComplexType.AddProperty(new EdmStructuralProperty(nestedComplexType, "InnerComplexProperty", new EdmComplexTypeReference(simpleComplexType2, isNullable: false)));
model.AddElement(nestedComplexType);
EdmComplexType ratingComplexType = new EdmComplexType(DefaultNamespaceName, "RatingComplexType");
ratingComplexType.AddProperty(new EdmStructuralProperty(ratingComplexType, "Rating", Int32NullableTypeRef));
model.AddElement(ratingComplexType);
EdmEntityType entityType = new EdmEntityType(DefaultNamespaceName, "EntityType");
EdmEntityType expandedEntryType = new EdmEntityType(DefaultNamespaceName, "ExpandedEntryType");
expandedEntryType.AddKeys(expandedEntryType.AddStructuralProperty("Id", Int32TypeRef));
expandedEntryType.AddStructuralProperty("ExpandedEntryName", StringTypeRef);
expandedEntryType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo {
Name = "ExpandedEntry_DeferredNavigation", Target = entityType, TargetMultiplicity = EdmMultiplicity.One
});
expandedEntryType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo {
Name = "ExpandedEntry_ExpandedFeed", Target = entityType, TargetMultiplicity = EdmMultiplicity.Many
});
model.AddElement(expandedEntryType);
entityType.AddKeys(entityType.AddStructuralProperty("Id", Int32TypeRef));
entityType.AddStructuralProperty("StringProperty", StringTypeRef);
entityType.AddStructuralProperty("NumberProperty", Int32TypeRef);
entityType.AddStructuralProperty("SimpleComplexProperty", new EdmComplexTypeReference(simpleComplexType, isNullable: false));
entityType.AddStructuralProperty("DeepComplexProperty", new EdmComplexTypeReference(nestedComplexType, isNullable: false));
entityType.AddStructuralProperty("PrimitiveCollection", EdmCoreModel.GetCollection(StringTypeRef));
entityType.AddStructuralProperty("ComplexCollection", EdmCoreModel.GetCollection(new EdmComplexTypeReference(ratingComplexType, isNullable: false)));
entityType.AddStructuralProperty("NamedStream", EdmPrimitiveTypeKind.Stream, false);
entityType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo {
Name = "DeferredNavigation", Target = entityType, TargetMultiplicity = EdmMultiplicity.One
});
entityType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo {
Name = "AssociationLink", Target = entityType, TargetMultiplicity = EdmMultiplicity.One
});
entityType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo {
Name = "ExpandedEntry", Target = expandedEntryType, TargetMultiplicity = EdmMultiplicity.One
});
entityType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo {
Name = "ExpandedFeed", Target = entityType, TargetMultiplicity = EdmMultiplicity.Many
});
model.AddElement(entityType);
EdmEntityType wrappingEntityType = new EdmEntityType(DefaultNamespaceName, "WrappingEntityType");
wrappingEntityType.AddKeys(wrappingEntityType.AddStructuralProperty("Wrapping_ID", Int32TypeRef));
wrappingEntityType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo {
Name = "Wrapping_ExpandedEntry", Target = entityType, TargetMultiplicity = EdmMultiplicity.One
});
model.AddElement(wrappingEntityType);
var container = new EdmEntityContainer(DefaultNamespaceName, "DefaultContainer");
model.AddElement(container);
container.AddEntitySet("EntitySet", entityType);
container.AddEntitySet("WrappingEntitySet", wrappingEntityType);
return(model);
}
public SelectedPropertiesNodeTests()
{
this.edmModel = new EdmModel();
this.defaultContainer = new EdmEntityContainer("TestModel", "DefaultContainer");
this.edmModel.AddElement(this.defaultContainer);
this.townType = new EdmEntityType("TestModel", "Town");
this.edmModel.AddElement(townType);
EdmStructuralProperty townIdProperty = townType.AddStructuralProperty("Id", EdmCoreModel.Instance.GetInt32(/*isNullable*/ false));
townType.AddKeys(townIdProperty);
townType.AddStructuralProperty("Name", EdmCoreModel.Instance.GetString(/*isNullable*/ false));
townType.AddStructuralProperty("Size", EdmCoreModel.Instance.GetInt32(/*isNullable*/ false));
this.cityType = new EdmEntityType("TestModel", "City", this.townType);
cityType.AddStructuralProperty("Photo", EdmCoreModel.Instance.GetStream(/*isNullable*/ false));
this.edmModel.AddElement(cityType);
this.districtType = new EdmEntityType("TestModel", "District");
EdmStructuralProperty districtIdProperty = districtType.AddStructuralProperty("Id", EdmCoreModel.Instance.GetInt32(/*isNullable*/ false));
districtType.AddKeys(districtIdProperty);
districtType.AddStructuralProperty("Zip", EdmCoreModel.Instance.GetInt32(/*isNullable*/ false));
districtType.AddStructuralProperty("Thumbnail", EdmCoreModel.Instance.GetStream(/*isNullable*/ false));
this.edmModel.AddElement(districtType);
cityType.AddBidirectionalNavigation(
new EdmNavigationPropertyInfo {
Name = "Districts", Target = districtType, TargetMultiplicity = EdmMultiplicity.Many
},
new EdmNavigationPropertyInfo {
Name = "City", Target = cityType, TargetMultiplicity = EdmMultiplicity.One
});
this.defaultContainer.AddEntitySet("Cities", cityType);
this.defaultContainer.AddEntitySet("Districts", districtType);
EdmComplexType airportType = new EdmComplexType("TestModel", "Airport");
airportType.AddStructuralProperty("Name", EdmCoreModel.Instance.GetString(/*isNullable*/ false));
airportType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo {
Name = "City", Target = cityType, TargetMultiplicity = EdmMultiplicity.ZeroOrOne
});
this.edmModel.AddElement(airportType);
EdmComplexType regionalAirportType = new EdmComplexType("TestModel", "RegionalAirport", airportType);
airportType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo {
Name = "Region", Target = districtType, TargetMultiplicity = EdmMultiplicity.ZeroOrOne
});
this.edmModel.AddElement(regionalAirportType);
this.metropolisType = new EdmEntityType("TestModel", "Metropolis", this.cityType);
this.metropolisType.AddStructuralProperty("MetropolisStream", EdmCoreModel.Instance.GetStream(/*isNullable*/ false));
this.metropolisType.AddStructuralProperty("NearestAirport", new EdmComplexTypeReference(airportType, false));
this.edmModel.AddElement(metropolisType);
metropolisType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo {
Name = "MetropolisNavigation", Target = districtType, TargetMultiplicity = EdmMultiplicity.ZeroOrOne
});
this.action = new EdmAction("TestModel", "Action", new EdmEntityTypeReference(this.cityType, true));
this.action.AddParameter("Param", EdmCoreModel.Instance.GetInt32(false));
this.edmModel.AddElement(action);
this.actionImport = new EdmActionImport(this.defaultContainer, "Action", action);
this.actionConflictingWithPropertyName = new EdmAction("TestModel", "Zip", new EdmEntityTypeReference(this.districtType, true));
this.actionConflictingWithPropertyName.AddParameter("Param", EdmCoreModel.Instance.GetInt32(false));
this.edmModel.AddElement(actionConflictingWithPropertyName);
this.actionImportConflictingWithPropertyName = new EdmActionImport(this.defaultContainer, "Zip", actionConflictingWithPropertyName);
this.openType = new EdmEntityType("TestModel", "OpenCity", this.cityType, false, true);
}
internal void WriteEntityContainerElementHeader(EdmEntityContainer container)
{
_xmlWriter.WriteStartElement(CsdlConstants.Element_EntityContainer);
_xmlWriter.WriteAttributeString(CsdlConstants.Attribute_Name, container.Name);
}
private IEdmModel GetModel()
{
if (myModel == null)
{
myModel = new EdmModel();
EdmComplexType shippingAddress = new EdmComplexType("MyNS", "ShippingAddress");
shippingAddress.AddStructuralProperty("Street", EdmPrimitiveTypeKind.String);
shippingAddress.AddStructuralProperty("City", EdmPrimitiveTypeKind.String);
shippingAddress.AddStructuralProperty("Region", EdmPrimitiveTypeKind.String);
shippingAddress.AddStructuralProperty("PostalCode", EdmPrimitiveTypeKind.String);
myModel.AddElement(shippingAddress);
EdmComplexTypeReference shippingAddressReference = new EdmComplexTypeReference(shippingAddress, true);
EdmEntityType orderType = new EdmEntityType("MyNS", "Order");
orderType.AddKeys(orderType.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32));
orderType.AddStructuralProperty("ShippingAddress", shippingAddressReference);
myModel.AddElement(orderType);
EdmEntityType customer = new EdmEntityType("MyNS", "Customer");
customer.AddStructuralProperty("ContactName", EdmPrimitiveTypeKind.String);
var customerId = customer.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32);
customer.AddKeys(customerId);
customer.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo
{
Name = "Orders",
Target = orderType,
TargetMultiplicity = EdmMultiplicity.Many,
});
myModel.AddElement(customer);
var productType = new EdmEntityType("MyNS", "Product");
var productId = productType.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32);
productType.AddStructuralProperty("Name", EdmPrimitiveTypeKind.String);
productType.AddKeys(productId);
myModel.AddElement(productType);
var physicalProductType = new EdmEntityType("MyNS", "PhysicalProduct", productType);
physicalProductType.AddStructuralProperty("Material", EdmPrimitiveTypeKind.String);
myModel.AddElement(physicalProductType);
var productDetailType = new EdmEntityType("MyNS", "ProductDetail");
var productDetailId = productDetailType.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32);
productDetailType.AddStructuralProperty("Detail", EdmPrimitiveTypeKind.String);
productDetailType.AddKeys(productDetailId);
myModel.AddElement(productDetailType);
var productDetailItemType = new EdmEntityType("MyNS", "ProductDetailItem");
var productDetailItemId = productDetailItemType.AddStructuralProperty("ItemId", EdmPrimitiveTypeKind.Int32);
productDetailItemType.AddStructuralProperty("Description", EdmPrimitiveTypeKind.String);
productDetailItemType.AddKeys(productDetailItemId);
myModel.AddElement(productDetailItemType);
productType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo
{
Name = "Details",
Target = productDetailType,
TargetMultiplicity = EdmMultiplicity.Many,
ContainsTarget = true,
});
productDetailType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo
{
Name = "Items",
Target = productDetailItemType,
TargetMultiplicity = EdmMultiplicity.Many,
ContainsTarget = true,
});
var favouriteProducts = customer.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo
{
Name = "FavouriteProducts",
Target = productType,
TargetMultiplicity = EdmMultiplicity.Many,
});
var productBeingViewed = customer.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo
{
Name = "ProductBeingViewed",
Target = productType,
TargetMultiplicity = EdmMultiplicity.ZeroOrOne,
});
EdmEntityContainer container = new EdmEntityContainer("MyNS", "Example30");
var products = container.AddEntitySet("Products", productType);
var customers = container.AddEntitySet("Customers", customer);
customers.AddNavigationTarget(favouriteProducts, products);
customers.AddNavigationTarget(productBeingViewed, products);
container.AddEntitySet("Orders", orderType);
myModel.AddElement(container);
}
return(myModel);
}
/// <summary>
/// Creates a new action import with the specified name.
/// </summary>
/// <param name="container">The <see cref="EntityContainer"/> to create the action import in.</param>
/// <param name="localName">The name for the action import to create.</param>
/// <returns>The newly created action import instance.</returns>
public static EdmActionImport ActionImport(this EdmEntityContainer container, IEdmAction action)
{
ExceptionUtilities.CheckArgumentNotNull(container, "container");
return(container.AddActionImport(action));
}
/// <summary>
/// Creates a set of models.
/// </summary>
/// <returns>List of interesting models.</returns>
public static IEnumerable <IEdmModel> CreateModels()
{
//
// NOTE: we only create a few models here since we mostly rely on EdmLib to test
// model serialization/deserialization for us
//
// Empty model
EdmModel emptyModel = new EdmModel();
emptyModel.AddElement(new EdmEntityContainer("DefaultNamespace", "DefaultContainer"));
yield return(emptyModel.Fixup());
// Model with a single entity type
EdmModel modelWithSingleEntityType = new EdmModel();
var singletonEntityType = new EdmEntityType(DefaultNamespaceName, "SingletonEntityType");
singletonEntityType.AddKeys(singletonEntityType.AddStructuralProperty("Id", Int32TypeRef));
singletonEntityType.AddStructuralProperty("Name", StringNullableTypeRef);
modelWithSingleEntityType.AddElement(singletonEntityType);
modelWithSingleEntityType.Fixup();
yield return(modelWithSingleEntityType);
// Model with a single complex type
EdmModel modelWithSingleComplexType = new EdmModel();
var singletonComplexType = new EdmComplexType(DefaultNamespaceName, "SingletonComplexType");
singletonComplexType.AddStructuralProperty("City", StringNullableTypeRef);
modelWithSingleComplexType.AddElement(singletonComplexType);
modelWithSingleComplexType.Fixup();
yield return(modelWithSingleComplexType);
// Model with a collection property
EdmModel modelWithCollectionProperty = new EdmModel();
var complexTypeWithCollection = new EdmComplexType(DefaultNamespaceName, "ComplexTypeWithCollection");
complexTypeWithCollection.AddStructuralProperty("Cities", EdmCoreModel.GetCollection(StringNullableTypeRef));
modelWithCollectionProperty.AddElement(complexTypeWithCollection);
modelWithCollectionProperty.Fixup();
yield return(modelWithCollectionProperty);
// Model with an open type
EdmModel modelWithOpenType = new EdmModel();
var openType = new EdmEntityType(DefaultNamespaceName, "OpenEntityType", baseType: null, isAbstract: false, isOpen: true);
openType.AddKeys(openType.AddStructuralProperty("Id", Int32TypeRef));
modelWithOpenType.AddElement(openType);
var containerForModelWithOpenType = new EdmEntityContainer(DefaultNamespaceName, "DefaultContainer");
containerForModelWithOpenType.AddEntitySet("OpenEntityType", openType);
modelWithOpenType.AddElement(containerForModelWithOpenType);
yield return(modelWithOpenType);
// Model with a named stream
EdmModel modelWithNamedStream = new EdmModel();
var namedStreamEntityType = new EdmEntityType(DefaultNamespaceName, "NamedStreamEntityType");
namedStreamEntityType.AddKeys(namedStreamEntityType.AddStructuralProperty("Id", Int32TypeRef));
namedStreamEntityType.AddStructuralProperty("NamedStream", EdmPrimitiveTypeKind.Stream, isNullable: false);
modelWithNamedStream.AddElement(namedStreamEntityType);
var containerForModelWithNamedStream = new EdmEntityContainer(DefaultNamespaceName, "DefaultContainer");
containerForModelWithNamedStream.AddEntitySet("NamedStreamEntityType", namedStreamEntityType);
modelWithNamedStream.AddElement(containerForModelWithNamedStream);
yield return(modelWithNamedStream);
// OData Shared Test Model
yield return(BuildTestModel());
// Model with OData-specific attribute annotations
yield return(BuildODataAnnotationTestModel(true));
#if !NETCOREAPP1_0
// Astoria Default Test Model
yield return(BuildDefaultAstoriaTestModel());
#endif
}
/// <summary>
/// Build a test model shared across several tests.
/// </summary>
/// <returns>Returns the test model.</returns>
public static EdmModel BuildTestModel()
{
// The metadata model
var model = new EdmModel();
var addressType = new EdmComplexType(DefaultNamespaceName, "Address");
addressType.AddStructuralProperty("Street", StringNullableTypeRef);
addressType.AddStructuralProperty("Zip", Int32TypeRef);
addressType.AddStructuralProperty("SubAddress", new EdmComplexTypeReference(addressType, isNullable: false));
model.AddElement(addressType);
var officeType = new EdmEntityType(DefaultNamespaceName, "OfficeType");
officeType.AddKeys(officeType.AddStructuralProperty("Id", Int32TypeRef));
officeType.AddStructuralProperty("Address", new EdmComplexTypeReference(addressType, isNullable: false));
model.AddElement(officeType);
var officeWithNumberType = new EdmEntityType(DefaultNamespaceName, "OfficeWithNumberType", officeType);
officeWithNumberType.AddStructuralProperty("Number", Int32TypeRef);
model.AddElement(officeWithNumberType);
var cityType = new EdmEntityType(DefaultNamespaceName, "CityType");
cityType.AddKeys(cityType.AddStructuralProperty("Id", Int32TypeRef));
cityType.AddStructuralProperty("Name", StringNullableTypeRef);
cityType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo {
Name = "CityHall", Target = officeType, TargetMultiplicity = EdmMultiplicity.Many
});
cityType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo {
Name = "DOL", Target = officeType, TargetMultiplicity = EdmMultiplicity.Many
});
cityType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo {
Name = "PoliceStation", Target = officeType, TargetMultiplicity = EdmMultiplicity.One
});
cityType.AddStructuralProperty("Skyline", EdmPrimitiveTypeKind.Stream, isNullable: false);
cityType.AddStructuralProperty("MetroLanes", EdmCoreModel.GetCollection(StringNullableTypeRef));
model.AddElement(cityType);
var metropolitanCityType = new EdmEntityType(DefaultNamespaceName, "MetropolitanCityType", cityType);
metropolitanCityType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo {
Name = "ContainedOffice", Target = officeType, TargetMultiplicity = EdmMultiplicity.Many, ContainsTarget = true
});
officeType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo {
Name = "ContainedCity", Target = metropolitanCityType, TargetMultiplicity = EdmMultiplicity.One, ContainsTarget = true
});
model.AddElement(metropolitanCityType);
var cityWithMapType = new EdmEntityType(DefaultNamespaceName, "CityWithMapType", cityType, false, false, true);
model.AddElement(cityWithMapType);
var cityOpenType = new EdmEntityType(DefaultNamespaceName, "CityOpenType", cityType, isAbstract: false, isOpen: true);
model.AddElement(cityOpenType);
var personType = new EdmEntityType(DefaultNamespaceName, "Person");
personType.AddKeys(personType.AddStructuralProperty("Id", Int32TypeRef));
personType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo {
Name = "Friend", Target = personType, TargetMultiplicity = EdmMultiplicity.Many
});
model.AddElement(personType);
var employeeType = new EdmEntityType(DefaultNamespaceName, "Employee", personType);
employeeType.AddStructuralProperty("CompanyName", StringNullableTypeRef);
model.AddElement(employeeType);
var managerType = new EdmEntityType(DefaultNamespaceName, "Manager", employeeType);
managerType.AddStructuralProperty("Level", Int32TypeRef);
model.AddElement(managerType);
var container = new EdmEntityContainer(DefaultNamespaceName, "DefaultContainer");
model.AddElement(container);
container.AddEntitySet("Offices", officeType);
container.AddEntitySet("Cities", cityType);
container.AddEntitySet("MetropolitanCities", metropolitanCityType);
container.AddEntitySet("Persons", personType);
container.AddEntitySet("Employee", employeeType);
container.AddEntitySet("Manager", managerType);
container.AddSingleton("Boss", personType);
// Fixup will set DefaultContainer\TopLevelEntitySet\AssociationSet
model.Fixup();
// NOTE: Function import parameters and return types must be nullable as per current CSDL spec
var serviceOp = container.AddFunctionAndFunctionImport(model, "ServiceOperation1", Int32NullableTypeRef, null, false /*isComposable*/, false /*isBound*/);
serviceOp.Function.AsEdmFunction().AddParameter("a", Int32NullableTypeRef);
serviceOp.Function.AsEdmFunction().AddParameter("b", StringNullableTypeRef);
container.AddFunctionAndFunctionImport(model, "PrimitiveResultOperation", Int32NullableTypeRef, null, false /*isComposable*/, false /*isBound*/);
container.AddFunctionAndFunctionImport(model, "ComplexResultOperation", new EdmComplexTypeReference(addressType, isNullable: true), null, false /*isComposable*/, false /*isBound*/);
container.AddFunctionAndFunctionImport(model, "PrimitiveCollectionResultOperation", EdmCoreModel.GetCollection(Int32NullableTypeRef), null, false /*isComposable*/, false /*isBound*/);
container.AddFunctionAndFunctionImport(model, "ComplexCollectionResultOperation", EdmCoreModel.GetCollection(new EdmComplexTypeReference(addressType, isNullable: true)), null, false /*isComposable*/, false /*isBound*/);
// Overload with 0 Param
container.AddFunctionAndFunctionImport(model, "FunctionImportWithOverload", Int32NullableTypeRef, null, false /*isComposable*/, false /*isBound*/);
// Overload with 1 Param
var overloadWithOneParam = container.AddFunctionAndFunctionImport(model, "FunctionImportWithOverload", Int32NullableTypeRef, null, false /*isComposable*/, false /*isBound*/);
overloadWithOneParam.Function.AsEdmFunction().AddParameter("p1", new EdmEntityTypeReference(cityWithMapType, isNullable: true));
// Overload with 2 Params
var overloadWithTwoParams = container.AddFunctionAndFunctionImport(model, "FunctionImportWithOverload", Int32NullableTypeRef, null, false /*isComposable*/, false /*isBound*/);
overloadWithTwoParams.Function.AsEdmFunction().AddParameter("p1", new EdmEntityTypeReference(cityType, isNullable: true));
overloadWithTwoParams.Function.AsEdmFunction().AddParameter("p2", StringNullableTypeRef);
// Overload with 5 Params
var overloadWithFiveParams = container.AddFunctionAndFunctionImport(model, "FunctionImportWithOverload", Int32NullableTypeRef, null, false /*isComposable*/, false /*isBound*/);
overloadWithFiveParams.Function.AsEdmFunction().AddParameter("p1", EdmCoreModel.GetCollection(new EdmEntityTypeReference(cityType, isNullable: true)));
overloadWithFiveParams.Function.AsEdmFunction().AddParameter("p2", EdmCoreModel.GetCollection(StringNullableTypeRef));
overloadWithFiveParams.Function.AsEdmFunction().AddParameter("p3", StringNullableTypeRef);
overloadWithFiveParams.Function.AsEdmFunction().AddParameter("p4", new EdmComplexTypeReference(addressType, isNullable: true));
overloadWithFiveParams.Function.AsEdmFunction().AddParameter("p5", EdmCoreModel.GetCollection(new EdmComplexTypeReference(addressType, isNullable: true)));
return(model);
}
private IEdmModel GetModel()
{
if (_model != null)
{
return(_model);
}
var model = new EdmModel();
// EntityContainer: Service
var container = new EdmEntityContainer("ns", "Service");
model.AddElement(container);
// EntityType: Address
var address = new EdmEntityType("ns", "Address");
var addressId = address.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32);
address.AddKeys(addressId);
model.AddElement(address);
// EntitySet: Addresses
var addresses = container.AddEntitySet("Addresses", address);
// EntityType: PaymentInstrument
var paymentInstrument = new EdmEntityType("ns", "PaymentInstrument");
var paymentInstrumentId = paymentInstrument.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32);
paymentInstrument.AddKeys(paymentInstrumentId);
var billingAddresses = paymentInstrument.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo
{
Name = "BillingAddresses",
Target = address,
TargetMultiplicity = EdmMultiplicity.Many
});
paymentInstrument.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo
{
Name = "ContainedBillingAddresses",
Target = address,
TargetMultiplicity = EdmMultiplicity.Many,
ContainsTarget = true
});
model.AddElement(paymentInstrument);
// EntityType: Account
var account = new EdmEntityType("ns", "Account");
var accountId = account.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32);
account.AddKeys(accountId);
var myPaymentInstruments = account.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo
{
Name = "MyPaymentInstruments",
Target = paymentInstrument,
TargetMultiplicity = EdmMultiplicity.Many,
ContainsTarget = true
});
model.AddElement(account);
// EntitySet: Accounts
var accounts = container.AddEntitySet("Accounts", account);
var paymentInstruments = accounts.FindNavigationTarget(myPaymentInstruments) as EdmNavigationSource;
Assert.NotNull(paymentInstruments);
paymentInstruments.AddNavigationTarget(billingAddresses, addresses);
// EntityType: Person
var person = new EdmEntityType("ns", "Person");
var personId = person.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32);
person.AddKeys(personId);
var myAccounts = person.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo
{
Name = "MyAccounts",
Target = account,
TargetMultiplicity = EdmMultiplicity.Many
});
var myPermanentAccount = person.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo
{
Name = "MyPermanentAccount",
Target = account,
TargetMultiplicity = EdmMultiplicity.One
});
var myLatestAccount = person.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo
{
Name = "MyLatestAccount",
Target = account,
TargetMultiplicity = EdmMultiplicity.One
});
person.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo
{
Name = "MyAddresses",
Target = address,
TargetMultiplicity = EdmMultiplicity.Many,
ContainsTarget = true
});
model.AddElement(person);
// EntityType: Benefit
var benefit = new EdmEntityType("ns", "Benefit");
var benefitId = benefit.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32);
benefit.AddKeys(benefitId);
model.AddElement(benefit);
// EntityType: SpecialPerson
var specialPerson = new EdmEntityType("ns", "SpecialPerson", person);
specialPerson.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo
{
Name = "Benefits",
Target = benefit,
TargetMultiplicity = EdmMultiplicity.Many,
ContainsTarget = true
});
model.AddElement(specialPerson);
// EntityType: VIP
var vip = new EdmEntityType("ns", "VIP", specialPerson);
vip.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo
{
Name = "MyBenefits",
Target = benefit,
TargetMultiplicity = EdmMultiplicity.Many,
ContainsTarget = true
});
model.AddElement(vip);
// EntitySet: People
var people = container.AddEntitySet("People", person);
people.AddNavigationTarget(myAccounts, accounts);
people.AddNavigationTarget(myLatestAccount, accounts);
// EntityType: Club
var club = new EdmEntityType("ns", "Club");
var clubId = club.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32);
club.AddKeys(clubId);
var members = club.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo
{
Name = "Members",
Target = person,
TargetMultiplicity = EdmMultiplicity.Many,
ContainsTarget = true
});
// EntityType: SeniorClub
var seniorClub = new EdmEntityType("ns", "SeniorClub", club);
model.AddElement(seniorClub);
// EntitySet: Clubs
var clubs = container.AddEntitySet("Clubs", club);
var membersInClub = clubs.FindNavigationTarget(members) as EdmNavigationSource;
membersInClub.AddNavigationTarget(myAccounts, accounts);
// Singleton: PermanentAccount
var permanentAccount = container.AddSingleton("PermanentAccount", account);
people.AddNavigationTarget(myPermanentAccount, permanentAccount);
_model = model;
return(_model);
}
public Task<IEdmModel> GetModelAsync(ModelContext context, CancellationToken cancellationToken)
{
var model = new EdmModel();
var entityType = new EdmEntityType(
"TestNamespace", "TestName");
var entityContainer = new EdmEntityContainer(
"TestNamespace", "Entities");
entityContainer.AddEntitySet("TestEntitySet", entityType);
model.AddElement(entityType);
model.AddElement(entityContainer);
return Task.FromResult<IEdmModel>(model);
}
protected virtual void VisitAssociationSets(
EdmEntityContainer container, IEnumerable<EdmAssociationSet> associationSets)
{
VisitCollection(associationSets, VisitEdmAssociationSet);
}
protected virtual void VisitEntitySets(EdmEntityContainer container, IEnumerable<EdmEntitySet> entitySets)
{
VisitCollection(entitySets, VisitEdmEntitySet);
}
public void InStreamErrorInEntriesTest()
{
EdmModel edmModel = new EdmModel();
EdmEntityContainer defaultContainer = new EdmEntityContainer("TestModel", "DefaultContainer");
edmModel.AddElement(defaultContainer);
var dummyType = new EdmEntityType("TestModel", "DummyEntryType");
dummyType.AddKeys(dummyType.AddStructuralProperty("Id", EdmCoreModel.Instance.GetInt32(/*isNullable*/ false)));
edmModel.AddElement(dummyType);
var dummySet = defaultContainer.AddEntitySet("DummySet", dummyType);
var errorCases = new []
{
new
{
Json = "{{ \"{0}\": {{ \"code\": \"my-error-code\" }} }}",
ExpectedException = ODataExpectedExceptions.ODataErrorException(new ODataError {
ErrorCode = "my-error-code"
})
},
new
{
Json = "{{ \"{0}\": {{ \"message\": \"my-error-message\" }} }}",
ExpectedException = ODataExpectedExceptions.ODataErrorException(new ODataError {
Message = "my-error-message"
})
},
new
{
Json = "{{ \"{0}\": {{ \"code\": \"my-error-code\", \"message\": \"my-error-message\" }} }}",
ExpectedException = ODataExpectedExceptions.ODataErrorException(new ODataError {
ErrorCode = "my-error-code", Message = "my-error-message"
})
},
new
{
Json = "{{ \"{0}\": {{ \"code\": \"my-error-code\", \"innererror\": {{ \"message\": \"my-inner-error\" }} }} }}",
ExpectedException = ODataExpectedExceptions.ODataErrorException(new ODataError {
ErrorCode = "my-error-code", InnerError = new ODataInnerError {
Message = "my-inner-error"
}
})
},
new
{
Json = "{{ \"{0}\": {{ \"innererror\": {{ \"message\": \"my-inner-error\" }} }} }}",
ExpectedException = ODataExpectedExceptions.ODataErrorException(new ODataError {
InnerError = new ODataInnerError {
Message = "my-inner-error"
}
})
},
new
{
Json = "{{ \"{0}\": {{ \"message\": \"my-error-message\", \"innererror\": {{ \"message\": \"my-inner-error\" }} }} }}",
ExpectedException = ODataExpectedExceptions.ODataErrorException(new ODataError {
Message = "my-error-message", InnerError = new ODataInnerError {
Message = "my-inner-error"
}
})
},
new
{
Json = "{{ \"{0}\": {{ \"code\": \"my-error-code\", \"message\": \"my-error-message\", \"innererror\": {{ \"message\": \"my-inner-error\" }} }} }}",
ExpectedException = ODataExpectedExceptions.ODataErrorException(new ODataError {
ErrorCode = "my-error-code", Message = "my-error-message", InnerError = new ODataInnerError {
Message = "my-inner-error"
}
})
},
};
this.CombinatorialEngineProvider.RunCombinations(
errorCases,
this.ReaderTestConfigurationProvider.JsonLightFormatConfigurations,
(errorCase, testConfiguration) =>
{
string errorElementName = JsonLightConstants.ODataErrorPropertyName;
var testCase = new JsonPayloadErrorTestCase
{
Json = PayloadBuilder.Entity("TestModel.DummyEntryType")
.JsonRepresentation(string.Format(errorCase.Json, errorElementName))
.ExpectedEntityType(dummyType, dummySet),
EdmModel = edmModel,
ExpectedExceptionFunc = (tCase, tConfig) => errorCase.ExpectedException,
};
var descriptor = testCase.ToEdmPayloadReaderTestDescriptor(this.PayloadTestDescriptorSettings, this.PayloadExpectedResultSettings);
// NOTE: payload generation is not supported for JSON Light yet
var descriptors = testConfiguration.Format == ODataFormat.Json
? new PayloadReaderTestDescriptor[] { descriptor }
: this.PayloadGenerator.GenerateReaderPayloads(descriptor);
this.CombinatorialEngineProvider.RunCombinations(
descriptors,
testDescriptor => testDescriptor.RunTest(testConfiguration));
});
}
public void ContainedUnderComplexTest()
{
var model = new EdmModel();
var entity = new EdmEntityType("NS", "EntityType");
var entityId = entity.AddStructuralProperty("ID", EdmCoreModel.Instance.GetString(false));
entity.AddKeys(entityId);
var containedEntity = new EdmEntityType("NS", "ContainedEntityType");
var containedEntityId = containedEntity.AddStructuralProperty("ID", EdmCoreModel.Instance.GetString(false));
containedEntity.AddKeys(containedEntityId);
var complex = new EdmComplexType("NS", "ComplexType");
complex.AddStructuralProperty("Prop1", EdmCoreModel.Instance.GetInt32(false));
var containedUnderComplex = complex.AddUnidirectionalNavigation(
new EdmNavigationPropertyInfo()
{
Name = "ContainedUnderComplex",
Target = containedEntity,
TargetMultiplicity = EdmMultiplicity.Many,
ContainsTarget = true
});
var navUnderContained = containedEntity.AddUnidirectionalNavigation(
new EdmNavigationPropertyInfo()
{
Name = "NavUnderContained",
Target = entity,
TargetMultiplicity = EdmMultiplicity.Many
});
entity.AddStructuralProperty("Complex", new EdmComplexTypeReference(complex, false));
model.AddElement(entity);
model.AddElement(containedEntity);
model.AddElement(complex);
var entityContainer = new EdmEntityContainer("NS", "Container");
model.AddElement(entityContainer);
EdmEntitySet entites1 = new EdmEntitySet(entityContainer, "Entities1", entity);
EdmEntitySet entites2 = new EdmEntitySet(entityContainer, "Entities2", entity);
entites1.AddNavigationTarget(navUnderContained, entites2,
new EdmPathExpression("Complex/ContainedUnderComplex/NavUnderContained"));
entityContainer.AddElement(entites1);
entityContainer.AddElement(entites2);
string actual = GetCsdl(model, CsdlTarget.OData);
var entitySet1 = model.EntityContainer.FindEntitySet("Entities1");
var entitySet2 = model.EntityContainer.FindEntitySet("Entities2");
var containedEntitySet = entitySet1.FindNavigationTarget(containedUnderComplex);
Assert.Equal(containedEntitySet.Name, "ContainedUnderComplex");
var entitySetUnderContained = containedEntitySet.FindNavigationTarget(navUnderContained,
new EdmPathExpression("Complex/ContainedUnderComplex/NavUnderContained"));
Assert.Equal(entitySetUnderContained, entitySet2);
}
private static IEdmModel GetUnTypedEdmModel()
{
EdmModel model = new EdmModel();
// Enum type "Color"
EdmEnumType colorEnum = new EdmEnumType("NS", "Color");
colorEnum.AddMember(new EdmEnumMember(colorEnum, "Red", new EdmEnumMemberValue(0)));
colorEnum.AddMember(new EdmEnumMember(colorEnum, "Blue", new EdmEnumMemberValue(1)));
colorEnum.AddMember(new EdmEnumMember(colorEnum, "Green", new EdmEnumMemberValue(2)));
model.AddElement(colorEnum);
// complex type "Address"
EdmComplexType address = new EdmComplexType("NS", "Address");
address.AddStructuralProperty("Street", EdmPrimitiveTypeKind.String);
address.AddStructuralProperty("City", EdmPrimitiveTypeKind.String);
model.AddElement(address);
// derived complex type "SubAddress"
EdmComplexType subAddress = new EdmComplexType("NS", "SubAddress", address);
subAddress.AddStructuralProperty("Code", EdmPrimitiveTypeKind.Double);
model.AddElement(subAddress);
// entity type "Customer"
EdmEntityType customer = new EdmEntityType("NS", "Customer");
customer.AddKeys(customer.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32));
customer.AddStructuralProperty("Name", EdmPrimitiveTypeKind.String);
customer.AddStructuralProperty("Location", new EdmComplexTypeReference(address, isNullable: true));
model.AddElement(customer);
// derived entity type special customer
EdmEntityType specialCustomer = new EdmEntityType("NS", "SpecialCustomer", customer);
specialCustomer.AddStructuralProperty("Title", EdmPrimitiveTypeKind.Guid);
model.AddElement(specialCustomer);
// entity sets
EdmEntityContainer container = new EdmEntityContainer("NS", "Default");
model.AddElement(container);
container.AddEntitySet("FCustomers", customer);
EdmComplexTypeReference complexType = new EdmComplexTypeReference(address, isNullable: false);
EdmCollectionTypeReference complexCollectionType = new EdmCollectionTypeReference(new EdmCollectionType(complexType));
EdmEnumTypeReference enumType = new EdmEnumTypeReference(colorEnum, isNullable: false);
EdmCollectionTypeReference enumCollectionType = new EdmCollectionTypeReference(new EdmCollectionType(enumType));
EdmEntityTypeReference entityType = new EdmEntityTypeReference(customer, isNullable: false);
EdmCollectionTypeReference entityCollectionType = new EdmCollectionTypeReference(new EdmCollectionType(entityType));
IEdmTypeReference intType = EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.Int32, isNullable: true);
EdmCollectionTypeReference primitiveCollectionType = new EdmCollectionTypeReference(new EdmCollectionType(intType));
// bound functions
BoundFunction(model, "IntCollectionFunction", "intValues", primitiveCollectionType, entityType);
BoundFunction(model, "ComplexFunction", "address", complexType, entityType);
BoundFunction(model, "ComplexCollectionFunction", "addresses", complexCollectionType, entityType);
BoundFunction(model, "EnumFunction", "color", enumType, entityType);
BoundFunction(model, "EnumCollectionFunction", "colors", enumCollectionType, entityType);
BoundFunction(model, "EntityFunction", "customer", entityType, entityType);
BoundFunction(model, "CollectionEntityFunction", "customers", entityCollectionType, entityType);
// unbound functions
UnboundFunction(container, "UnboundIntCollectionFunction", "intValues", primitiveCollectionType);
UnboundFunction(container, "UnboundComplexFunction", "address", complexType);
UnboundFunction(container, "UnboundComplexCollectionFunction", "addresses", complexCollectionType);
UnboundFunction(container, "UnboundEnumFunction", "color", enumType);
UnboundFunction(container, "UnboundEnumCollectionFunction", "colors", enumCollectionType);
UnboundFunction(container, "UnboundEntityFunction", "customer", entityType);
UnboundFunction(container, "UnboundCollectionEntityFunction", "customers", entityCollectionType);
// bound to collection
BoundToCollectionFunction(model, "BoundToCollectionFunction", "p", intType, entityType);
model.SetAnnotationValue <BindableOperationFinder>(model, new BindableOperationFinder(model));
return(model);
}
public static TestModel Initialize()
{
EdmModel model = new EdmModel();
var result = new TestModel(model);
var productType = new EdmEntityType("TestModel", "Product");
result.ProductType = productType;
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);
EdmEntityContainer defaultContainer = new EdmEntityContainer("TestModel", "Default");
result.Container = defaultContainer;
result.ProductsSet = defaultContainer.AddEntitySet("Products", productType);
model.AddElement(defaultContainer);
var derivedProductType = new EdmEntityType("TestModel", "DerivedProduct", productType);
result.DerivedProductType = derivedProductType;
EdmEntityType multipleKeyType = new EdmEntityType("TestModel", "MultipleKeyType");
result.MultipleKeyType = multipleKeyType;
EdmStructuralProperty keyAProperty = new EdmStructuralProperty(multipleKeyType, "KeyA", EdmCoreModel.Instance.GetString(false));
EdmStructuralProperty keyBProperty = new EdmStructuralProperty(multipleKeyType, "KeyB", EdmCoreModel.Instance.GetInt32(false));
multipleKeyType.AddProperty(keyAProperty);
multipleKeyType.AddProperty(keyBProperty);
multipleKeyType.AddKeys(keyAProperty, keyBProperty);
model.AddElement(multipleKeyType);
result.MultipleKeysSet = defaultContainer.AddEntitySet("MultipleKeySet", multipleKeyType);
EdmEntityType productTypeWithNavProps = new EdmEntityType("TestModel", "ProductWithNavProps", productType);
result.ProductWithNavPropsType = productTypeWithNavProps;
productTypeWithNavProps.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo()
{
Name = "RelatedProducts",
Target = productType,
TargetMultiplicity = EdmMultiplicity.Many
});
productTypeWithNavProps.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo()
{
Name = "RelatedDerivedProduct",
Target = derivedProductType,
TargetMultiplicity = EdmMultiplicity.One
});
model.AddElement(productTypeWithNavProps);
EdmAction action = new EdmAction("TestModel", "SimpleAction", null /*returnType*/, true /*isBound*/, null /*entitySetPath*/);
model.AddElement(action);
defaultContainer.AddActionImport("SimpleAction", action);
EdmAction action1 = new EdmAction("TestModel", "SimpleFunctionWithOverload", EdmCoreModel.Instance.GetInt32(false), true /*isbound*/, null);
action1.AddParameter("p1", EdmCoreModel.Instance.GetInt32(false));
defaultContainer.AddActionImport("SimpleFunctionWithOverload", action1);
EdmAction action2 = new EdmAction("TestModel", "SimpleFunctionWithOverload", EdmCoreModel.Instance.GetInt32(false), true /*isbound*/, null);
action2.AddParameter("p1", EdmCoreModel.Instance.GetString(false));
defaultContainer.AddActionImport("SimpleFunctionWithOverload", action2);
result.OneProductValue = BuildDefaultProductValue(productType);
result.OneDerivedProductValue = BuildDefaultProductValue(derivedProductType);
result.OneMultipleKeyValue = BuildDefaultMultipleKeyValue(model);
result.OneProductWithNavPropsValue = BuildDefaultProductValue(productTypeWithNavProps);
return(result);
}
/// <summary>
/// Creates a test model shared among parameter reader/writer tests.
/// </summary>
/// <returns>Returns a model with operation imports.</returns>
public static IEdmModel BuildModelWithFunctionImport()
{
EdmCoreModel coreModel = EdmCoreModel.Instance;
EdmModel model = new EdmModel();
const string defaultNamespaceName = DefaultNamespaceName;
EdmEntityContainer container = new EdmEntityContainer(defaultNamespaceName, "TestContainer");
model.AddElement(container);
EdmComplexType complexType = new EdmComplexType(defaultNamespaceName, "ComplexType");
complexType.AddProperty(new EdmStructuralProperty(complexType, "PrimitiveProperty", coreModel.GetString(false)));
complexType.AddProperty(new EdmStructuralProperty(complexType, "ComplexProperty", complexType.ToTypeReference(false)));
model.AddElement(complexType);
EdmEnumType enumType = new EdmEnumType(defaultNamespaceName, "EnumType");
model.AddElement(enumType);
EdmEntityType entityType = new EdmEntityType(defaultNamespaceName, "EntityType");
entityType.AddKeys(new IEdmStructuralProperty[] { new EdmStructuralProperty(entityType, "ID", coreModel.GetInt32(false)) });
entityType.AddProperty(new EdmStructuralProperty(entityType, "ComplexProperty", complexType.ToTypeReference()));
container.AddFunctionAndFunctionImport(model, "FunctionImport_Primitive", coreModel.GetString(false) /*returnType*/, null /*entitySet*/, false /*composable*/, false /*bindable*/).Function.AsEdmFunction().AddParameter("primitive", coreModel.GetString(false));
container.AddFunctionAndFunctionImport(model, "FunctionImport_NullablePrimitive", coreModel.GetString(false) /*returnType*/, null /*entitySet*/, false /*composable*/, false /*bindable*/).Function.AsEdmFunction().AddParameter("nullablePrimitive", coreModel.GetString(true));
EdmCollectionType stringCollectionType = new EdmCollectionType(coreModel.GetString(true));
container.AddFunctionAndFunctionImport(model, "FunctionImport_PrimitiveCollection", coreModel.GetString(false) /*returnType*/, null /*entitySet*/, false /*composable*/, false /*bindable*/).Function.AsEdmFunction().AddParameter("primitiveCollection", stringCollectionType.ToTypeReference(false));
container.AddFunctionAndFunctionImport(model, "FunctionImport_Complex", coreModel.GetString(false) /*returnType*/, null /*entitySet*/, false /*composable*/, false /*bindable*/).Function.AsEdmFunction().AddParameter("complex", complexType.ToTypeReference(true));
EdmCollectionType complexCollectionType = new EdmCollectionType(complexType.ToTypeReference());
container.AddFunctionAndFunctionImport(model, "FunctionImport_ComplexCollection", coreModel.GetString(false) /*returnType*/, null /*entitySet*/, false /*composable*/, false /*bindable*/).Function.AsEdmFunction().AddParameter("complexCollection", complexCollectionType.ToTypeReference());
container.AddFunctionAndFunctionImport(model, "FunctionImport_Entry", coreModel.GetString(false) /*returnType*/, null /*entitySet*/, false /*composable*/, true /*bindable*/).Function.AsEdmFunction().AddParameter("entry", entityType.ToTypeReference());
EdmCollectionType entityCollectionType = new EdmCollectionType(entityType.ToTypeReference());
container.AddFunctionAndFunctionImport(model, "FunctionImport_Feed", coreModel.GetString(false) /*returnType*/, null /*entitySet*/, false /*composable*/, true /*bindable*/).Function.AsEdmFunction().AddParameter("feed", entityCollectionType.ToTypeReference());
container.AddFunctionAndFunctionImport(model, "FunctionImport_Stream", coreModel.GetString(false) /*returnType*/, null /*entitySet*/, false /*composable*/, false /*bindable*/).Function.AsEdmFunction().AddParameter("stream", coreModel.GetStream(false));
container.AddFunctionAndFunctionImport(model, "FunctionImport_Enum", coreModel.GetString(false) /*returnType*/, null /*entitySet*/, false /*composable*/, false /*bindable*/).Function.AsEdmFunction().AddParameter("enum", enumType.ToTypeReference());
var functionImport_PrimitiveTwoParameters = container.AddFunctionAndFunctionImport(model, "FunctionImport_PrimitiveTwoParameters", coreModel.GetString(false) /*returnType*/, null /*entitySet*/, false /*composable*/, false /*bindable*/);
var function_PrimitiveTwoParameters = functionImport_PrimitiveTwoParameters.Function.AsEdmFunction();
function_PrimitiveTwoParameters.AddParameter("p1", coreModel.GetInt32(false));
function_PrimitiveTwoParameters.AddParameter("p2", coreModel.GetString(false));
container.AddFunctionAndFunctionImport(model, "FunctionImport_Int", coreModel.GetString(false) /*returnType*/, null /*entitySet*/, false /*composable*/, false /*bindable*/).Function.AsEdmFunction().AddParameter("p1", coreModel.GetInt32(false));
container.AddFunctionAndFunctionImport(model, "FunctionImport_Double", coreModel.GetString(false) /*returnType*/, null /*entitySet*/, false /*composable*/, false /*bindable*/).Function.AsEdmFunction().AddParameter("p1", coreModel.GetDouble(false));
EdmCollectionType int32CollectionType = new EdmCollectionType(coreModel.GetInt32(false));
container.AddActionAndActionImport(model, "FunctionImport_NonNullablePrimitiveCollection", null /*returnType*/, null /*entitySet*/, false /*bindable*/).Action.AsEdmAction().AddParameter("p1", int32CollectionType.ToTypeReference(false));
EdmComplexType complexType2 = new EdmComplexType(defaultNamespaceName, "ComplexTypeWithNullableProperties");
complexType2.AddProperty(new EdmStructuralProperty(complexType2, "StringProperty", coreModel.GetString(true)));
complexType2.AddProperty(new EdmStructuralProperty(complexType2, "IntegerProperty", coreModel.GetInt32(true)));
model.AddElement(complexType2);
EdmEnumType enumType1 = new EdmEnumType(defaultNamespaceName, "enumType1");
enumType1.AddMember(new EdmEnumMember(enumType1, "enumType1_value1", new EdmEnumMemberValue(6)));
model.AddElement(enumType1);
var functionImport_MultipleNullableParameters = container.AddFunctionAndFunctionImport(model, "FunctionImport_MultipleNullableParameters", coreModel.GetString(false) /*returnType*/, null /*entitySet*/, false /*composable*/, false /*bindable*/);
var function_MultipleNullableParameters = functionImport_MultipleNullableParameters.Function.AsEdmFunction();
function_MultipleNullableParameters.AddParameter("p1", coreModel.GetBinary(true /*isNullable*/));
function_MultipleNullableParameters.AddParameter("p2", coreModel.GetBoolean(true /*isNullable*/));
function_MultipleNullableParameters.AddParameter("p3", coreModel.GetByte(true /*isNullable*/));
function_MultipleNullableParameters.AddParameter("p5", coreModel.GetDateTimeOffset(true /*isNullable*/));
function_MultipleNullableParameters.AddParameter("p6", coreModel.GetDecimal(true /*isNullable*/));
function_MultipleNullableParameters.AddParameter("p7", coreModel.GetDouble(true /*isNullable*/));
function_MultipleNullableParameters.AddParameter("p8", coreModel.GetGuid(true /*isNullable*/));
function_MultipleNullableParameters.AddParameter("p9", coreModel.GetInt16(true /*isNullable*/));
function_MultipleNullableParameters.AddParameter("p10", coreModel.GetInt32(true /*isNullable*/));
function_MultipleNullableParameters.AddParameter("p11", coreModel.GetInt64(true /*isNullable*/));
function_MultipleNullableParameters.AddParameter("p12", coreModel.GetSByte(true /*isNullable*/));
function_MultipleNullableParameters.AddParameter("p13", coreModel.GetSingle(true /*isNullable*/));
function_MultipleNullableParameters.AddParameter("p14", coreModel.GetSpatial(EdmPrimitiveTypeKind.GeographyPoint, true /*isNullable*/));
function_MultipleNullableParameters.AddParameter("p15", coreModel.GetString(true /*isNullable*/));
function_MultipleNullableParameters.AddParameter("p16", complexType2.ToTypeReference(true /*isNullable*/));
function_MultipleNullableParameters.AddParameter("p17", enumType1.ToTypeReference(true /*isNullable*/));
return(model);
}
protected override void VisitEdmEntityContainer(EdmEntityContainer item)
{
_schemaWriter.WriteEntityContainerElementHeader(item);
base.VisitEdmEntityContainer(item);
_schemaWriter.WriteEndElement();
}
/// <summary>
/// Creates a test model to test our conversion of OData instances into EDM values.
/// </summary>
/// <returns>Returns a model suitable for testing EDM values over OData instances.</returns>
public static IEdmModel BuildEdmValueModel()
{
EdmModel model = new EdmModel();
var complexType = new EdmComplexType(DefaultNamespaceName, "ComplexType");
complexType.AddStructuralProperty("IntProp", Int32TypeRef);
complexType.AddStructuralProperty("StringProp", EdmCoreModel.Instance.GetString(isNullable: false));
complexType.AddStructuralProperty("ComplexProp", new EdmComplexTypeReference(complexType, isNullable: true));
model.AddElement(complexType);
#region Entity types
var entityContainer = new EdmEntityContainer(DefaultNamespaceName, "TestContainer");
model.AddElement(entityContainer);
// Entity type with a single primitive property
var singlePrimitivePropertyEntityType = new EdmEntityType(DefaultNamespaceName, "SinglePrimitivePropertyEntityType");
singlePrimitivePropertyEntityType.AddKeys(singlePrimitivePropertyEntityType.AddStructuralProperty("ID", Int32TypeRef));
singlePrimitivePropertyEntityType.AddStructuralProperty("Int32Prop", Int32NullableTypeRef);
entityContainer.AddEntitySet("SinglePrimitivePropertyEntityType", singlePrimitivePropertyEntityType);
model.AddElement(singlePrimitivePropertyEntityType);
// Entity type with all primitive properties
var allPrimitivePropertiesEntityType = new EdmEntityType(DefaultNamespaceName, "AllPrimitivePropertiesEntityType");
allPrimitivePropertiesEntityType.AddKeys(allPrimitivePropertiesEntityType.AddStructuralProperty("ID", Int32TypeRef));
allPrimitivePropertiesEntityType.AddStructuralProperty("BoolProp", EdmPrimitiveTypeKind.Boolean, isNullable: false);
allPrimitivePropertiesEntityType.AddStructuralProperty("Int16Prop", EdmPrimitiveTypeKind.Int16, isNullable: false);
allPrimitivePropertiesEntityType.AddStructuralProperty("Int32Prop", EdmPrimitiveTypeKind.Int32, isNullable: false);
allPrimitivePropertiesEntityType.AddStructuralProperty("Int64Prop", EdmPrimitiveTypeKind.Int64, isNullable: false);
allPrimitivePropertiesEntityType.AddStructuralProperty("ByteProp", EdmPrimitiveTypeKind.Byte, isNullable: false);
allPrimitivePropertiesEntityType.AddStructuralProperty("SByteProp", EdmPrimitiveTypeKind.SByte, isNullable: false);
allPrimitivePropertiesEntityType.AddStructuralProperty("SingleProp", EdmPrimitiveTypeKind.Single, isNullable: false);
allPrimitivePropertiesEntityType.AddStructuralProperty("DoubleProp", EdmPrimitiveTypeKind.Double, isNullable: false);
allPrimitivePropertiesEntityType.AddStructuralProperty("DecimalProp", EdmPrimitiveTypeKind.Decimal, isNullable: false);
allPrimitivePropertiesEntityType.AddStructuralProperty("DateTimeOffsetProp", EdmPrimitiveTypeKind.DateTimeOffset, isNullable: false);
allPrimitivePropertiesEntityType.AddStructuralProperty("TimeProp", EdmPrimitiveTypeKind.Duration, isNullable: false);
allPrimitivePropertiesEntityType.AddStructuralProperty("GuidProp", EdmPrimitiveTypeKind.Guid, isNullable: false);
allPrimitivePropertiesEntityType.AddStructuralProperty("StringProp", EdmPrimitiveTypeKind.String, isNullable: false);
allPrimitivePropertiesEntityType.AddStructuralProperty("BinaryProp", EdmPrimitiveTypeKind.Binary, isNullable: false);
entityContainer.AddEntitySet("AllPrimitivePropertiesEntityType", allPrimitivePropertiesEntityType);
model.AddElement(allPrimitivePropertiesEntityType);
// Entity type with a single complex property
var singleComplexPropertyEntityType = new EdmEntityType(DefaultNamespaceName, "SingleComplexPropertyEntityType");
singleComplexPropertyEntityType.AddKeys(singleComplexPropertyEntityType.AddStructuralProperty("ID", Int32TypeRef));
singleComplexPropertyEntityType.AddStructuralProperty("ComplexProp", new EdmComplexTypeReference(complexType, isNullable: true));
entityContainer.AddEntitySet("SingleComplexPropertyEntityType", singleComplexPropertyEntityType);
model.AddElement(singleComplexPropertyEntityType);
// Entity type with a single primitive collection property
var singlePrimitiveCollectionPropertyEntityType = new EdmEntityType(DefaultNamespaceName, "SinglePrimitiveCollectionPropertyEntityType");
singlePrimitiveCollectionPropertyEntityType.AddKeys(singlePrimitiveCollectionPropertyEntityType.AddStructuralProperty("ID", Int32TypeRef));
singlePrimitiveCollectionPropertyEntityType.AddStructuralProperty("PrimitiveCollectionProp", EdmCoreModel.GetCollection(Int32TypeRef));
entityContainer.AddEntitySet("SinglePrimitiveCollectionPropertyEntityType", singlePrimitiveCollectionPropertyEntityType);
model.AddElement(singlePrimitiveCollectionPropertyEntityType);
// Entity type with a single primitive collection property
var singleComplexCollectionPropertyEntityType = new EdmEntityType(DefaultNamespaceName, "SingleComplexCollectionPropertyEntityType");
singleComplexCollectionPropertyEntityType.AddKeys(singleComplexCollectionPropertyEntityType.AddStructuralProperty("ID", Int32TypeRef));
singleComplexCollectionPropertyEntityType.AddStructuralProperty("ComplexCollectionProp", EdmCoreModel.GetCollection(new EdmComplexTypeReference(complexType, isNullable: true)));
entityContainer.AddEntitySet("SingleComplexCollectionPropertyEntityType", singleComplexCollectionPropertyEntityType);
model.AddElement(singleComplexCollectionPropertyEntityType);
// Entity type with different property kinds
var differentPropertyKindsEntityType = new EdmEntityType(DefaultNamespaceName, "DifferentPropertyKindsEntityType");
differentPropertyKindsEntityType.AddKeys(differentPropertyKindsEntityType.AddStructuralProperty("ID", Int32TypeRef));
differentPropertyKindsEntityType.AddStructuralProperty("ComplexProp", new EdmComplexTypeReference(complexType, isNullable: true));
differentPropertyKindsEntityType.AddStructuralProperty("PrimitiveCollectionProp", EdmCoreModel.GetCollection(Int32TypeRef));
differentPropertyKindsEntityType.AddStructuralProperty("Int32Prop", EdmPrimitiveTypeKind.Int32, isNullable: false);
differentPropertyKindsEntityType.AddStructuralProperty("ComplexCollectionProp", EdmCoreModel.GetCollection(new EdmComplexTypeReference(complexType, isNullable: true)));
entityContainer.AddEntitySet("DifferentPropertyKindsEntityType", differentPropertyKindsEntityType);
model.AddElement(differentPropertyKindsEntityType);
#endregion Entity types
#region Complex types
// Empty complex type
model.AddElement(new EdmComplexType(DefaultNamespaceName, "EmptyComplexType"));
// Complex type with a single primitive property
var singlePrimitivePropertyComplexType = new EdmComplexType(DefaultNamespaceName, "SinglePrimitivePropertyComplexType");
singlePrimitivePropertyComplexType.AddStructuralProperty("Int32Prop", Int32NullableTypeRef);
model.AddElement(singlePrimitivePropertyComplexType);
// Complex type with all primitive properties
var allPrimitivePropertiesComplexType = new EdmComplexType(DefaultNamespaceName, "AllPrimitivePropertiesComplexType");
allPrimitivePropertiesComplexType.AddStructuralProperty("BoolProp", EdmPrimitiveTypeKind.Boolean, isNullable: false);
allPrimitivePropertiesComplexType.AddStructuralProperty("Int16Prop", EdmPrimitiveTypeKind.Int16, isNullable: false);
allPrimitivePropertiesComplexType.AddStructuralProperty("Int32Prop", EdmPrimitiveTypeKind.Int32, isNullable: false);
allPrimitivePropertiesComplexType.AddStructuralProperty("Int64Prop", EdmPrimitiveTypeKind.Int64, isNullable: false);
allPrimitivePropertiesComplexType.AddStructuralProperty("ByteProp", EdmPrimitiveTypeKind.Byte, isNullable: false);
allPrimitivePropertiesComplexType.AddStructuralProperty("SByteProp", EdmPrimitiveTypeKind.SByte, isNullable: false);
allPrimitivePropertiesComplexType.AddStructuralProperty("SingleProp", EdmPrimitiveTypeKind.Single, isNullable: false);
allPrimitivePropertiesComplexType.AddStructuralProperty("DoubleProp", EdmPrimitiveTypeKind.Double, isNullable: false);
allPrimitivePropertiesComplexType.AddStructuralProperty("DecimalProp", EdmPrimitiveTypeKind.Decimal, isNullable: false);
allPrimitivePropertiesComplexType.AddStructuralProperty("DateTimeOffsetProp", EdmPrimitiveTypeKind.DateTimeOffset, isNullable: false);
allPrimitivePropertiesComplexType.AddStructuralProperty("TimeProp", EdmPrimitiveTypeKind.Duration, isNullable: false);
allPrimitivePropertiesComplexType.AddStructuralProperty("GuidProp", EdmPrimitiveTypeKind.Guid, isNullable: false);
allPrimitivePropertiesComplexType.AddStructuralProperty("StringProp", EdmPrimitiveTypeKind.String, isNullable: false);
allPrimitivePropertiesComplexType.AddStructuralProperty("BinaryProp", EdmPrimitiveTypeKind.Binary, isNullable: false);
model.AddElement(allPrimitivePropertiesComplexType);
// Complex type with a single complex property
var singleComplexPropertyComplexType = new EdmComplexType(DefaultNamespaceName, "SingleComplexPropertyComplexType");
singleComplexPropertyComplexType.AddStructuralProperty("ComplexProp", new EdmComplexTypeReference(complexType, isNullable: true));
model.AddElement(singleComplexPropertyComplexType);
// Complex type with a single primitive collection property
var singlePrimitiveCollectionPropertyComplexType = new EdmComplexType(DefaultNamespaceName, "SinglePrimitiveCollectionPropertyComplexType");
singlePrimitiveCollectionPropertyComplexType.AddStructuralProperty("PrimitiveCollectionProp", EdmCoreModel.GetCollection(Int32TypeRef));
model.AddElement(singlePrimitiveCollectionPropertyComplexType);
// Complex type with a single primitive collection property
var singleComplexCollectionPropertyComplexType = new EdmComplexType(DefaultNamespaceName, "SingleComplexCollectionPropertyComplexType");
singleComplexCollectionPropertyComplexType.AddStructuralProperty("ComplexCollectionProp", EdmCoreModel.GetCollection(new EdmComplexTypeReference(complexType, isNullable: true)));
model.AddElement(singleComplexCollectionPropertyComplexType);
// Complex type with different property kinds
var differentPropertyKindsComplexType = new EdmComplexType(DefaultNamespaceName, "DifferentPropertyKindsComplexType");
differentPropertyKindsComplexType.AddStructuralProperty("ComplexProp", new EdmComplexTypeReference(complexType, isNullable: true));
differentPropertyKindsComplexType.AddStructuralProperty("PrimitiveCollectionProp", EdmCoreModel.GetCollection(Int32TypeRef));
differentPropertyKindsComplexType.AddStructuralProperty("Int32Prop", EdmPrimitiveTypeKind.Int32);
differentPropertyKindsComplexType.AddStructuralProperty("ComplexCollectionProp", EdmCoreModel.GetCollection(new EdmComplexTypeReference(complexType, isNullable: true)));
model.AddElement(differentPropertyKindsComplexType);
#endregion Complex types
return(model);
}
public void ReadOpenCollectionPropertyValue()
{
EdmModel model = new EdmModel();
EdmEntityType entityType = new EdmEntityType("NS", "MyTestEntity", null, false, true);
EdmStructuralProperty key = entityType.AddStructuralProperty("LongId", EdmPrimitiveTypeKind.Int64, false);
entityType.AddKeys(key);
EdmComplexType complexType = new EdmComplexType("NS", "MyTestComplexType");
complexType.AddStructuralProperty("CLongId", EdmPrimitiveTypeKind.Int64, false);
model.AddElement(complexType);
EdmEntityContainer container = new EdmEntityContainer("EntityNs", "MyContainer_sub");
EdmEntitySet entitySet = container.AddEntitySet("MyTestEntitySet", entityType);
model.AddElement(container);
const string payload =
"{" +
"\"@odata.context\":\"http://www.example.com/$metadata#EntityNs.MyContainer.MyTestEntitySet/$entity\"," +
"\"@odata.id\":\"http://mytest\"," +
"\"[email protected]\":\"Collection(Edm.Int32)\"," +
"\"OpenPrimitiveCollection\":[0,1,2]," +
"\"[email protected]\":\"Collection(NS.MyTestComplexType)\"," +
"\"OpenComplexTypeCollection\":[{\"CLongId\":\"1\"},{\"CLongId\":\"1\"}]" +
"}";
IEdmModel mainModel = TestUtils.WrapReferencedModelsToMainModel("EntityNs", "MyContainer", model);
ODataResource entry = null;
List <ODataResource> complexCollection = new List <ODataResource>();
ODataNestedResourceInfo nestedOpenCollection = null;
bool startComplexCollection = false;
this.ReadEntryPayload(mainModel, payload, entitySet, entityType,
reader =>
{
switch (reader.State)
{
case ODataReaderState.NestedResourceInfoStart:
startComplexCollection = true;
break;
case ODataReaderState.ResourceEnd:
if (startComplexCollection)
{
complexCollection.Add(reader.Item as ODataResource);
}
entry = reader.Item as ODataResource;
break;
case ODataReaderState.NestedResourceInfoEnd:
startComplexCollection = false;
nestedOpenCollection = reader.Item as ODataNestedResourceInfo;
break;
}
});
Assert.NotNull(entry);
var intCollection = entry.Properties.FirstOrDefault(
s => string.Equals(
s.Name,
"OpenPrimitiveCollection",
StringComparison.OrdinalIgnoreCase)).Value.As <ODataCollectionValue>();
var list = new List <int?>();
foreach (var val in intCollection.Items)
{
list.Add(val as int?);
}
Assert.Equal(0, list[0]);
Assert.Equal(1, (int)list[1]);
Assert.Equal(2, (int)list[2]);
Assert.Equal("OpenComplexTypeCollection", nestedOpenCollection.Name);
foreach (var val in complexCollection)
{
val.Properties.FirstOrDefault(s => string.Equals(s.Name, "CLongId", StringComparison.OrdinalIgnoreCase)).Value.ShouldBeEquivalentTo(1L, "value should be in correct type.");
}
}
private static EdmModel BuildEdmModel()
{
var model = new EdmModel();
var numberEntity = new EdmEntityType("NS", "Number");
numberEntity.AddKeys(numberEntity.AddStructuralProperty("RowId", EdmCoreModel.Instance.GetInt32(false)));
numberEntity.AddStructuralProperty("RowParity", EdmCoreModel.Instance.GetString(false));
numberEntity.AddStructuralProperty("RowCategory", EdmCoreModel.Instance.GetString(false));
numberEntity.AddStructuralProperty("IntProp", EdmCoreModel.Instance.GetInt32(false));
numberEntity.AddStructuralProperty("NullableIntProp", EdmCoreModel.Instance.GetInt32(true));
numberEntity.AddStructuralProperty("DoubleProp", EdmCoreModel.Instance.GetDouble(false));
numberEntity.AddStructuralProperty("NullableDoubleProp", EdmCoreModel.Instance.GetDouble(true));
numberEntity.AddStructuralProperty("DecimalProp", EdmCoreModel.Instance.GetDecimal(false));
numberEntity.AddStructuralProperty("NullableDecimalProp", EdmCoreModel.Instance.GetDecimal(true));
numberEntity.AddStructuralProperty("LongProp", EdmCoreModel.Instance.GetInt64(false));
numberEntity.AddStructuralProperty("NullableLongProp", EdmCoreModel.Instance.GetInt64(true));
numberEntity.AddStructuralProperty("SingleProp", EdmCoreModel.Instance.GetSingle(false));
numberEntity.AddStructuralProperty("NullableSingleProp", EdmCoreModel.Instance.GetSingle(true));
var saleEntity = new EdmEntityType("NS", "Sale");
saleEntity.AddKeys(saleEntity.AddStructuralProperty("Id", EdmCoreModel.Instance.GetInt32(false)));
saleEntity.AddStructuralProperty("CustomerId", EdmCoreModel.Instance.GetString(false));
saleEntity.AddStructuralProperty("Date", EdmCoreModel.Instance.GetString(false));
saleEntity.AddStructuralProperty("ProductId", EdmCoreModel.Instance.GetString(false));
saleEntity.AddStructuralProperty("CurrencyCode", EdmCoreModel.Instance.GetString(false));
saleEntity.AddStructuralProperty("Amount", EdmCoreModel.Instance.GetDecimal(false));
var productEntity = new EdmEntityType("NS", "Product");
productEntity.AddKeys(productEntity.AddStructuralProperty("Id", EdmCoreModel.Instance.GetInt32(false)));
productEntity.AddStructuralProperty("CategoryId", EdmCoreModel.Instance.GetString(false));
productEntity.AddStructuralProperty("Name", EdmCoreModel.Instance.GetString(false));
productEntity.AddStructuralProperty("Color", EdmCoreModel.Instance.GetString(false));
productEntity.AddStructuralProperty("TaxRate", EdmCoreModel.Instance.GetDecimal(false));
var customerEntity = new EdmEntityType("NS", "Customer");
customerEntity.AddKeys(customerEntity.AddStructuralProperty("Id", EdmCoreModel.Instance.GetString(false)));
customerEntity.AddStructuralProperty("Name", EdmCoreModel.Instance.GetString(false));
customerEntity.AddStructuralProperty("Country", EdmCoreModel.Instance.GetString(false));
var categoryEntity = new EdmEntityType("NS", "Category");
categoryEntity.AddKeys(categoryEntity.AddStructuralProperty("Id", EdmCoreModel.Instance.GetString(false)));
categoryEntity.AddStructuralProperty("Name", EdmCoreModel.Instance.GetString(false));
var currencyEntity = new EdmEntityType("NS", "Currency");
currencyEntity.AddKeys(currencyEntity.AddStructuralProperty("Code", EdmCoreModel.Instance.GetString(false)));
currencyEntity.AddStructuralProperty("Name", EdmCoreModel.Instance.GetString(false));
// Associations
saleEntity.AddBidirectionalNavigation(
new EdmNavigationPropertyInfo {
Name = "Customer", Target = customerEntity, TargetMultiplicity = EdmMultiplicity.One
},
new EdmNavigationPropertyInfo {
Name = "Sales", Target = saleEntity, TargetMultiplicity = EdmMultiplicity.Many
});
saleEntity.AddBidirectionalNavigation(
new EdmNavigationPropertyInfo {
Name = "Product", Target = productEntity, TargetMultiplicity = EdmMultiplicity.One
},
new EdmNavigationPropertyInfo {
Name = "Sales", Target = saleEntity, TargetMultiplicity = EdmMultiplicity.Many
});
saleEntity.AddUnidirectionalNavigation(
new EdmNavigationPropertyInfo {
Name = "Currency", Target = currencyEntity, TargetMultiplicity = EdmMultiplicity.One
});
productEntity.AddBidirectionalNavigation(
new EdmNavigationPropertyInfo {
Name = "Category", Target = categoryEntity, TargetMultiplicity = EdmMultiplicity.One
},
new EdmNavigationPropertyInfo {
Name = "Products", Target = productEntity, TargetMultiplicity = EdmMultiplicity.Many
});
var entityContainer = new EdmEntityContainer("NS", "Container");
model.AddElement(numberEntity);
model.AddElement(saleEntity);
model.AddElement(productEntity);
model.AddElement(customerEntity);
model.AddElement(categoryEntity);
model.AddElement(currencyEntity);
model.AddElement(entityContainer);
entityContainer.AddEntitySet(numbersEntitySetName, numberEntity);
entityContainer.AddEntitySet(salesEntitySetName, saleEntity);
entityContainer.AddEntitySet(productsEntitySetName, productEntity);
return(model);
}
public void ReadingPayloadInt64SingleDoubleDecimalWithoutSuffix()
{
EdmModel model = new EdmModel();
EdmEntityType entityType = new EdmEntityType("NS", "MyTestEntity");
EdmStructuralProperty key = entityType.AddStructuralProperty("LongId", EdmPrimitiveTypeKind.Int64, false);
entityType.AddKeys(key);
entityType.AddStructuralProperty("FloatId", EdmPrimitiveTypeKind.Single, false);
entityType.AddStructuralProperty("DoubleId", EdmPrimitiveTypeKind.Double, false);
entityType.AddStructuralProperty("DecimalId", EdmPrimitiveTypeKind.Decimal, false);
EdmComplexType complexType = new EdmComplexType("NS", "MyTestComplexType");
complexType.AddStructuralProperty("CLongId", EdmPrimitiveTypeKind.Int64, false);
complexType.AddStructuralProperty("CFloatId", EdmPrimitiveTypeKind.Single, false);
complexType.AddStructuralProperty("CDoubleId", EdmPrimitiveTypeKind.Double, false);
complexType.AddStructuralProperty("CDecimalId", EdmPrimitiveTypeKind.Decimal, false);
model.AddElement(complexType);
EdmComplexTypeReference complexTypeRef = new EdmComplexTypeReference(complexType, true);
entityType.AddStructuralProperty("ComplexProperty", complexTypeRef);
entityType.AddStructuralProperty("LongNumbers", new EdmCollectionTypeReference(new EdmCollectionType(EdmCoreModel.Instance.GetInt64(false))));
entityType.AddStructuralProperty("FloatNumbers", new EdmCollectionTypeReference(new EdmCollectionType(EdmCoreModel.Instance.GetSingle(false))));
entityType.AddStructuralProperty("DoubleNumbers", new EdmCollectionTypeReference(new EdmCollectionType(EdmCoreModel.Instance.GetDouble(false))));
entityType.AddStructuralProperty("DecimalNumbers", new EdmCollectionTypeReference(new EdmCollectionType(EdmCoreModel.Instance.GetDecimal(false))));
model.AddElement(entityType);
EdmEntityContainer container = new EdmEntityContainer("EntityNs", "MyContainer_sub");
EdmEntitySet entitySet = container.AddEntitySet("MyTestEntitySet", entityType);
model.AddElement(container);
const string payload =
"{" +
"\"@odata.context\":\"http://www.example.com/$metadata#EntityNs.MyContainer.MyTestEntitySet/$entity\"," +
"\"@odata.id\":\"http://MyTestEntity\"," +
"\"LongId\":\"12\"," +
"\"FloatId\":34.98," +
"\"DoubleId\":56.01," +
"\"DecimalId\":\"78.62\"," +
"\"LongNumbers\":[\"-1\",\"-9223372036854775808\",\"9223372036854775807\"]," +
"\"FloatNumbers\":[-1,-3.40282347E+38,3.40282347E+38,\"INF\",\"-INF\",\"NaN\"]," +
"\"DoubleNumbers\":[1.0,-1.7976931348623157E+308,1.7976931348623157E+308,\"INF\",\"-INF\",\"NaN\"]," +
"\"DecimalNumbers\":[\"0\",\"-79228162514264337593543950335\",\"79228162514264337593543950335\"]," +
"\"ComplexProperty\":{\"CLongId\":\"1\",\"CFloatId\":1,\"CDoubleId\":-1.0,\"CDecimalId\":\"0.0\"}" +
"}";
IEdmModel mainModel = TestUtils.WrapReferencedModelsToMainModel("EntityNs", "MyContainer", model);
List <ODataResource> entries = new List <ODataResource>();
ODataNestedResourceInfo navigationLink;
this.ReadEntryPayload(mainModel, payload, entitySet, entityType,
reader =>
{
switch (reader.State)
{
case ODataReaderState.ResourceStart:
entries.Add(reader.Item as ODataResource);
break;
case ODataReaderState.NestedResourceInfoStart:
navigationLink = (ODataNestedResourceInfo)reader.Item;
break;
default:
break;
}
});
Assert.Equal(2, entries.Count);
entries[0].Properties.FirstOrDefault(s => string.Equals(s.Name, "LongId", StringComparison.OrdinalIgnoreCase)).Value.ShouldBeEquivalentTo(12L, "value should be in correct type.");
entries[0].Properties.FirstOrDefault(s => string.Equals(s.Name, "FloatId", StringComparison.OrdinalIgnoreCase)).Value.ShouldBeEquivalentTo(34.98f, "value should be in correct type.");
entries[0].Properties.FirstOrDefault(s => string.Equals(s.Name, "DoubleId", StringComparison.OrdinalIgnoreCase)).Value.ShouldBeEquivalentTo(56.01d, "value should be in correct type.");
entries[0].Properties.FirstOrDefault(s => string.Equals(s.Name, "DecimalId", StringComparison.OrdinalIgnoreCase)).Value.ShouldBeEquivalentTo(78.62m, "value should be in correct type.");
var complextProperty = entries[1];
complextProperty.Properties.FirstOrDefault(s => string.Equals(s.Name, "CLongId", StringComparison.OrdinalIgnoreCase)).Value.ShouldBeEquivalentTo(1L, "value should be in correct type.");
complextProperty.Properties.FirstOrDefault(s => string.Equals(s.Name, "CFloatId", StringComparison.OrdinalIgnoreCase)).Value.ShouldBeEquivalentTo(1.0F, "value should be in correct type.");
complextProperty.Properties.FirstOrDefault(s => string.Equals(s.Name, "CDoubleId", StringComparison.OrdinalIgnoreCase)).Value.ShouldBeEquivalentTo(-1.0D, "value should be in correct type.");
complextProperty.Properties.FirstOrDefault(s => string.Equals(s.Name, "CDecimalId", StringComparison.OrdinalIgnoreCase)).Value.ShouldBeEquivalentTo(0.0M, "value should be in correct type.");
var longCollection = entries[0].Properties.FirstOrDefault(s => string.Equals(s.Name, "LongNumbers", StringComparison.OrdinalIgnoreCase)).Value.As <ODataCollectionValue>();
longCollection.Items.Should().Contain(-1L).And.Contain(long.MinValue).And.Contain(long.MaxValue);
var floatCollection = entries[0].Properties.FirstOrDefault(s => string.Equals(s.Name, "FloatNumbers", StringComparison.OrdinalIgnoreCase)).Value.As <ODataCollectionValue>();
floatCollection.Items.Should().Contain(-1F).And.Contain(float.MinValue).And.Contain(float.MaxValue).And.Contain(float.PositiveInfinity).And.Contain(float.NegativeInfinity).And.Contain(float.NaN);
var doubleCollection = entries[0].Properties.FirstOrDefault(s => string.Equals(s.Name, "DoubleNumbers", StringComparison.OrdinalIgnoreCase)).Value.As <ODataCollectionValue>();
doubleCollection.Items.Should().Contain(1.0D).And.Contain(double.MinValue).And.Contain(double.MaxValue).And.Contain(double.PositiveInfinity).And.Contain(double.NegativeInfinity).And.Contain(double.NaN);
var decimalCollection = entries[0].Properties.FirstOrDefault(s => string.Equals(s.Name, "DecimalNumbers", StringComparison.OrdinalIgnoreCase)).Value.As <ODataCollectionValue>();
decimalCollection.Items.Should().Contain(0M).And.Contain(decimal.MinValue).And.Contain(decimal.MaxValue);
}
public void WriteCollectionOfNavigationOnComplex()
{
var model = new EdmModel();
var entity = new EdmEntityType("DefaultNs", "EntityType");
var entityId = entity.AddStructuralProperty("ID", EdmCoreModel.Instance.GetString(false));
entity.AddKeys(entityId);
var navEntity = new EdmEntityType("DefaultNs", "NavEntityType");
var navEntityId = navEntity.AddStructuralProperty("ID", EdmCoreModel.Instance.GetString(false));
navEntity.AddKeys(navEntityId);
var complex = new EdmComplexType("DefaultNs", "ComplexType");
complex.AddStructuralProperty("Prop1", EdmCoreModel.Instance.GetInt32(false));
var navP = complex.AddUnidirectionalNavigation(
new EdmNavigationPropertyInfo()
{
Name = "CollectionOfNav",
Target = navEntity,
TargetMultiplicity = EdmMultiplicity.Many,
});
entity.AddStructuralProperty("Complex", new EdmComplexTypeReference(complex, false));
model.AddElement(entity);
model.AddElement(navEntity);
model.AddElement(complex);
var entityContainer = new EdmEntityContainer("DefaultNs", "Container");
model.AddElement(entityContainer);
EdmEntitySet entites = new EdmEntitySet(entityContainer, "Entities", entity);
EdmEntitySet navEntities = new EdmEntitySet(entityContainer, "NavEntities", navEntity);
entites.AddNavigationTarget(navP, navEntities, new EdmPathExpression("Complex/CollectionOfNav"));
entityContainer.AddElement(entites);
entityContainer.AddElement(navEntities);
string actual = GetCsdl(model, CsdlTarget.OData);
string expected = "<?xml version=\"1.0\" encoding=\"utf-16\"?><edmx:Edmx Version=\"4.0\" xmlns:edmx=\"http://docs.oasis-open.org/odata/ns/edmx\">" +
"<edmx:DataServices><Schema Namespace=\"DefaultNs\" xmlns=\"http://docs.oasis-open.org/odata/ns/edm\">" +
"<EntityType Name=\"EntityType\">" +
"<Key><PropertyRef Name=\"ID\" /></Key>" +
"<Property Name=\"ID\" Type=\"Edm.String\" Nullable=\"false\" />" +
"<Property Name=\"Complex\" Type=\"DefaultNs.ComplexType\" Nullable=\"false\" />" +
"</EntityType>" +
"<EntityType Name=\"NavEntityType\">" +
"<Key><PropertyRef Name=\"ID\" /></Key>" +
"<Property Name=\"ID\" Type=\"Edm.String\" Nullable=\"false\" />" +
"</EntityType>" +
"<ComplexType Name=\"ComplexType\">" +
"<Property Name=\"Prop1\" Type=\"Edm.Int32\" Nullable=\"false\" />" +
"<NavigationProperty Name=\"CollectionOfNav\" Type=\"Collection(DefaultNs.NavEntityType)\" />" +
"</ComplexType>" +
"<EntityContainer Name=\"Container\">" +
"<EntitySet Name=\"Entities\" EntityType=\"DefaultNs.EntityType\">" +
"<NavigationPropertyBinding Path=\"Complex/CollectionOfNav\" Target=\"NavEntities\" />" +
"</EntitySet>" +
"<EntitySet Name=\"NavEntities\" EntityType=\"DefaultNs.NavEntityType\" />" +
"</EntityContainer>" +
"</Schema>" +
"</edmx:DataServices>" +
"</edmx:Edmx>";
Assert.Equal(expected, actual);
}
public void ReadingTypeDefinitionPayloadWithEdmTypeAnnotationJsonLight()
{
EdmModel model = new EdmModel();
EdmEntityType entityType = new EdmEntityType("NS", "Person");
entityType.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32);
EdmTypeDefinition weightType = new EdmTypeDefinition("NS", "Weight", EdmPrimitiveTypeKind.Double);
EdmTypeDefinitionReference weightTypeRef = new EdmTypeDefinitionReference(weightType, false);
entityType.AddStructuralProperty("Weight", weightTypeRef);
EdmTypeDefinition heightType = new EdmTypeDefinition("NS", "Height", EdmPrimitiveTypeKind.Double);
EdmComplexType complexType = new EdmComplexType("NS", "OpenAddress");
EdmComplexTypeReference complexTypeRef = new EdmComplexTypeReference(complexType, true);
EdmTypeDefinition addressType = new EdmTypeDefinition("NS", "Address", EdmPrimitiveTypeKind.String);
EdmTypeDefinitionReference addressTypeRef = new EdmTypeDefinitionReference(addressType, false);
complexType.AddStructuralProperty("CountryRegion", addressTypeRef);
entityType.AddStructuralProperty("Address", complexTypeRef);
model.AddElement(weightType);
model.AddElement(heightType);
model.AddElement(addressType);
model.AddElement(complexType);
model.AddElement(entityType);
EdmEntityContainer container = new EdmEntityContainer("EntityNs", "MyContainer");
EdmEntitySet entitySet = container.AddEntitySet("People", entityType);
model.AddElement(container);
const string payload =
"{" +
"\"@odata.context\":\"http://www.example.com/$metadata#EntityNs.MyContainer.People/$entity\"," +
"\"@odata.id\":\"http://mytest\"," +
"\"Id\":0," +
"\"[email protected]\":\"#Edm.Double\"," +
"\"Weight\":60.5," +
"\"Address\":{\"[email protected]\":\"#Edm.String\",\"CountryRegion\":\"China\"}" +
"}";
List <ODataResource> entries = new List <ODataResource>();
ODataNestedResourceInfo navigationLink = null;
this.ReadEntryPayload(model, payload, entitySet, entityType,
reader =>
{
switch (reader.State)
{
case ODataReaderState.ResourceStart:
entries.Add(reader.Item as ODataResource);
break;
case ODataReaderState.NestedResourceInfoStart:
navigationLink = (ODataNestedResourceInfo)reader.Item;
break;
default:
break;
}
});
Assert.Equal(2, entries.Count);
IList <ODataProperty> propertyList = entries[0].Properties.ToList();
propertyList[1].Name.Should().Be("Weight");
propertyList[1].Value.Should().Be(60.5);
navigationLink.Name.Should().Be("Address");
var address = entries[1];
address.Properties.FirstOrDefault(s => string.Equals(s.Name, "CountryRegion", StringComparison.OrdinalIgnoreCase)).Value.Should().Be("China");
}
public void WriteNavigationPropertyInComplexType()
{
var model = new EdmModel();
var person = new EdmEntityType("DefaultNs", "Person");
var entityId = person.AddStructuralProperty("UserName", EdmCoreModel.Instance.GetString(false));
person.AddKeys(entityId);
var city = new EdmEntityType("DefaultNs", "City");
var cityId = city.AddStructuralProperty("Name", EdmCoreModel.Instance.GetString(false));
city.AddKeys(cityId);
var countryOrRegion = new EdmEntityType("DefaultNs", "CountryOrRegion");
var countryId = countryOrRegion.AddStructuralProperty("Name", EdmCoreModel.Instance.GetString(false));
countryOrRegion.AddKeys(countryId);
var complex = new EdmComplexType("DefaultNs", "Address");
complex.AddStructuralProperty("Id", EdmCoreModel.Instance.GetInt32(false));
var navP = complex.AddUnidirectionalNavigation(
new EdmNavigationPropertyInfo()
{
Name = "City",
Target = city,
TargetMultiplicity = EdmMultiplicity.One,
});
var derivedComplex = new EdmComplexType("DefaultNs", "WorkAddress", complex);
var navP2 = derivedComplex.AddUnidirectionalNavigation(
new EdmNavigationPropertyInfo()
{
Name = "CountryOrRegion",
Target = countryOrRegion,
TargetMultiplicity = EdmMultiplicity.One,
});
person.AddStructuralProperty("HomeAddress", new EdmComplexTypeReference(complex, false));
person.AddStructuralProperty("WorkAddress", new EdmComplexTypeReference(complex, false));
person.AddStructuralProperty("Addresses", new EdmCollectionTypeReference(new EdmCollectionType(new EdmComplexTypeReference(complex, false))));
model.AddElement(person);
model.AddElement(city);
model.AddElement(countryOrRegion);
model.AddElement(complex);
model.AddElement(derivedComplex);
var entityContainer = new EdmEntityContainer("DefaultNs", "Container");
model.AddElement(entityContainer);
EdmEntitySet people = new EdmEntitySet(entityContainer, "People", person);
EdmEntitySet cities = new EdmEntitySet(entityContainer, "City", city);
EdmEntitySet countriesOrRegions = new EdmEntitySet(entityContainer, "CountryOrRegion", countryOrRegion);
people.AddNavigationTarget(navP, cities, new EdmPathExpression("HomeAddress/City"));
people.AddNavigationTarget(navP, cities, new EdmPathExpression("Addresses/City"));
people.AddNavigationTarget(navP2, countriesOrRegions, new EdmPathExpression("WorkAddress/DefaultNs.WorkAddress/CountryOrRegion"));
entityContainer.AddElement(people);
entityContainer.AddElement(cities);
entityContainer.AddElement(countriesOrRegions);
IEnumerable <EdmError> actualErrors = null;
model.Validate(out actualErrors);
Assert.Equal(actualErrors.Count(), 0);
string actual = GetCsdl(model, CsdlTarget.OData);
string expected =
"<?xml version=\"1.0\" encoding=\"utf-16\"?><edmx:Edmx Version=\"4.0\" xmlns:edmx=\"http://docs.oasis-open.org/odata/ns/edmx\">" +
"<edmx:DataServices>" +
"<Schema Namespace=\"DefaultNs\" xmlns=\"http://docs.oasis-open.org/odata/ns/edm\">" +
"<EntityType Name=\"Person\">" +
"<Key><PropertyRef Name=\"UserName\" /></Key>" +
"<Property Name=\"UserName\" Type=\"Edm.String\" Nullable=\"false\" />" +
"<Property Name=\"HomeAddress\" Type=\"DefaultNs.Address\" Nullable=\"false\" />" +
"<Property Name=\"WorkAddress\" Type=\"DefaultNs.Address\" Nullable=\"false\" />" +
"<Property Name=\"Addresses\" Type=\"Collection(DefaultNs.Address)\" Nullable=\"false\" />" +
"</EntityType>" +
"<EntityType Name=\"City\">" +
"<Key><PropertyRef Name=\"Name\" /></Key>" +
"<Property Name=\"Name\" Type=\"Edm.String\" Nullable=\"false\" />" +
"</EntityType>" +
"<EntityType Name=\"CountryOrRegion\">" +
"<Key><PropertyRef Name=\"Name\" /></Key>" +
"<Property Name=\"Name\" Type=\"Edm.String\" Nullable=\"false\" />" +
"</EntityType>" +
"<ComplexType Name=\"Address\">" +
"<Property Name=\"Id\" Type=\"Edm.Int32\" Nullable=\"false\" />" +
"<NavigationProperty Name=\"City\" Type=\"DefaultNs.City\" Nullable=\"false\" />" +
"</ComplexType>" +
"<ComplexType Name=\"WorkAddress\" BaseType=\"DefaultNs.Address\">" +
"<NavigationProperty Name=\"CountryOrRegion\" Type=\"DefaultNs.CountryOrRegion\" Nullable=\"false\" /><" +
"/ComplexType>" +
"<EntityContainer Name=\"Container\">" +
"<EntitySet Name=\"People\" EntityType=\"DefaultNs.Person\">" +
"<NavigationPropertyBinding Path=\"HomeAddress/City\" Target=\"City\" />" +
"<NavigationPropertyBinding Path=\"Addresses/City\" Target=\"City\" />" +
"<NavigationPropertyBinding Path=\"WorkAddress/DefaultNs.WorkAddress/CountryOrRegion\" Target=\"CountryOrRegion\" />" +
"</EntitySet>" +
"<EntitySet Name=\"City\" EntityType=\"DefaultNs.City\" />" +
"<EntitySet Name=\"CountryOrRegion\" EntityType=\"DefaultNs.CountryOrRegion\" />" +
"</EntityContainer></Schema>" +
"</edmx:DataServices>" +
"</edmx:Edmx>";
Assert.Equal(expected, actual);
}
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);
}
private static IEdmModel GetModel()
{
var model = new EdmModel();
var entityType = new EdmEntityType("NS", "EntityType");
var id = entityType.AddStructuralProperty("ID", EdmCoreModel.Instance.GetString(false));
entityType.AddKeys(id);
var derivedEntityType = new EdmEntityType("NS", "DerivedEntityType", entityType);
var containedEntityType = new EdmEntityType("NS", "ContainedEntityType");
var containedId = containedEntityType.AddStructuralProperty("ID", EdmCoreModel.Instance.GetString(false));
containedEntityType.AddKeys(containedId);
var containedNav1 = entityType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo()
{
Name = "ContainedNav1",
Target = containedEntityType,
TargetMultiplicity = EdmMultiplicity.One,
ContainsTarget = true
});
var containedNav2 = entityType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo()
{
Name = "ContainedNav2",
Target = containedEntityType,
TargetMultiplicity = EdmMultiplicity.One,
ContainsTarget = true
});
var navEntityType = new EdmEntityType("NS", "NavEntityType");
var navEntityId = navEntityType.AddStructuralProperty("ID", EdmCoreModel.Instance.GetString(false));
navEntityType.AddKeys(navEntityId);
var nestedNavEntityType = new EdmEntityType("NS", "NestedNavEntityType");
var nestedId = nestedNavEntityType.AddStructuralProperty("NestedId", EdmCoreModel.Instance.GetString(false));
nestedNavEntityType.AddKeys(nestedId);
var nestNav = navEntityType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo()
{
Name = "NavNested",
Target = nestedNavEntityType,
TargetMultiplicity = EdmMultiplicity.One
});
var complex = new EdmComplexType("NS", "ComplexType");
complex.AddStructuralProperty("Prop1", EdmCoreModel.Instance.GetString(false));
complex.AddStructuralProperty("CollectionComplexProp", new EdmCollectionTypeReference(new EdmCollectionType(new EdmComplexTypeReference(complex, false))));
var derivedComplex = new EdmComplexType("NS", "DerivedComplexType", complex);
derivedComplex.AddStructuralProperty("DerivedProp", EdmCoreModel.Instance.GetString(false));
var derivedNav = derivedEntityType.AddUnidirectionalNavigation(
new EdmNavigationPropertyInfo()
{
Name = "NavOnDerived",
Target = navEntityType,
TargetMultiplicity = EdmMultiplicity.One,
});
var complxNavP = complex.AddUnidirectionalNavigation(
new EdmNavigationPropertyInfo()
{
Name = "CollectionOfNavOnComplex",
Target = navEntityType,
TargetMultiplicity = EdmMultiplicity.Many,
});
entityType.AddStructuralProperty("complexProp1", new EdmComplexTypeReference(complex, false));
entityType.AddStructuralProperty("complexProp2", new EdmComplexTypeReference(complex, false));
entityType.AddStructuralProperty("collectionComplex", new EdmCollectionTypeReference(new EdmCollectionType(new EdmComplexTypeReference(complex, false))));
var navOnContained = containedEntityType.AddUnidirectionalNavigation(
new EdmNavigationPropertyInfo()
{
Name = "NavOnContained",
Target = navEntityType,
TargetMultiplicity = EdmMultiplicity.One,
});
var manyNavOnContained = containedEntityType.AddUnidirectionalNavigation(
new EdmNavigationPropertyInfo()
{
Name = "ManyNavOnContained",
Target = navEntityType,
TargetMultiplicity = EdmMultiplicity.Many,
});
model.AddElement(entityType);
model.AddElement(derivedEntityType);
model.AddElement(containedEntityType);
model.AddElement(navEntityType);
model.AddElement(nestedNavEntityType);
model.AddElement(complex);
model.AddElement(derivedComplex);
var entityContainer = new EdmEntityContainer("NS", "Container");
model.AddElement(entityContainer);
var entitySet = new EdmEntitySet(entityContainer, "EntitySet", entityType);
var navEntitySet1 = new EdmEntitySet(entityContainer, "NavEntitySet1", navEntityType);
var navEntitySet2 = new EdmEntitySet(entityContainer, "NavEntitySet2", navEntityType);
var nestNavEntitySet = new EdmEntitySet(entityContainer, "NestedEntitySet", nestedNavEntityType);
navEntitySet1.AddNavigationTarget(nestNav, nestNavEntitySet);
navEntitySet2.AddNavigationTarget(nestNav, nestNavEntitySet);
entitySet.AddNavigationTarget(derivedNav, navEntitySet1, new EdmPathExpression("NS.DerivedEntityType/NavOnDerived"));
entitySet.AddNavigationTarget(complxNavP, navEntitySet1, new EdmPathExpression("complexProp1/CollectionOfNavOnComplex"));
entitySet.AddNavigationTarget(complxNavP, navEntitySet2, new EdmPathExpression("complexProp2/CollectionOfNavOnComplex"));
entitySet.AddNavigationTarget(navOnContained, navEntitySet1, new EdmPathExpression("ContainedNav1/NavOnContained"));
entitySet.AddNavigationTarget(navOnContained, navEntitySet2, new EdmPathExpression("ContainedNav2/NavOnContained"));
entitySet.AddNavigationTarget(manyNavOnContained, navEntitySet1, new EdmPathExpression("ContainedNav1/ManyNavOnContained"));
entitySet.AddNavigationTarget(manyNavOnContained, navEntitySet2, new EdmPathExpression("ContainedNav2/ManyNavOnContained"));
entitySet.AddNavigationTarget(complxNavP, navEntitySet2, new EdmPathExpression("collectionComplex/CollectionOfNavOnComplex"));
entitySet.AddNavigationTarget(complxNavP, navEntitySet1, new EdmPathExpression("collectionComplex/CollectionComplexProp/CollectionOfNavOnComplex"));
entityContainer.AddElement(entitySet);
entityContainer.AddElement(navEntitySet1);
entityContainer.AddElement(navEntitySet2);
entityContainer.AddElement(nestNavEntitySet);
return(model);
}
public IEdmModel GetEdmModel(HttpRequest request, EdmEntityTypeSettings edmEntityTypeSettings, string namespaceName)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
if (edmEntityTypeSettings == null)
{
throw new ArgumentNullException(nameof(edmEntityTypeSettings));
}
if (string.IsNullOrWhiteSpace(namespaceName))
{
throw new ArgumentNullException(nameof(namespaceName));
}
string modelName = edmEntityTypeSettings.RouteName.ToLowerInvariant();
var odataContext = new ODataContext();
EdmModel model = new EdmModel();
EdmEntityContainer container = new EdmEntityContainer(namespaceName, "container");
model.AddElement(container);
var edmEntityType = new EdmEntityType(namespaceName, modelName);
foreach (var property in edmEntityTypeSettings.Properties)
{
if (property.PropertyName.Equals("id", StringComparison.OrdinalIgnoreCase))
{
if (property.IsNullable.HasValue)
{
edmEntityType.AddKeys(edmEntityType.AddStructuralProperty(property.PropertyName, property.GetEdmPrimitiveTypeKind(), property.IsNullable.Value));
}
else
{
edmEntityType.AddKeys(edmEntityType.AddStructuralProperty(property.PropertyName, property.GetEdmPrimitiveTypeKind()));
}
}
else
{
if (property.IsNullable.HasValue)
{
edmEntityType.AddStructuralProperty(property.PropertyName, property.GetEdmPrimitiveTypeKind(), property.IsNullable.Value);
}
else
{
edmEntityType.AddStructuralProperty(property.PropertyName, property.GetEdmPrimitiveTypeKind());
}
}
}
model.AddElement(edmEntityType);
container.AddEntitySet(modelName, edmEntityType);
//Set the context
odataContext.Settings = new List <EdmEntityTypeSettings>
{
edmEntityTypeSettings
};
odataContext.Path = new ODataPath();
odataContext.EdmModel = model;
odataContext.EdmEntityTypeReference = new EdmEntityTypeReference(edmEntityType, true);
odataContext.EdmCollectionType = new EdmCollectionType(odataContext.EdmEntityTypeReference);
odataContext.ActualRouteName = modelName;
request.HttpContext.Items.Add(odataContextKey, odataContext);
return(model);
}
public CustomersModelWithInheritance()
{
EdmModel model = new EdmModel();
// complex type address
EdmComplexType address = new EdmComplexType("NS", "Address");
address.AddStructuralProperty("Street", EdmPrimitiveTypeKind.String);
address.AddStructuralProperty("City", EdmPrimitiveTypeKind.String);
address.AddStructuralProperty("State", EdmPrimitiveTypeKind.String);
address.AddStructuralProperty("ZipCode", EdmPrimitiveTypeKind.String);
address.AddStructuralProperty("Country", EdmPrimitiveTypeKind.String);
model.AddElement(address);
// entity type customer
EdmEntityType customer = new EdmEntityType("NS", "Customer");
customer.AddKeys(customer.AddStructuralProperty("ID", EdmPrimitiveTypeKind.Int32));
customer.AddStructuralProperty("Name", EdmPrimitiveTypeKind.String);
customer.AddStructuralProperty("Address", new EdmComplexTypeReference(address, isNullable: true));
customer.AddStructuralProperty("City", EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.String, true),
defaultValue: null, concurrencyMode: EdmConcurrencyMode.Fixed);
model.AddElement(customer);
// derived entity type special customer
EdmEntityType specialCustomer = new EdmEntityType("NS", "SpecialCustomer", customer);
specialCustomer.AddStructuralProperty("SpecialCustomerProperty", EdmPrimitiveTypeKind.Guid);
model.AddElement(specialCustomer);
// entity type order
EdmEntityType order = new EdmEntityType("NS", "Order");
order.AddKeys(order.AddStructuralProperty("ID", EdmPrimitiveTypeKind.Int32));
order.AddStructuralProperty("Amount", EdmPrimitiveTypeKind.Int32);
model.AddElement(order);
// derived entity type special order
EdmEntityType specialOrder = new EdmEntityType("NS", "SpecialOrder", order);
specialOrder.AddStructuralProperty("SpecialOrderProperty", EdmPrimitiveTypeKind.Guid);
model.AddElement(specialOrder);
// entity sets
EdmEntityContainer container = new EdmEntityContainer("NS", "ModelWithInheritance");
model.AddElement(container);
EdmEntitySet customers = container.AddEntitySet("Customers", customer);
EdmEntitySet orders = container.AddEntitySet("Orders", order);
// actions
EdmFunctionImport upgradeCustomer = container.AddFunctionImport(
"upgrade", returnType: null, entitySet: new EdmEntitySetReferenceExpression(customers), sideEffecting: true, composable: false, bindable: true);
upgradeCustomer.AddParameter("entity", new EdmEntityTypeReference(customer, false));
EdmFunctionImport upgradeSpecialCustomer = container.AddFunctionImport(
"specialUpgrade", returnType: null, entitySet: new EdmEntitySetReferenceExpression(customers), sideEffecting: true, composable: false, bindable: true);
upgradeSpecialCustomer.AddParameter("entity", new EdmEntityTypeReference(specialCustomer, false));
// navigation properties
customers.AddNavigationTarget(
customer.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo
{
Name = "Orders",
TargetMultiplicity = EdmMultiplicity.Many,
Target = order
}),
orders);
orders.AddNavigationTarget(
order.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo
{
Name = "Customer",
TargetMultiplicity = EdmMultiplicity.ZeroOrOne,
Target = customer
}),
customers);
// navigation properties on derived types.
customers.AddNavigationTarget(
specialCustomer.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo
{
Name = "SpecialOrders",
TargetMultiplicity = EdmMultiplicity.Many,
Target = order
}),
orders);
orders.AddNavigationTarget(
specialOrder.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo
{
Name = "SpecialCustomer",
TargetMultiplicity = EdmMultiplicity.ZeroOrOne,
Target = customer
}),
customers);
model.SetAnnotationValue <BindableProcedureFinder>(model, new BindableProcedureFinder(model));
// set properties
Model = model;
Container = container;
Customer = customer;
Order = order;
Address = address;
SpecialCustomer = specialCustomer;
SpecialOrder = specialOrder;
Orders = orders;
Customers = customers;
UpgradeCustomer = upgradeCustomer;
UpgradeSpecialCustomer = upgradeSpecialCustomer;
}
public void UnsignedIntAndTypeDefinitionRoundtripJsonLightIntegrationTest()
{
var model = new EdmModel();
var uint16 = new EdmTypeDefinition("MyNS", "UInt16", EdmPrimitiveTypeKind.Double);
var uint16Ref = new EdmTypeDefinitionReference(uint16, false);
model.AddElement(uint16);
model.SetPrimitiveValueConverter(uint16Ref, UInt16ValueConverter.Instance);
var uint64 = new EdmTypeDefinition("MyNS", "UInt64", EdmPrimitiveTypeKind.String);
var uint64Ref = new EdmTypeDefinitionReference(uint64, false);
model.AddElement(uint64);
model.SetPrimitiveValueConverter(uint64Ref, UInt64ValueConverter.Instance);
var guidType = new EdmTypeDefinition("MyNS", "Guid", EdmPrimitiveTypeKind.Int64);
var guidRef = new EdmTypeDefinitionReference(guidType, true);
model.AddElement(guidType);
var personType = new EdmEntityType("MyNS", "Person");
personType.AddKeys(personType.AddStructuralProperty("ID", uint64Ref));
personType.AddStructuralProperty("Name", EdmPrimitiveTypeKind.String);
personType.AddStructuralProperty("FavoriteNumber", uint16Ref);
personType.AddStructuralProperty("Age", model.GetUInt32("MyNS", true));
personType.AddStructuralProperty("Guid", guidRef);
personType.AddStructuralProperty("Weight", EdmPrimitiveTypeKind.Double);
personType.AddStructuralProperty("Money", EdmPrimitiveTypeKind.Decimal);
model.AddElement(personType);
var container = new EdmEntityContainer("MyNS", "Container");
var peopleSet = container.AddEntitySet("People", personType);
model.AddElement(container);
var stream = new MemoryStream();
IODataResponseMessage message = new InMemoryMessage {
Stream = stream
};
message.StatusCode = 200;
var writerSettings = new ODataMessageWriterSettings();
writerSettings.SetServiceDocumentUri(new Uri("http://host/service"));
var messageWriter = new ODataMessageWriter(message, writerSettings, model);
var entryWriter = messageWriter.CreateODataResourceWriter(peopleSet);
var entry = new ODataResource
{
TypeName = "MyNS.Person",
Properties = new[]
{
new ODataProperty
{
Name = "ID",
Value = UInt64.MaxValue
},
new ODataProperty
{
Name = "Name",
Value = "Foo"
},
new ODataProperty
{
Name = "FavoriteNumber",
Value = (UInt16)250
},
new ODataProperty
{
Name = "Age",
Value = (UInt32)123
},
new ODataProperty
{
Name = "Guid",
Value = Int64.MinValue
},
new ODataProperty
{
Name = "Weight",
Value = 123.45
},
new ODataProperty
{
Name = "Money",
Value = Decimal.MaxValue
}
}
};
entryWriter.WriteStart(entry);
entryWriter.WriteEnd();
entryWriter.Flush();
stream.Position = 0;
StreamReader reader = new StreamReader(stream);
string payload = reader.ReadToEnd();
Assert.Equal("{\"@odata.context\":\"http://host/service/$metadata#People/$entity\",\"ID\":\"18446744073709551615\",\"Name\":\"Foo\",\"FavoriteNumber\":250.0,\"Age\":123,\"Guid\":-9223372036854775808,\"Weight\":123.45,\"Money\":79228162514264337593543950335}", payload);
#if NETCOREAPP1_1
stream = new MemoryStream(Encoding.GetEncoding(0).GetBytes(payload));
#else
stream = new MemoryStream(Encoding.Default.GetBytes(payload));
#endif
message = new InMemoryMessage {
Stream = stream
};
message.StatusCode = 200;
var readerSettings = new ODataMessageReaderSettings();
var messageReader = new ODataMessageReader(message, readerSettings, model);
var entryReader = messageReader.CreateODataResourceReader(peopleSet, personType);
Assert.True(entryReader.Read());
var entryReaded = entryReader.Item as ODataResource;
var propertiesReaded = entryReaded.Properties.ToList();
var propertiesGiven = entry.Properties.ToList();
Assert.Equal(propertiesReaded.Count, propertiesGiven.Count);
for (int i = 0; i < propertiesReaded.Count; ++i)
{
Assert.Equal(propertiesReaded[i].Name, propertiesGiven[i].Name);
Assert.Equal(propertiesReaded[i].Value.GetType(), propertiesGiven[i].Value.GetType());
Assert.Equal(propertiesReaded[i].Value, propertiesGiven[i].Value);
}
}
