private static NavigationSourceConfiguration GetDefaultNavigationSource(EntityTypeConfiguration targetEntityType,
ODataModelBuilder model, bool isSingleton)
{
if (targetEntityType == null)
{
return null;
}
NavigationSourceConfiguration[] matchingNavigationSources = null;
if (isSingleton)
{
matchingNavigationSources = model.Singletons.Where(e => e.EntityType == targetEntityType).ToArray();
}
else
{
matchingNavigationSources = model.EntitySets.Where(e => e.EntityType == targetEntityType).ToArray();
}
if (matchingNavigationSources.Length > 1)
{
return null;
}
else if (matchingNavigationSources.Length == 1)
{
return matchingNavigationSources[0];
}
else
{
// default navigation source is the same as the default navigation source for the base type.
return GetDefaultNavigationSource(targetEntityType.BaseType as EntityTypeConfiguration,
model, isSingleton);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="EnumTypeConfiguration"/> class.
/// </summary>
public EnumTypeConfiguration(ODataModelBuilder builder, Type clrType)
{
if (builder == null)
{
throw Error.ArgumentNull("builder");
}
if (clrType == null)
{
throw Error.ArgumentNull("clrType");
}
if (!clrType.IsEnum)
{
throw Error.Argument("clrType", SRResources.TypeCannotBeEnum, clrType.FullName);
}
ClrType = clrType;
IsFlags = clrType.GetCustomAttributes(typeof(FlagsAttribute), false).Any();
UnderlyingType = Enum.GetUnderlyingType(clrType);
ModelBuilder = builder;
_name = clrType.EdmName();
_namespace = clrType.Namespace ?? DefaultNamespace;
ExplicitMembers = new Dictionary<Enum, EnumMemberConfiguration>();
RemovedMembers = new List<Enum>();
}
public void ConstructorEmptyRawValueThrows()
{
var model = new ODataModelBuilder().Add_Customer_EntityType().Add_Customers_EntitySet().GetEdmModel();
Assert.Throws<ArgumentException>(() =>
new OrderByQueryOption(string.Empty, new ODataQueryContext(model, typeof(Customer))));
}
public void AssociationSetDiscoveryConvention_AddsBindingForBaseAndDerivedNavigationProperties()
{
// Arrange
ODataModelBuilder builder = new ODataModelBuilder();
EntityTypeConfiguration vehicle = builder.AddEntity(typeof(Vehicle));
EntityTypeConfiguration car = builder.AddEntity(typeof(Car)).DerivesFrom(vehicle);
NavigationPropertyConfiguration carNavigationProperty = car.AddNavigationProperty(typeof(Car).GetProperty("Manufacturer"), EdmMultiplicity.ZeroOrOne);
EntityTypeConfiguration motorcycle = builder.AddEntity(typeof(Motorcycle)).DerivesFrom(vehicle);
NavigationPropertyConfiguration motorcycleNavigationProperty = motorcycle.AddNavigationProperty(typeof(Motorcycle).GetProperty("Manufacturer"), EdmMultiplicity.ZeroOrOne);
EntityTypeConfiguration manufacturer = builder.AddEntity(typeof(Manufacturer));
EntityTypeConfiguration motorcycleManufacturer = builder.AddEntity(typeof(MotorcycleManufacturer)).DerivesFrom(manufacturer);
EntityTypeConfiguration carManufacturer = builder.AddEntity(typeof(CarManufacturer)).DerivesFrom(manufacturer);
EntitySetConfiguration manufacturers = builder.AddEntitySet("manufacturers", manufacturer);
Mock<EntitySetConfiguration> entitySet = new Mock<EntitySetConfiguration>(MockBehavior.Strict);
entitySet.Setup(v => v.EntityType).Returns(vehicle);
entitySet.Setup(v => v.AddBinding(motorcycleNavigationProperty, manufacturers)).Returns<NavigationPropertyConfiguration>(null);
entitySet.Setup(v => v.AddBinding(carNavigationProperty, manufacturers)).Returns<NavigationPropertyConfiguration>(null);
// Act
_convention.Apply(entitySet.Object, builder);
// Assert
entitySet.VerifyAll();
}
private static IEdmModel GetEdmModel()
{
ODataModelBuilder builder = new ODataModelBuilder();
// Configure LimitedEntity
EntitySetConfiguration<LimitedEntity> limitedEntities = builder.EntitySet<LimitedEntity>("LimitedEntities");
limitedEntities.EntityType.HasKey(p => p.Id);
limitedEntities.EntityType.ComplexProperty(c => c.ComplexProperty);
limitedEntities.EntityType.CollectionProperty(c => c.ComplexCollectionProperty).IsNotCountable();
limitedEntities.EntityType.HasMany(l => l.EntityCollectionProperty).IsNotCountable();
limitedEntities.EntityType.CollectionProperty(cp => cp.Integers).IsNotCountable();
// Configure LimitedRelatedEntity
EntitySetConfiguration<LimitedRelatedEntity> limitedRelatedEntities =
builder.EntitySet<LimitedRelatedEntity>("LimitedRelatedEntities");
limitedRelatedEntities.EntityType.HasKey(p => p.Id);
limitedRelatedEntities.EntityType.CollectionProperty(p => p.ComplexCollectionProperty).IsNotCountable();
// Configure Complextype
ComplexTypeConfiguration<LimitedComplex> complexType = builder.ComplexType<LimitedComplex>();
complexType.CollectionProperty(p => p.Strings).IsNotCountable();
complexType.Property(p => p.Value);
complexType.CollectionProperty(p => p.SimpleEnums).IsNotCountable();
// Configure EnumType
EnumTypeConfiguration<SimpleEnum> enumType = builder.EnumType<SimpleEnum>();
enumType.Member(SimpleEnum.First);
enumType.Member(SimpleEnum.Second);
enumType.Member(SimpleEnum.Third);
enumType.Member(SimpleEnum.Fourth);
return builder.GetEdmModel();
}
public void CreateEnumTypeWithFlags()
{
// Arrange
var builder = new ODataModelBuilder();
var color = builder.EnumType<Color>();
color.Member(Color.Red);
color.Member(Color.Green);
color.Member(Color.Blue);
// Act
var model = builder.GetEdmModel();
var colorType = model.SchemaElements.OfType<IEdmEnumType>().Single();
// Assert
Assert.Equal("Color", colorType.Name);
Assert.True(colorType.IsFlags);
Assert.Equal(3, colorType.Members.Count());
Assert.Equal("Edm.Int32", colorType.UnderlyingType.FullName());
var redMember = colorType.Members.SingleOrDefault(m => m.Name == "Red");
var greenMember = colorType.Members.SingleOrDefault(m => m.Name == "Green");
var blueMember = colorType.Members.SingleOrDefault(m => m.Name == "Blue");
Assert.NotNull(redMember);
Assert.NotNull(greenMember);
Assert.NotNull(blueMember);
}
protected NavigationSourceConfiguration(ODataModelBuilder modelBuilder, EntityTypeConfiguration entityType, string name)
{
if (modelBuilder == null)
{
throw Error.ArgumentNull("modelBuilder");
}
if (entityType == null)
{
throw Error.ArgumentNull("entityType");
}
if (String.IsNullOrEmpty(name))
{
throw Error.ArgumentNullOrEmpty("name");
}
_modelBuilder = modelBuilder;
Name = name;
EntityType = entityType;
ClrType = entityType.ClrType;
_url = Name;
_editLinkBuilder = null;
_readLinkBuilder = null;
_navigationPropertyLinkBuilders = new Dictionary<NavigationPropertyConfiguration, NavigationLinkBuilder>();
_navigationPropertyBindings = new Dictionary<NavigationPropertyConfiguration, NavigationPropertyBindingConfiguration>();
}
protected StructuralTypeConfiguration(ODataModelBuilder modelBuilder, Type clrType)
{
ClrType = clrType;
ModelBuilder = modelBuilder;
ExplicitProperties = new Dictionary<PropertyInfo, PropertyConfiguration>();
IgnoredProperties = new List<PropertyInfo>();
}
public void Apply(ProcedureConfiguration configuration, ODataModelBuilder model)
{
FunctionConfiguration function = configuration as FunctionConfiguration;
if (function == null || !function.IsBindable)
{
return;
}
// You only need to create links for bindable functions that bind to a single entity.
if (function.BindingParameter.TypeConfiguration.Kind == EdmTypeKind.Entity && function.GetFunctionLink() == null)
{
string bindingParamterType = function.BindingParameter.TypeConfiguration.FullName;
function.HasFunctionLink(entityContext =>
entityContext.GenerateFunctionLink(bindingParamterType, function.FullyQualifiedName, function.Parameters.Select(p => p.Name)),
followsConventions: true);
}
else if (function.BindingParameter.TypeConfiguration.Kind == EdmTypeKind.Collection && function.GetFeedFunctionLink() == null)
{
if (((CollectionTypeConfiguration)function.BindingParameter.TypeConfiguration).ElementType.Kind ==
EdmTypeKind.Entity)
{
string bindingParamterType = function.BindingParameter.TypeConfiguration.FullName;
function.HasFeedFunctionLink(
feedContext =>
feedContext.GenerateFunctionLink(bindingParamterType, function.FullyQualifiedName, function.Parameters.Select(p => p.Name)),
followsConventions: true);
}
}
}
private static Dictionary<string, EdmEntitySet> AddEntitySets(this EdmModel model, ODataModelBuilder builder, EdmEntityContainer container, Dictionary<Type, IEdmStructuredType> edmTypeMap)
{
IEnumerable<EntitySetConfiguration> configurations = builder.EntitySets;
// build the entitysets and their annotations
IEnumerable<Tuple<EdmEntitySet, EntitySetConfiguration>> entitySets = AddEntitySets(configurations, container, edmTypeMap);
var entitySetAndAnnotations = entitySets.Select(e => new
{
EntitySet = e.Item1,
Configuration = e.Item2,
Annotations = new
{
LinkBuilder = new EntitySetLinkBuilderAnnotation(e.Item2),
Url = new EntitySetUrlAnnotation { Url = e.Item2.GetUrl() }
}
}).ToArray();
// index the entitySets by name
Dictionary<string, EdmEntitySet> edmEntitySetMap = entitySetAndAnnotations.ToDictionary(e => e.EntitySet.Name, e => e.EntitySet);
// apply the annotations
foreach (var iter in entitySetAndAnnotations)
{
EdmEntitySet entitySet = iter.EntitySet;
model.SetAnnotationValue<EntitySetUrlAnnotation>(entitySet, iter.Annotations.Url);
model.SetAnnotationValue<IEntitySetLinkBuilder>(entitySet, iter.Annotations.LinkBuilder);
AddNavigationBindings(iter.Configuration, iter.EntitySet, iter.Annotations.LinkBuilder, builder, edmTypeMap, edmEntitySetMap);
}
return edmEntitySetMap;
}
public static IEdmModel GetEdmModel()
{
if (_model == null)
{
ODataModelBuilder model = new ODataModelBuilder();
var people = model.EntitySet<FormatterPerson>("People");
people.HasFeedSelfLink(context => new Uri(context.Url.ODataLink(new EntitySetPathSegment(
context.EntitySet))));
people.HasIdLink(context =>
{
return context.Url.ODataLink(
new EntitySetPathSegment(context.EntitySet),
new KeyValuePathSegment(context.GetPropertyValue("PerId").ToString()));
},
followsConventions: false);
var person = people.EntityType;
person.HasKey(p => p.PerId);
person.Property(p => p.Age);
person.Property(p => p.MyGuid);
person.Property(p => p.Name);
person.ComplexProperty<FormatterOrder>(p => p.Order);
var order = model.ComplexType<FormatterOrder>();
order.Property(o => o.OrderAmount);
order.Property(o => o.OrderName);
_model = model.GetEdmModel();
}
return _model;
}
public void ConstructorNullRawValueThrows()
{
var model = new ODataModelBuilder().Add_Customer_EntityType().Add_Customers_EntitySet().GetEdmModel();
Assert.Throws<ArgumentException>(() =>
new SkipQueryOption(null, new ODataQueryContext(model, typeof(Customer), "Customers")));
}
public static IEdmModel BuildEdmModel(ODataModelBuilder builder)
{
if (builder == null)
{
throw Error.ArgumentNull("builder");
}
EdmModel model = new EdmModel();
EdmEntityContainer container = new EdmEntityContainer(builder.Namespace, builder.ContainerName);
// add types and sets, building an index on the way.
Dictionary<Type, IEdmStructuredType> edmTypeMap = model.AddTypes(builder.StructuralTypes);
Dictionary<string, EdmEntitySet> edmEntitySetMap = model.AddEntitySets(builder, container, edmTypeMap);
// add procedures
model.AddProcedures(builder.Procedures, container, edmTypeMap, edmEntitySetMap);
// finish up
model.AddElement(container);
// build the map from IEdmEntityType to IEdmFunctionImport
model.SetAnnotationValue<BindableProcedureFinder>(model, new BindableProcedureFinder(model));
return model;
}
public void CanCreateEntityWithCollectionProperties()
{
var builder = new ODataModelBuilder();
var customer = builder.Entity<Customer>();
customer.HasKey(c => c.CustomerId);
customer.CollectionProperty(c => c.Aliases);
customer.CollectionProperty(c => c.Addresses);
var aliasesProperty = customer.Properties.OfType<CollectionPropertyConfiguration>().SingleOrDefault(p => p.Name == "Aliases");
var addressesProperty = customer.Properties.OfType<CollectionPropertyConfiguration>().SingleOrDefault(p => p.Name == "Addresses");
Assert.Equal(3, customer.Properties.Count());
Assert.Equal(2, customer.Properties.OfType<CollectionPropertyConfiguration>().Count());
Assert.NotNull(aliasesProperty);
Assert.Equal(typeof(string), aliasesProperty.ElementType);
Assert.NotNull(addressesProperty);
Assert.Equal(typeof(Address), addressesProperty.ElementType);
Assert.Equal(2, builder.StructuralTypes.Count());
var addressType = builder.StructuralTypes.Skip(1).FirstOrDefault();
Assert.NotNull(addressType);
Assert.Equal(EdmTypeKind.Complex, addressType.Kind);
Assert.Equal(typeof(Address).FullName, addressType.FullName);
var model = builder.GetServiceModel();
var edmCustomerType = model.FindType(typeof(Customer).FullName) as IEdmEntityType;
var edmAddressType = model.FindType(typeof(Address).FullName) as IEdmComplexType;
}
public void CanCreateFunctionWithNoArguments()
{
// Arrange
// Act
ODataModelBuilder builder = new ODataModelBuilder();
builder.Namespace = "MyNamespace";
builder.ContainerName = "MyContainer";
FunctionConfiguration function = builder.Function("Format");
// Assert
Assert.Equal("Format", function.Name);
Assert.Equal(ProcedureKind.Function, function.Kind);
Assert.NotNull(function.Parameters);
Assert.Empty(function.Parameters);
Assert.Null(function.ReturnType);
Assert.False(function.IsSideEffecting);
Assert.False(function.IsComposable);
Assert.False(function.IsBindable);
Assert.False(function.SupportedInFilter);
Assert.False(function.SupportedInOrderBy);
Assert.Equal("MyContainer.Format", function.ContainerQualifiedName);
Assert.Equal("MyContainer.Format", function.FullName);
Assert.Equal("MyNamespace.MyContainer.Format", function.FullyQualifiedName);
Assert.NotNull(builder.Procedures);
Assert.Equal(1, builder.Procedures.Count());
}
public override void Apply(EntityTypeConfiguration entity, ODataModelBuilder model)
{
if (entity.IsAbstract == null)
{
entity.IsAbstract = entity.ClrType.IsAbstract;
}
}
public void CreateEntityTypeWithRelationship()
{
var builder = new ODataModelBuilder().Add_Customer_EntityType().Add_Order_EntityType().Add_OrderCustomer_Relationship();
var model = builder.GetServiceModel();
var orderType = model.SchemaElements.OfType<IEdmEntityType>().SingleOrDefault(t => t.Name == "Order");
Assert.NotNull(orderType);
Assert.Equal("Order", orderType.Name);
Assert.Equal(typeof(Order).Namespace, orderType.Namespace);
Assert.Equal("OrderId", orderType.DeclaredKey.Single().Name);
Assert.Equal(5, orderType.DeclaredProperties.Count());
Assert.Equal(1, orderType.NavigationProperties().Count());
var deliveryDateProperty = orderType.DeclaredProperties.Single(dp => dp.Name == "DeliveryDate");
Assert.NotNull(deliveryDateProperty);
Assert.True(deliveryDateProperty.Type.IsNullable);
Assert.Equal("Customer", orderType.NavigationProperties().First().Name);
Assert.Equal("Customer", orderType.NavigationProperties().First().ToEntityType().Name);
var customerType = model.SchemaElements.OfType<IEdmEntityType>().SingleOrDefault(t => t.Name == "Customer");
Assert.NotNull(customerType);
Assert.Equal("Customer", customerType.Name);
Assert.Equal(typeof(Customer).Namespace, customerType.Namespace);
Assert.Equal("CustomerId", customerType.DeclaredKey.Single().Name);
Assert.Equal(5, customerType.DeclaredProperties.Count());
}
public void CanCreateActionWithNoArguments()
{
// Arrange
// Act
ODataModelBuilder builder = new ODataModelBuilder();
builder.Namespace = "MyNamespace";
builder.ContainerName = "MyContainer";
ActionConfiguration action = builder.Action("Format");
ActionConfiguration actionII = builder.Action("FormatII");
actionII.Namespace = "MyNamespaceII";
// Assert
Assert.Equal("Format", action.Name);
Assert.Equal(ProcedureKind.Action, action.Kind);
Assert.NotNull(action.Parameters);
Assert.Empty(action.Parameters);
Assert.Null(action.ReturnType);
Assert.True(action.IsSideEffecting);
Assert.False(action.IsComposable);
Assert.False(action.IsBindable);
Assert.Equal("MyNamespace", action.Namespace);
Assert.Equal("MyNamespace.Format", action.FullyQualifiedName);
Assert.Equal("MyNamespaceII", actionII.Namespace);
Assert.Equal("MyNamespaceII.FormatII", actionII.FullyQualifiedName);
Assert.NotNull(builder.Procedures);
Assert.Equal(2, builder.Procedures.Count());
}
public static IEdmModel GetEdmModel()
{
if (_model == null)
{
ODataModelBuilder model = new ODataModelBuilder();
var people = model.EntitySet<FormatterPerson>("People");
people.HasIdLink(context => context.UrlHelper.Link(ODataRouteNames.GetById, new { Id = (context.EntityInstance as FormatterPerson).PerId }));
people.HasEditLink(context => new Uri(context.UrlHelper.Link(ODataRouteNames.GetById, new { Id = (context.EntityInstance as FormatterPerson).PerId })));
people.HasReadLink(context => new Uri(context.UrlHelper.Link(ODataRouteNames.GetById, new { Id = (context.EntityInstance as FormatterPerson).PerId })));
var person = people.EntityType;
person.HasKey(p => p.PerId);
person.Property(p => p.Age);
person.Property(p => p.MyGuid);
person.Property(p => p.Name);
person.ComplexProperty<FormatterOrder>(p => p.Order);
var order = model.ComplexType<FormatterOrder>();
order.Property(o => o.OrderAmount);
order.Property(o => o.OrderName);
_model = model.GetEdmModel();
}
return _model;
}
public void CreateQueryOptions_SetsContextProperties_WithModelAndPath()
{
// Arrange
ApiController controller = new Mock<ApiController>().Object;
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/Customers");
controller.Configuration = new HttpConfiguration();
ODataModelBuilder odataModel = new ODataModelBuilder();
string setName = typeof(Customer).Name;
odataModel.EntityType<Customer>().HasKey(c => c.Id);
odataModel.EntitySet<Customer>(setName);
IEdmModel model = odataModel.GetEdmModel();
IEdmEntitySet entitySet = model.EntityContainer.FindEntitySet(setName);
request.ODataProperties().Model = model;
request.ODataProperties().Path = new ODataPath(new EntitySetPathSegment(entitySet));
controller.Request = request;
// Act
ODataQueryOptions<Customer> queryOptions =
EntitySetControllerHelpers.CreateQueryOptions<Customer>(controller);
// Assert
Assert.Same(model, queryOptions.Context.Model);
Assert.Same(entitySet, queryOptions.Context.NavigationSource);
Assert.Same(typeof(Customer), queryOptions.Context.ElementClrType);
}
public static IEdmModel GetExplicitModel()
{
ODataModelBuilder builder = new ODataModelBuilder();
var customerType = builder.EntityType<DCustomer>().HasKey(c => c.Id);
customerType.Property(c => c.DateTime);
customerType.Property(c => c.Offset);
customerType.Property(c => c.Date);
customerType.Property(c => c.TimeOfDay);
customerType.Property(c => c.NullableDateTime);
customerType.Property(c => c.NullableOffset);
customerType.Property(c => c.NullableDate);
customerType.Property(c => c.NullableTimeOfDay);
customerType.CollectionProperty(c => c.DateTimes);
customerType.CollectionProperty(c => c.Offsets);
customerType.CollectionProperty(c => c.Dates);
customerType.CollectionProperty(c => c.TimeOfDays);
customerType.CollectionProperty(c => c.NullableDateTimes);
customerType.CollectionProperty(c => c.NullableOffsets);
customerType.CollectionProperty(c => c.NullableDates);
customerType.CollectionProperty(c => c.NullableTimeOfDays);
var customers = builder.EntitySet<DCustomer>("DCustomers");
customers.HasIdLink(link, true);
customers.HasEditLink(link, true);
BuildFunctions(builder);
BuildActions(builder);
return builder.GetEdmModel();
}
public void CanUseRelativeLinks()
{
var builder = new ODataModelBuilder()
.Add_Customer_EntityType()
.Add_Order_EntityType()
.Add_CustomerOrders_Relationship()
.Add_Customers_EntitySet()
.Add_Orders_EntitySet()
.Add_CustomerOrders_Binding();
var customersSet = builder.EntitySet<Customer>("Customers");
customersSet.HasEditLink(o => new Uri(string.Format("Customers({0})", o.EntityInstance.CustomerId), UriKind.Relative));
customersSet.FindBinding("Orders").HasLinkFactory(o => string.Format("Orders/ByCustomerId/{0}", ((Customer)o.EntityInstance).CustomerId));
var model = builder.GetEdmModel();
var container = model.FindDeclaredEntityContainer("Container");
var customerEdmEntitySet = container.FindEntitySet("Customers");
// TODO: Fix later, need to add a reference
//var entityContext = new EntityInstanceContext<Customer>(model, customerEdmEntitySet, (IEdmEntityType)customerEdmEntitySet.ElementType, null, new Customer { CustomerId = 24 });
//Assert.Equal("Customers", customersSet.GetUrl());
///Assert.Equal("Customers(24)", customersSet.GetEditLink(entityContext).ToString());
//Assert.Equal("Orders/ByCustomerId/24", customersSet.FindBinding("Orders").GetLink(entityContext));
}
public void NonbindingParameterConfigurationSupportsParameterTypeAs(Type type, bool isNullable)
{
// Arrange
ODataModelBuilder builder = new ODataModelBuilder();
builder.EntityType<Customer>();
builder.ComplexType<Address>();
builder.EnumType<Color>();
// Act
Type underlyingType = TypeHelper.GetUnderlyingTypeOrSelf(type);
IEdmTypeConfiguration edmTypeConfiguration = builder.GetTypeConfigurationOrNull(type);
if (underlyingType.IsEnum)
{
edmTypeConfiguration = builder.GetTypeConfigurationOrNull(underlyingType);
if (edmTypeConfiguration != null && isNullable)
{
edmTypeConfiguration = ((EnumTypeConfiguration)edmTypeConfiguration).GetNullableEnumTypeConfiguration();
}
}
NonbindingParameterConfiguration parameter = new NonbindingParameterConfiguration("name",
edmTypeConfiguration);
// Assert
Assert.Equal(isNullable, parameter.OptionalParameter);
}
public void Apply(IEntitySetConfiguration configuration, ODataModelBuilder model)
{
if (configuration == null)
{
throw Error.ArgumentNull("configuration");
}
// We only need to configure the EditLink by convention, ReadLink and IdLink both delegate to EditLink
if (configuration.GetEditLink() == null)
{
configuration.HasEditLink(entityContext =>
{
string routeName = SelfRouteName ?? ODataRouteNames.GetById;
string editlink = entityContext.UrlHelper.Link(
routeName,
new
{
controller = configuration.Name,
id = ConventionsHelpers.GetEntityKeyValue(entityContext, configuration.EntityType)
});
if (editlink == null)
{
throw Error.InvalidOperation(SRResources.GetByIdRouteMissingOrIncorrect, routeName);
}
return new Uri(editlink);
});
}
}
public static IEdmModel GetExplicitModel(string singletonName)
{
ODataModelBuilder builder = new ODataModelBuilder();
// Define EntityType of Partner
var partner = builder.EntityType<Partner>();
partner.HasKey(p => p.ID);
partner.Property(p => p.Name);
var partnerCompany = partner.HasRequired(p => p.Company);
// Define Enum Type
var category = builder.EnumType<CompanyCategory>();
category.Member(CompanyCategory.IT);
category.Member(CompanyCategory.Communication);
category.Member(CompanyCategory.Electronics);
category.Member(CompanyCategory.Others);
// Define EntityType of Company
var company = builder.EntityType<Company>();
company.HasKey(p => p.ID);
company.Property(p => p.Name);
company.Property(p => p.Revenue);
company.EnumProperty(p => p.Category);
var companyPartners = company.HasMany(p => p.Partners);
companyPartners.IsNotCountable();
var companyBranches = company.CollectionProperty(p => p.Branches);
// Define Complex Type: Office
var office = builder.ComplexType<Office>();
office.Property(p => p.City);
office.Property(p => p.Address);
// Define Derived Type: SubCompany
var subCompany = builder.EntityType<SubCompany>();
subCompany.DerivesFrom<Company>();
subCompany.Property(p => p.Location);
subCompany.Property(p => p.Description);
subCompany.ComplexProperty(p => p.Office);
builder.Namespace = typeof(Partner).Namespace;
// Define PartnerSet and Company(singleton)
EntitySetConfiguration<Partner> partnersConfiguration = builder.EntitySet<Partner>("Partners");
partnersConfiguration.HasIdLink(c=>c.GenerateSelfLink(false), true);
partnersConfiguration.HasSingletonBinding(c => c.Company, singletonName);
Func<EntityInstanceContext<Partner>, IEdmNavigationProperty, Uri> link = (eic, np) => eic.GenerateNavigationPropertyLink(np, false);
partnersConfiguration.HasNavigationPropertyLink(partnerCompany, link, true);
partnersConfiguration.EntityType.Collection.Action("ResetDataSource");
SingletonConfiguration<Company> companyConfiguration = builder.Singleton<Company>(singletonName);
companyConfiguration.HasIdLink(c => c.GenerateSelfLink(false), true);
companyConfiguration.HasManyBinding(c => c.Partners, "Partners");
Func<EntityInstanceContext<Company>, IEdmNavigationProperty, Uri> linkFactory = (eic, np) => eic.GenerateNavigationPropertyLink(np, false);
companyConfiguration.HasNavigationPropertyLink(companyPartners, linkFactory, true);
companyConfiguration.EntityType.Action("ResetDataSource");
companyConfiguration.EntityType.Function("GetPartnersCount").Returns<int>();
return builder.GetEdmModel();
}
public EntitySetConfiguration(ODataModelBuilder modelBuilder, EntityTypeConfiguration entityType, string name)
{
if (modelBuilder == null)
{
throw Error.ArgumentNull("modelBuilder");
}
if (entityType == null)
{
throw Error.ArgumentNull("entityType");
}
if (name == null)
{
throw Error.ArgumentNull("name");
}
_modelBuilder = modelBuilder;
Name = name;
EntityType = entityType;
ClrType = entityType.ClrType;
_url = Name;
_editLinkFactory = null;
_readLinkFactory = null;
_navigationPropertyLinkBuilders = new Dictionary<NavigationPropertyConfiguration, Func<EntityInstanceContext, IEdmNavigationProperty, Uri>>();
_entitySetBindings = new Dictionary<NavigationPropertyConfiguration, NavigationPropertyBinding>();
}
public void Apply(EntitySetConfiguration configuration, ODataModelBuilder model)
{
if (configuration == null)
{
throw Error.ArgumentNull("configuration");
}
// generate links without cast for declared and inherited navigation properties
foreach (EntityTypeConfiguration entity in configuration.EntityType.ThisAndBaseTypes())
{
foreach (NavigationPropertyConfiguration property in entity.NavigationProperties)
{
if (configuration.GetNavigationPropertyLink(property) == null)
{
configuration.HasNavigationPropertyLink(
property,
(entityContext, navigationProperty) => GenerateNavigationPropertyLink(entityContext, navigationProperty, configuration, includeCast: false));
}
}
}
// generate links with cast for navigation properties in derived types.
foreach (EntityTypeConfiguration entity in model.DerivedTypes(configuration.EntityType))
{
foreach (NavigationPropertyConfiguration property in entity.NavigationProperties)
{
if (configuration.GetNavigationPropertyLink(property) == null)
{
configuration.HasNavigationPropertyLink(
property,
(entityContext, navigationProperty) => GenerateNavigationPropertyLink(entityContext, navigationProperty, configuration, includeCast: true));
}
}
}
}
public void Apply_SingleForeignKeyOnForeignKeyProperty_Works()
{
// Arrange
Type dependentType = typeof(SingleDependentEntity2);
ODataModelBuilder builder = new ODataModelBuilder();
builder.Entity<PrincipalEntity>().HasKey(p => p.PrincipalIntId);
EntityTypeConfiguration dependentEntity = builder.AddEntity(dependentType);
PropertyInfo expectPropertyInfo = dependentType.GetProperty("PrincipalId");
PrimitivePropertyConfiguration primitiveProperty = dependentEntity.AddProperty(expectPropertyInfo);
PropertyInfo propertyInfo = dependentType.GetProperty("Principal");
NavigationPropertyConfiguration navigation = dependentEntity.AddNavigationProperty(propertyInfo,
EdmMultiplicity.ZeroOrOne);
navigation.AddedExplicitly = false;
// Act
new ForeignKeyAttributeConvention().Apply(primitiveProperty, dependentEntity);
// Assert
PropertyInfo actualPropertyInfo = Assert.Single(navigation.DependentProperties);
Assert.Same(expectPropertyInfo, actualPropertyInfo);
Assert.Equal("PrincipalIntId", Assert.Single(navigation.PrincipalProperties).Name);
Assert.False(primitiveProperty.OptionalProperty);
}
public void Apply_MultiForeignKeysOnNavigationProperty_Works()
{
// Arrange
Type dependentType = typeof(MultiDependentEntity);
ODataModelBuilder builder = new ODataModelBuilder();
builder.Entity<PrincipalEntity>().HasKey(p => new { p.PrincipalIntId, p.PrincipalStringId });
EntityTypeConfiguration dependentEntity = builder.AddEntity(dependentType);
PropertyInfo expectPropertyInfo1 = dependentType.GetProperty("PrincipalId1");
dependentEntity.AddProperty(expectPropertyInfo1);
PropertyInfo expectPropertyInfo2 = dependentType.GetProperty("PrincipalId2");
dependentEntity.AddProperty(expectPropertyInfo2);
PropertyInfo propertyInfo = typeof(MultiDependentEntity).GetProperty("Principal");
NavigationPropertyConfiguration navigation = dependentEntity.AddNavigationProperty(propertyInfo,
EdmMultiplicity.One);
navigation.AddedExplicitly = false;
// Act
new ForeignKeyAttributeConvention().Apply(navigation, dependentEntity);
// Assert
Assert.Equal(2, navigation.DependentProperties.Count());
Assert.Same(expectPropertyInfo1, navigation.DependentProperties.First());
Assert.Same(expectPropertyInfo2, navigation.DependentProperties.Last());
Assert.Equal(2, navigation.PrincipalProperties.Count());
Assert.Equal("PrincipalIntId", navigation.PrincipalProperties.First().Name);
Assert.Equal("PrincipalStringId", navigation.PrincipalProperties.Last().Name);
}
public void Apply_KeyNameConventions_Works()
{
// Arrange
ODataModelBuilder builder = new ODataModelBuilder();
EntityTypeConfiguration principalEntity = builder.AddEntity(typeof(DiscoveryPrincipalEntity));
PropertyInfo propertyInfo = typeof(DiscoveryPrincipalEntity).GetProperty("DiscoveryPrincipalEntityId");
principalEntity.HasKey(propertyInfo);
EntityTypeConfiguration dependentEntity = builder.AddEntity(typeof(DiscoveryDependentEntity));
PropertyInfo expectPropertyInfo = typeof(DiscoveryDependentEntity).GetProperty("DiscoveryPrincipalEntityId");
dependentEntity.AddProperty(expectPropertyInfo);
PropertyInfo navigationPropertyInfo = typeof(DiscoveryDependentEntity).GetProperty("Principal");
NavigationPropertyConfiguration navigation = dependentEntity.AddNavigationProperty(navigationPropertyInfo,
EdmMultiplicity.One);
navigation.AddedExplicitly = false;
// Act
new ForeignKeyDiscoveryConvention().Apply(navigation, dependentEntity);
// Assert
PropertyInfo actualPropertyInfo = Assert.Single(navigation.DependentProperties);
Assert.Same(expectPropertyInfo, actualPropertyInfo);
PropertyInfo principalProperty = Assert.Single(navigation.PrincipalProperties);
Assert.Equal("DiscoveryPrincipalEntityId", principalProperty.Name);
}
// Singleton -> Singleton
public static ODataModelBuilder Add_MicrosoftCEO_Binding(this ODataModelBuilder builder)
{
builder.Singleton <Company>("OsCorp").HasSingletonBinding(c => c.CEO, "CEO");
return(builder);
}
// Adds a Customer EntitySet with no key properties
public static ODataModelBuilder Add_Customers_No_Keys_EntitySet(this ODataModelBuilder builder)
{
builder.Add_Customer_No_Keys_EntityType().EntitySet <Customer>("Customers");
return(builder);
}
public static ODataModelBuilder Add_Orders_EntitySet(this ODataModelBuilder builder)
{
builder.EntitySet <Order>("Orders");
return(builder);
}
// Adds a Customer EntitySet but allows caller to configure keys
public static ODataModelBuilder Add_Customers_With_Keys_EntitySet <TKey>(this ODataModelBuilder builder, Expression <Func <Customer, TKey> > keyDefinitionExpression)
{
builder.Add_Customer_With_Keys_EntityType(keyDefinitionExpression).EntitySet <Customer>("Customers");
return(builder);
}
public static ODataModelBuilder Add_Customers_Singleton(this ODataModelBuilder builder)
{
builder.Add_Customer_EntityType().Singleton <Customer>("VipCustomer");
return(builder);
}
public static ODataModelBuilder Add_OrderCustomer_Relationship(this ODataModelBuilder builder)
{
builder.EntityType <Order>().HasRequired(o => o.Customer);
return(builder);
}
public static ODataModelBuilder Add_CustomerCompany_Relationship(this ODataModelBuilder builder)
{
builder.EntityType <Customer>().HasOptional(c => c.Company);
return(builder);
}
public static ODataModelBuilder Add_CustomerOrders_Relationship(this ODataModelBuilder builder)
{
builder.EntityType <Customer>().HasMany(c => c.Orders);
return(builder);
}
// EntitySet -> Singleton
public static ODataModelBuilder Add_CompaniesCEO_Binding(this ODataModelBuilder builder)
{
builder.EntitySet <Company>("Companies").HasSingletonBinding(c => c.CEO, "CEO");
return(builder);
}
// Singleton -> EntitySet
public static ODataModelBuilder Add_MicrosoftEmployees_Binding(this ODataModelBuilder builder)
{
builder.Singleton <Company>("OsCorp").HasManyBinding(c => c.ComplanyEmployees, "Employees");
return(builder);
}
public static ODataModelBuilder Add_EmployeeComplany_Relationship(this ODataModelBuilder builder)
{
builder.EntityType <Employee>().HasRequired(o => o.WorkCompany);
return(builder);
}
// EntitySet -> EntitySet
public static ODataModelBuilder Add_CompaniesEmployees_Binding(this ODataModelBuilder builder)
{
builder.EntitySet <Company>("Companies").HasManyBinding(c => c.ComplanyEmployees, "Employees");
return(builder);
}
public static ODataModelBuilder Add_Company_Singleton(this ODataModelBuilder builder)
{
builder.Add_Company_EntityType().Singleton <Company>("OsCorp");
return(builder);
}
public static ODataModelBuilder Add_CompanyEmployees_Relationship(this ODataModelBuilder builder)
{
builder.EntityType <Company>().HasMany(c => c.ComplanyEmployees);
builder.EntityType <Company>().HasRequired(c => c.CEO, (company, employee) => company.CEOID == employee.EmployeeID, employee => employee.IsCeoOf);
return(builder);
}
public static ODataModelBuilder Add_Customer_EntityType_With_DuplicatedAddress(this ODataModelBuilder builder)
{
builder.Add_Customer_EntityType();
builder.Add_Address_ComplexType();
var customer = builder.EntityType <Customer>();
customer.ComplexProperty(c => c.Address);
customer.ComplexProperty(c => c.WorkAddress);
customer.Property(c => c.City);
return(builder);
}
public static ODataModelBuilder Add_Customer_EntityType_With_CollectionProperties(this ODataModelBuilder builder)
{
builder.Add_Customer_EntityType();
builder.EntityType <Customer>().CollectionProperty(c => c.Aliases);
builder.EntityType <Customer>().CollectionProperty(c => c.Addresses);
return(builder);
}
public static ODataModelBuilder Add_Customer_EntityType_With_DynamicProperties(this ODataModelBuilder builder)
{
builder.Add_Customer_EntityType();
var customer = builder.EntityType <Customer>();
customer.HasDynamicProperties(c => c.DynamicProperties);
return(builder);
}
public static IEdmModel GetServiceModel(this ODataModelBuilder builder)
{
return(EdmModelHelperMethods.BuildEdmModel(builder));
}
public void CanEmitModelWithTwoEntitiesAndARelationship()
{
var builder = new ODataModelBuilder().Add_Order_EntityType().Add_Customer_EntityType().Add_CustomerOrders_Relationship();
var model = builder.GetServiceModel();
var csdl = GetCSDL(model);
}
public void CanCreateEdmModel_ForBindableFunction_WithSupportedParameterType()
{
// Arrange
ODataModelBuilder builder = new ODataModelBuilder();
EntityTypeConfiguration <Customer> customer = builder.EntityType <Customer>();
customer.HasKey(c => c.CustomerId);
customer.Property(c => c.Name);
// Act
FunctionConfiguration functionBuilder = customer.Function("FunctionName");
functionBuilder.Parameter <int>("primitive");
functionBuilder.CollectionParameter <int>("collectionPrimitive");
functionBuilder.Parameter <bool?>("nullablePrimitive");
functionBuilder.CollectionParameter <bool?>("nullableCollectionPrimitive");
functionBuilder.Parameter <Color>("enum");
functionBuilder.CollectionParameter <Color>("collectionEnum");
functionBuilder.Parameter <Color?>("nullableEnum");
functionBuilder.CollectionParameter <Color?>("nullableCollectionEnum");
functionBuilder.Parameter <Address>("complex");
functionBuilder.CollectionParameter <Address>("collectionComplex");
functionBuilder.EntityParameter <Customer>("entity");
functionBuilder.CollectionEntityParameter <Customer>("collectionEntity");
functionBuilder.Returns <bool>();
IEdmModel model = builder.GetEdmModel();
// Assert
Assert.Single(model.SchemaElements.OfType <IEdmFunction>());
IEdmFunction function = Assert.Single(model.SchemaElements.OfType <IEdmFunction>());
Assert.False(function.IsComposable);
Assert.True(function.IsBound);
Assert.Equal("FunctionName", function.Name);
Assert.NotNull(function.ReturnType);
Assert.Equal(13, function.Parameters.Count());
function.AssertHasParameter(model, BindingParameterConfiguration.DefaultBindingParameterName, typeof(Customer), true);
function.AssertHasParameter(model, parameterName: "primitive", parameterType: typeof(int), isNullable: false);
function.AssertHasParameter(model, parameterName: "collectionPrimitive", parameterType: typeof(IList <int>), isNullable: false);
function.AssertHasParameter(model, parameterName: "nullablePrimitive", parameterType: typeof(bool?), isNullable: true);
function.AssertHasParameter(model, parameterName: "nullableCollectionPrimitive", parameterType: typeof(IList <bool?>), isNullable: true);
function.AssertHasParameter(model, parameterName: "enum", parameterType: typeof(Color), isNullable: false);
function.AssertHasParameter(model, parameterName: "collectionEnum", parameterType: typeof(IList <Color>), isNullable: false);
function.AssertHasParameter(model, parameterName: "nullableEnum", parameterType: typeof(Color?), isNullable: true);
function.AssertHasParameter(model, parameterName: "nullableCollectionEnum", parameterType: typeof(IList <Color?>), isNullable: true);
function.AssertHasParameter(model, parameterName: "complex", parameterType: typeof(Address), isNullable: true);
function.AssertHasParameter(model, parameterName: "collectionComplex", parameterType: typeof(IList <Address>), isNullable: true);
function.AssertHasParameter(model, parameterName: "entity", parameterType: typeof(Customer), isNullable: true);
function.AssertHasParameter(model, parameterName: "collectionEntity", parameterType: typeof(IList <Customer>), isNullable: true);
}
public void CanEmitModelWithSingleEntity()
{
var builder = new ODataModelBuilder().Add_Customer_EntityType();
var model = builder.GetServiceModel();
var csdl = GetCSDL(model);
}
public void CanEmitModelWithSingleComplexType()
{
var builder = new ODataModelBuilder().Add_Address_ComplexType();
var model = builder.GetServiceModel();
var csdl = GetCSDL(model);
}
public NavigationSourceLinkBuilderAnnotationTest()
{
_modelBuilder = ODataModelBuilderMocks.GetModelBuilderMock <ODataModelBuilder>();
_entitySet = _modelBuilder.AddEntitySet("Customers", _modelBuilder.AddEntityType(typeof(Customer)));
}
private static IEdmModel GetExplicitEdmModel()
{
var modelBuilder = new ODataModelBuilder();
var enumContry = modelBuilder.EnumType <CountryOrRegion>();
enumContry.Member(CountryOrRegion.Canada);
enumContry.Member(CountryOrRegion.China);
enumContry.Member(CountryOrRegion.India);
enumContry.Member(CountryOrRegion.Japen);
enumContry.Member(CountryOrRegion.USA);
var products = modelBuilder.EntitySet <Product>("Products");
products.HasEditLink(entityContext =>
{
object id;
entityContext.EdmObject.TryGetPropertyValue("ID", out id);
return(new Uri(entityContext.GetUrlHelper().Link(ODataTestConstants.DefaultRouteName,
new
{
odataPath = ResourceContextHelper.CreateODataLink(entityContext,
new EntitySetSegment(entityContext.NavigationSource as IEdmEntitySet),
new KeySegment(new[] { new KeyValuePair <string, object>("ID", id) }, entityContext.StructuredType as IEdmEntityType, null))
})));
}, true);
var suppliers = modelBuilder.EntitySet <Supplier>("Suppliers");
suppliers.HasEditLink(entityContext =>
{
object id;
entityContext.EdmObject.TryGetPropertyValue("ID", out id);
return(new Uri(entityContext.GetUrlHelper().Link(ODataTestConstants.DefaultRouteName,
new
{
odataPath = ResourceContextHelper.CreateODataLink(entityContext,
new EntitySetSegment(entityContext.NavigationSource as IEdmEntitySet),
new KeySegment(new[] { new KeyValuePair <string, object>("ID", id) }, entityContext.StructuredType as IEdmEntityType, null))
})));
}, true);
var families = modelBuilder.EntitySet <ProductFamily>("ProductFamilies");
families.HasEditLink(entityContext =>
{
object id;
entityContext.EdmObject.TryGetPropertyValue("ID", out id);
return(new Uri(entityContext.GetUrlHelper().Link(ODataTestConstants.DefaultRouteName,
new
{
odataPath = ResourceContextHelper.CreateODataLink(entityContext,
new EntitySetSegment(entityContext.NavigationSource as IEdmEntitySet),
new KeySegment(new[] { new KeyValuePair <string, object>("ID", id) }, entityContext.StructuredType as IEdmEntityType, null))
})));
}, true);
var product = products.EntityType;
product.HasKey(p => p.ID);
product.Property(p => p.Name);
product.Property(p => p.ReleaseDate);
product.Property(p => p.SupportedUntil);
var address = modelBuilder.ComplexType <Address>();
address.Property(a => a.City);
address.Property(a => a.CountryOrRegion);
address.Property(a => a.State);
address.Property(a => a.Street);
address.Property(a => a.ZipCode);
var supplier = suppliers.EntityType;
supplier.HasKey(s => s.ID);
supplier.Property(s => s.Name);
supplier.CollectionProperty(s => s.Addresses);
supplier.CollectionProperty(s => s.Tags);
supplier.EnumProperty(s => s.CountryOrRegion);
var productFamily = families.EntityType;
productFamily.HasKey(pf => pf.ID);
productFamily.Property(pf => pf.Name);
productFamily.Property(pf => pf.Description);
// Create relationships and bindings in one go
products.HasRequiredBinding(p => p.Family, families);
families.HasManyBinding(pf => pf.Products, products);
families.HasOptionalBinding(pf => pf.Supplier, suppliers);
suppliers.HasManyBinding(s => s.ProductFamilies, families);
// Create navigation Link builders
products.HasNavigationPropertiesLink(
product.NavigationProperties,
(entityContext, navigationProperty) =>
{
object id;
entityContext.EdmObject.TryGetPropertyValue("ID", out id);
return(new Uri(entityContext.GetUrlHelper().Link(ODataTestConstants.DefaultRouteName,
new
{
odataPath = ResourceContextHelper.CreateODataLink(entityContext,
new EntitySetSegment(entityContext.NavigationSource as IEdmEntitySet),
new KeySegment(new[] { new KeyValuePair <string, object>("ID", id) }, entityContext.StructuredType as IEdmEntityType, null),
new NavigationPropertySegment(navigationProperty, null))
})));
}, true);
families.HasNavigationPropertiesLink(
productFamily.NavigationProperties,
(entityContext, navigationProperty) =>
{
object id;
entityContext.EdmObject.TryGetPropertyValue("ID", out id);
return(new Uri(entityContext.GetUrlHelper().Link(ODataTestConstants.DefaultRouteName,
new
{
odataPath = ResourceContextHelper.CreateODataLink(entityContext,
new EntitySetSegment(entityContext.NavigationSource as IEdmEntitySet),
new KeySegment(new[] { new KeyValuePair <string, object>("ID", id) }, entityContext.StructuredType as IEdmEntityType, null),
new NavigationPropertySegment(navigationProperty, null))
})));
}, true);
suppliers.HasNavigationPropertiesLink(
supplier.NavigationProperties,
(entityContext, navigationProperty) =>
{
object id;
entityContext.EdmObject.TryGetPropertyValue("ID", out id);
return(new Uri(entityContext.GetUrlHelper().Link(
ODataTestConstants.DefaultRouteName,
new
{
odataPath = ResourceContextHelper.CreateODataLink(entityContext,
new EntitySetSegment(entityContext.NavigationSource as IEdmEntitySet),
new KeySegment(new[] { new KeyValuePair <string, object>("ID", id) }, entityContext.StructuredType as IEdmEntityType, null),
new NavigationPropertySegment(navigationProperty, null))
})));
}, true);
return(modelBuilder.GetEdmModel());
}
public void Apply(ODataModelBuilder builder, ApiVersion apiVersion)
{
var category = builder.EntitySet <Categories>(nameof(Categories)).EntityType;
category.HasKey(p => p.CategoryId);
}
public void MaxDataServiceVersion_RoundTrips()
{
ODataModelBuilder builder = new ODataModelBuilder();
ReflectionAssert.Property(builder, b => b.MaxDataServiceVersion, new Version(4, 0), allowNull: false, roundTripTestValue: new Version(1, 0));
}
public static ODataModelBuilder Add_CustomerOrders_Binding(this ODataModelBuilder builder)
{
builder.EntitySet <Customer>("Customers").HasManyBinding(c => c.Orders, "Orders");
return(builder);
}
private void ConfigureV2(ODataModelBuilder builder) => ConfigureCurrent(builder).Ignore(p => p.Phone);
public static ODataModelBuilder Add_OrderCustomer_Binding(this ODataModelBuilder builder)
{
builder.EntitySet <Order>("Orders").HasRequiredBinding(o => o.Customer, "Customer");
return(builder);
}
public static EntitySetConfiguration CreateOrReuseEntitySet <TElementEntityType>(ODataModelBuilder builder, string entitySetName) where TElementEntityType : class
{
EntitySetConfiguration entitySet = builder.EntitySets.SingleOrDefault(s => s.Name == entitySetName);
if (entitySet == null)
{
builder.EntitySet <TElementEntityType>(entitySetName);
entitySet = builder.EntitySets.Single(s => s.Name == entitySetName);
}
else
{
builder.EntityType <TElementEntityType>();
}
return(entitySet);
}