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 static IEdmModel GetTypedExplicitModel() { ODataModelBuilder builder = new ODataModelBuilder(); var accountType = builder.EntityType<Account>(); accountType.HasKey(c => c.Id); accountType.Property(c => c.Name); accountType.HasDynamicProperties(c => c.DynamicProperties); accountType.ComplexProperty<AccountInfo>(c => c.AccountInfo); accountType.ComplexProperty<Address>(a => a.Address); accountType.ComplexProperty<Tags>(a => a.Tags); var premiumAccountType = builder.EntityType<PremiumAccount>(); premiumAccountType.Property(p => p.Since); premiumAccountType.DerivesFrom<Account>(); var accountInfoType = builder.ComplexType<AccountInfo>(); accountInfoType.Property(i => i.NickName); accountInfoType.HasDynamicProperties(i => i.DynamicProperties); var addressType = builder.ComplexType<Address>(); addressType.Property(a => a.City); addressType.Property(a => a.Street); addressType.HasDynamicProperties(a => a.DynamicProperties); var globalAddressType = builder.ComplexType<GlobalAddress>(); globalAddressType.Property(a => a.CountryCode); globalAddressType.DerivesFrom<Address>(); var tagsType = builder.ComplexType<Tags>(); tagsType.HasDynamicProperties(t => t.DynamicProperties); var gender = builder.EnumType<Gender>(); gender.Member(Gender.Female); gender.Member(Gender.Male); var employeeType = builder.EntityType<Employee>(); employeeType.HasKey(e => e.Id); employeeType.HasOptional(e => e.Account); builder.EntitySet<Employee>("Employees"); var managerType = builder.EntityType<Manager>(); managerType.Property(m => m.Heads); managerType.HasDynamicProperties(m => m.DynamicProperties); managerType.DerivesFrom<Employee>(); AddBoundActionsAndFunctions(accountType); AddUnboundActionsAndFunctions(builder); EntitySetConfiguration<Account> accounts = builder.EntitySet<Account>("Accounts"); builder.Namespace = typeof(Account).Namespace; return builder.GetEdmModel(); }
public static IEdmModel GetEdmModel() { var builder = new ODataModelBuilder(); var employee = builder.EntityType<Employee>(); employee.HasKey(e => e.EmployeeID); employee.HasMany(e => e.Orders); var order = builder.EntityType<Order>(); order.HasKey(c => c.OrderID); order.HasMany(c => c.OrderDetails); return builder.GetEdmModel(); }
private static void BuildFunctions(ODataModelBuilder builder) { FunctionConfiguration GetWeapons = builder.EntityType<Hero>() .Collection.Function("GetWeapons") .ReturnsCollectionFromEntitySet<Weapon>("Weapons"); GetWeapons.IsComposable = true; FunctionConfiguration GetNames = builder.EntityType<Hero>() .Collection.Function("GetNames") .ReturnsCollection<string>(); GetNames.IsComposable = true; }
public void CanCreateEntityWithCollectionProperties() { var builder = new ODataModelBuilder(); var customer = builder.EntityType<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 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 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 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 CanBuildBoundProcedureCacheForIEdmModel() { // Arrange ODataModelBuilder builder = new ODataModelBuilder(); EntityTypeConfiguration<Customer> customer = builder.EntitySet<Customer>("Customers").EntityType; customer.HasKey(c => c.ID); customer.Property(c => c.Name); customer.ComplexProperty(c => c.Address); EntityTypeConfiguration<Movie> movie = builder.EntitySet<Movie>("Movies").EntityType; movie.HasKey(m => m.ID); movie.HasKey(m => m.Name); EntityTypeConfiguration<Blockbuster> blockBuster = builder.EntityType<Blockbuster>().DerivesFrom<Movie>(); EntityTypeConfiguration movieConfiguration = builder.StructuralTypes.OfType<EntityTypeConfiguration>().Single(t => t.Name == "Movie"); // build actions that are bindable to a single entity customer.Action("InCache1_CustomerAction"); customer.Action("InCache2_CustomerAction"); movie.Action("InCache3_MovieAction"); ActionConfiguration incache4_MovieAction = builder.Action("InCache4_MovieAction"); incache4_MovieAction.SetBindingParameter("bindingParameter", movieConfiguration); blockBuster.Action("InCache5_BlockbusterAction"); // build actions that are either: bindable to a collection of entities, have no parameter, have only complex parameter customer.Collection.Action("NotInCache1_CustomersAction"); movie.Collection.Action("NotInCache2_MoviesAction"); ActionConfiguration notInCache3_NoParameters = builder.Action("NotInCache3_NoParameters"); ActionConfiguration notInCache4_AddressParameter = builder.Action("NotInCache4_AddressParameter"); notInCache4_AddressParameter.Parameter<Address>("address"); IEdmModel model = builder.GetEdmModel(); IEdmEntityType customerType = model.SchemaElements.OfType<IEdmEntityType>().Single(e => e.Name == "Customer"); IEdmEntityType movieType = model.SchemaElements.OfType<IEdmEntityType>().Single(e => e.Name == "Movie"); IEdmEntityType blockBusterType = model.SchemaElements.OfType<IEdmEntityType>().Single(e => e.Name == "Blockbuster"); // Act BindableProcedureFinder annotation = new BindableProcedureFinder(model); IEdmAction[] movieActions = annotation.FindProcedures(movieType) .OfType<IEdmAction>() .ToArray(); IEdmAction[] customerActions = annotation.FindProcedures(customerType) .OfType<IEdmAction>() .ToArray(); IEdmAction[] blockBusterActions = annotation.FindProcedures(blockBusterType) .OfType<IEdmAction>() .ToArray(); // Assert Assert.Equal(2, customerActions.Length); Assert.NotNull(customerActions.SingleOrDefault(a => a.Name == "InCache1_CustomerAction")); Assert.NotNull(customerActions.SingleOrDefault(a => a.Name == "InCache2_CustomerAction")); Assert.Equal(2, movieActions.Length); Assert.NotNull(movieActions.SingleOrDefault(a => a.Name == "InCache3_MovieAction")); Assert.NotNull(movieActions.SingleOrDefault(a => a.Name == "InCache4_MovieAction")); Assert.Equal(3, blockBusterActions.Length); Assert.NotNull(blockBusterActions.SingleOrDefault(a => a.Name == "InCache3_MovieAction")); Assert.NotNull(blockBusterActions.SingleOrDefault(a => a.Name == "InCache4_MovieAction")); Assert.NotNull(blockBusterActions.SingleOrDefault(a => a.Name == "InCache5_BlockbusterAction")); }
private static void BuildFunctions(ODataModelBuilder builder) { FunctionConfiguration function = builder.EntityType<File>() .Collection.Function("GetFilesModifiedAt") .ReturnsCollectionViaEntitySetPath<File>("bindingParameter"); function.Parameter<DateTime>("modifiedDate"); }
public void CreateComplexTypeProperty() { var builder = new ODataModelBuilder().Add_Customer_EntityType().Add_Address_ComplexType(); builder.EntityType<Customer>().ComplexProperty(c => c.Address); var model = builder.GetServiceModel(); var customerType = model.SchemaElements.OfType<IEdmEntityType>().Single(); var addressProperty = customerType.FindProperty("Address"); Assert.NotNull(addressProperty); }
public UnboundFunctionPathSegmentTest() { ODataModelBuilder builder = new ODataModelBuilder(); builder.EntityType<MyCustomer>().HasKey(c => c.Id).Property(c => c.Name); builder.EntitySet<MyCustomer>("Customers"); FunctionConfiguration function = builder.Function("TopCustomer"); function.ReturnsFromEntitySet<MyCustomer>("Customers"); builder.Function("MyFunction").Returns<string>(); _model = builder.GetEdmModel(); _container = _model.EntityContainers().Single(); }
public static IEdmModel GetExplicitModel() { ODataModelBuilder builder = new ODataModelBuilder(); var accountType = builder.EntityType<Account>(); accountType.HasKey(a => a.AccountID); accountType.Property(a => a.Name); var payoutPI = accountType.ContainsOptional(a => a.PayoutPI); var payinPIs = accountType.HasMany(a => a.PayinPIs) .Contained(); var premiumAccountType = builder.EntityType<PremiumAccount>() .DerivesFrom<Account>(); var giftCard = premiumAccountType.ContainsRequired(pa => pa.GiftCard); var giftCardType = builder.EntityType<GiftCard>(); giftCardType.HasKey(g => g.GiftCardID); giftCardType.Property(g => g.GiftCardNO); giftCardType.Property(g => g.Amount); var paymentInstrumentType = builder.EntityType<PaymentInstrument>(); paymentInstrumentType.HasKey(pi => pi.PaymentInstrumentID); paymentInstrumentType.Property(pi => pi.FriendlyName); var statement = paymentInstrumentType.ContainsOptional(pi => pi.Statement); var statementType = builder.EntityType<Statement>(); statementType.HasKey(s => s.StatementID); statementType.Property(s => s.TransactionDescription); statementType.Property(s => s.Amount); var accounts = builder.EntitySet<Account>("Accounts"); accounts.HasIdLink(c => c.GenerateSelfLink(false), true); accounts.HasEditLink(c => c.GenerateSelfLink(true), true); builder.Singleton<Account>("AnonymousAccount"); AddBoundActionsAndFunctions(builder); builder.Namespace = typeof(Account).Namespace; return builder.GetEdmModel(); }
public UnboundActionPathSegmentTest() { ODataModelBuilder builder = new ODataModelBuilder(); builder.EntityType<MyCustomer>().HasKey(c => c.Id).Property(c => c.Name); builder.EntitySet<MyCustomer>("Customers"); ActionConfiguration action = builder.Action("CreateCustomer"); action.ReturnsFromEntitySet<MyCustomer>("Customers"); builder.Action("MyAction").Returns<string>(); builder.Action("ActionWithoutReturn"); _model = builder.GetEdmModel(); _container = _model.EntityContainer; }
public void SelectViaOData( [IncludeDataSources(TestProvName.AllSqlServer)] string context, [ValueSource(nameof(ODataQueriesTestCases))] ODataQueries testCase) { var modelBuilder = new ODataModelBuilder(); var person = modelBuilder.EntityType <PersonClass>(); person.HasKey(p => p.Name); person.Property(p => p.Title); person.Property(p => p.YearsExperience); var model = modelBuilder.GetEdmModel(); var testData = GenerateTestData(); using (var db = GetDataContext(context)) using (var table = db.CreateLocalTable(testData)) { var path = new ODataPath(); ODataQueryContext queryContext = new ODataQueryContext(model, typeof(PersonClass), path); var uri = new Uri("http://localhost:15580" + testCase.Query); #if NETFRAMEWORK var request = new HttpRequestMessage() { Method = HttpMethod.Get, RequestUri = uri }; var config = new HttpConfiguration(); config.EnableDependencyInjection(); request.Properties.Add(HttpPropertyKeys.HttpConfigurationKey, config); #else // https://github.com/OData/AspNetCoreOData/blob/master/test/Microsoft.AspNetCore.OData.Tests/Extensions/RequestFactory.cs#L78 var httpContext = new DefaultHttpContext(); HttpRequest request = httpContext.Request; IServiceCollection services = new ServiceCollection(); httpContext.RequestServices = services.BuildServiceProvider(); request.Method = "GET"; request.Scheme = uri.Scheme; request.Host = uri.IsDefaultPort ? new HostString(uri.Host) : new HostString(uri.Host, uri.Port); request.QueryString = new QueryString(uri.Query); request.Path = new PathString(uri.AbsolutePath); #endif var options = new ODataQueryOptions(queryContext, request); var resultQuery = options.ApplyTo(table); var materialized = Materialize(resultQuery); Assert.That(materialized.Count, Is.EqualTo(1)); } }
private IEdmModel BuildEdmModel(ODataModelBuilder builder) { builder.EntitySet <Case>("cases"); builder.EntitySet <Editor>("editors"); builder.EntitySet <Location>("locations"); builder.EntitySet <Visitor>("visitors"); var caseTypeBuilder = builder.EntityType <Case>(); var caseTypeGetStatusFunction = caseTypeBuilder.Function("status").Returns <ChangeDependentSubjectStateEntry>(); caseTypeGetStatusFunction.Parameter <int>("subjectId").Required(); return(builder.GetEdmModel()); }
public static ODataModelBuilder Add_Order_EntityType(this ODataModelBuilder builder) { var order = builder.EntityType <Order>(); order.HasKey(o => o.OrderId); order.Property(o => o.OrderDate); order.Property(o => o.Price); order.Property(o => o.OrderDate); order.Property(o => o.DeliveryDate); order.Ignore(o => o.Cost); return(builder); }
// Adds a Customer EntityType but allows caller to configure Keys() public static ODataModelBuilder Add_Customer_With_Keys_EntityType <TKey>(this ODataModelBuilder builder, Expression <Func <Customer, TKey> > keyDefinitionExpression) { var customer = builder.EntityType <Customer>(); customer.HasKey(keyDefinitionExpression); customer.Property(c => c.CustomerId); customer.Property(c => c.Name); customer.Property(c => c.Website); customer.Property(c => c.SharePrice); customer.Property(c => c.ShareSymbol); return(builder); }
public static ODataModelBuilder Add_Customer_EntityType(this ODataModelBuilder builder) { var customer = builder.EntityType <Customer>(); customer.HasKey(c => c.CustomerId); customer.Property(c => c.CustomerId); customer.Property(c => c.Name).IsConcurrencyToken(); customer.Property(c => c.Website); customer.Property(c => c.SharePrice); customer.Property(c => c.ShareSymbol); return(builder); }
public void CreateEdmModelWithEntitySetFromAbstractEntityTypeWithoutKey_Throws() { // Arrange ODataModelBuilder builder = new ODataModelBuilder(); builder.EntityType <Customer>().Abstract().Property(c => c.CustomerId); builder.EntitySet <Customer>("Customers"); // Act & Assert ExceptionAssert.Throws <InvalidOperationException>(() => builder.GetEdmModel(), "The entity set 'Customers' is based on type 'Microsoft.OData.ModelBuilder.Tests.TestModels.Customer' that has no keys defined."); }
public void BuildEdmModel_WorksOnModelBuilder_ForUntypedProperty(bool convention) { // Arrange & Act IEdmModel model = null; if (convention) { ODataConventionModelBuilder builder = new ODataConventionModelBuilder(); builder.EntityType <UntypedEntity>(); model = builder.GetEdmModel(); } else { ODataModelBuilder builder = new ODataModelBuilder(); var entity = builder.EntityType <UntypedEntity>(); entity.HasKey(p => p.Id); entity.Property(p => p.Value); entity.CollectionProperty(p => p.Data); entity.CollectionProperty(p => p.Infos); model = builder.GetEdmModel(); } // Assert Assert.NotNull(model); IEdmEntityType edmEntityType = model.SchemaElements.OfType <IEdmEntityType>().First(c => c.Name == "UntypedEntity"); IEdmProperty[] edmProperties = edmEntityType.Properties().ToArray(); Assert.Equal(4, edmProperties.Length); // Value property IEdmProperty valueProperty = edmProperties.First(p => p.Name == "Value"); Assert.True(valueProperty.Type.IsNullable); // always "true"? Assert.True(valueProperty.Type.IsUntyped()); Assert.Same(EdmCoreModel.Instance.GetUntypedType(), valueProperty.Type.Definition); Assert.Equal("Edm.Untyped", valueProperty.Type.FullName()); // Data collection property IEdmProperty dataProperty = edmProperties.First(p => p.Name == "Data"); Assert.True(dataProperty.Type.IsNullable); // always "true"? Assert.True(dataProperty.Type.IsCollection()); Assert.True(dataProperty.Type.AsCollection().ElementType().IsUntyped()); Assert.Equal("Collection(Edm.Untyped)", dataProperty.Type.FullName()); // Infos collection property IEdmProperty infosProperty = edmProperties.First(p => p.Name == "Infos"); Assert.True(infosProperty.Type.IsNullable); // always "true"? Assert.True(infosProperty.Type.IsCollection()); Assert.True(infosProperty.Type.AsCollection().ElementType().IsUntyped()); Assert.Equal("Collection(Edm.Untyped)", infosProperty.Type.FullName()); }
public void Validate_Throws_If_EntityWithoutKeyDefined_UsedToDefineEntitySet() { // Arrange ODataModelBuilder builder = new ODataModelBuilder(); builder.EntityType <Customer>(); builder.EntitySet <Customer>("Customers"); // Act & Assert ExceptionAssert.Throws <InvalidOperationException>(() => builder.GetEdmModel(), "The entity set 'Customers' is based on type 'Microsoft.AspNet.OData.Test.Common.Models.Customer' that has no keys defined."); }
public void HasFeedFunctionLink_SetsFollowsConventions(bool value) { // Arrange ODataModelBuilder builder = new ODataModelBuilder(); var function = builder.EntityType <Customer>().Collection.Function("IgnoreFunction"); // Act function.HasFeedFunctionLink((a) => { throw new NotImplementedException(); }, followsConventions: value); // Assert Assert.Equal(value, function.FollowsConventions); }
public void ExecuteBindingAsync_Works_WithPath(string methodName, Type entityClrType) { // Arrange HttpRequestMessage request = new HttpRequestMessage( HttpMethod.Get, "http://localhost/Customer/?$orderby=Name"); HttpConfiguration config = new HttpConfiguration(); request.SetConfiguration(config); // Get EDM model, and set path to request. 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)); // Setup action context and parameter descriptor. HttpControllerContext controllerContext = new HttpControllerContext( config, new HttpRouteData(new HttpRoute()), request); HttpControllerDescriptor controllerDescriptor = new HttpControllerDescriptor( config, "CustomerLowLevel", typeof(CustomerHighLevelController)); MethodInfo methodInfo = typeof(CustomerLowLevelController).GetMethod(methodName); HttpActionDescriptor actionDescriptor = new ReflectedHttpActionDescriptor(controllerDescriptor, methodInfo); HttpActionContext actionContext = new HttpActionContext(controllerContext, actionDescriptor); HttpParameterDescriptor parameterDescriptor = new ReflectedHttpParameterDescriptor( actionDescriptor, methodInfo.GetParameters().First()); // Act new ODataQueryParameterBindingAttribute().GetBinding(parameterDescriptor) .ExecuteBindingAsync((ModelMetadataProvider)null, actionContext, CancellationToken.None) .Wait(); // Assert Assert.Equal(1, actionContext.ActionArguments.Count); ODataQueryOptions options = actionContext.ActionArguments[parameterDescriptor.ParameterName] as ODataQueryOptions; Assert.NotNull(options); Assert.Same(model, options.Context.Model); Assert.Same(entitySet, options.Context.NavigationSource); Assert.Same(entityClrType, options.Context.ElementClrType); }
private static IEdmModel GetModel(WebRouteConfiguration config) { ODataModelBuilder builder = config.CreateConventionModelBuilder(); builder.EntitySet <DerivedTypeA>("SetA"); builder.EntitySet <DerivedTypeB>("SetB"); builder.EntityType <BaseType>(); // this line is necessary. builder.Function("ReturnAll").ReturnsCollection <BaseType>(); return(builder.GetEdmModel()); }
public static IEdmModel NewNonConventionalBuildModel() { var builder = new ODataModelBuilder(); var color = builder.EnumType <Color>(); color.Member(Color.Red); color.Member(Color.Blue); color.Member(Color.Green); var address = builder.ComplexType <Address>(); address.Property(a => a.Country); address.Property(a => a.City); address.HasDynamicProperties(a => a.Dynamics); var subAddress = builder.ComplexType <SubAddress>().DerivesFrom <Address>(); subAddress.Property(s => s.Street); var customer = builder.EntityType <Customer>(); customer.HasKey(c => c.CustomerId); customer.ComplexProperty(c => c.Location); customer.HasMany(c => c.Orders); var order = builder.EntityType <Order>(); order.HasKey(o => o.OrderId); order.Property(o => o.Token); builder.EntityType <Registration>().HasKey(r => new { r.ParticipantId, r.ThreadId }); builder.EntityType <Participant>().HasKey(p => p.Login); builder.EntityType <Thread>().HasKey(t => t.Id); builder.EntityType <Box>().HasKey(b => b.Id); builder.EntitySet <Thread>("Threads"); builder.EntitySet <Box>("Boxes"); builder.EntitySet <Participant>("Participants"); return(builder.GetEdmModel()); }
public EnableNestedPathsTest() { _deserializerProvider = ODataDeserializerProviderFactory.Create(); _resourceSetDeserializer = new ODataResourceSetDeserializer(_deserializerProvider); _resourceDeserializer = new ODataResourceDeserializer(_deserializerProvider); _primitiveDeserializer = new ODataPrimitiveDeserializer(); ODataModelBuilder builder = ODataConventionModelBuilderFactory.Create(); builder.EntitySet <EnableNestedPathsCustomer>("EnableNestedPathsCustomers"); builder.EntitySet <EnableNestedPathsProduct>("EnableNestedPathsProducts"); builder.Singleton <EnableNestedPathsCustomer>("EnableNestedPathsTopCustomer"); builder.EntityType <EnableNestedPathsVipCustomer>(); builder.EntityType <EnableNestedPathsVipCustomer>() .Function("GetMostPurchasedProduct") .ReturnsFromEntitySet <EnableNestedPathsProduct>("EnableNestedPathsProduct"); builder.EntityType <EnableNestedPathsProduct>() .Collection .Action("SetDiscountRate"); _model = builder.GetEdmModel(); Type[] controllers = new Type[] { typeof(EnableNestedPathsCustomersController), typeof(EnableNestedPathsProductsController), typeof(EnableNestedPathsTopCustomerController) }; _server = TestServerFactory.Create(controllers, (config) => { config.MapODataServiceRoute("odata", "odata", _model); config.Count().OrderBy().Filter().Expand().MaxTop(null).Select(); }); _client = TestServerFactory.CreateClient(_server); _db = new EnableNestedPathsDatabase(); }
private static void MapCommonOData(ODataModelBuilder builder) { builder .EntitySet <DocumentModel>("Documents") .EntityType.HasKey(p => p.Id); builder .EntitySet <Core.Models.Workflows.Parameters.MetadataModel>("MetadataModel") .EntityType.HasKey(p => new { p.KeyName, p.Value }); builder .EntitySet <CategoryModel>("Categories") .EntityType.HasKey(p => p.Id); builder .EntitySet <ContainerModel>("Containers") .EntityType.HasKey(p => p.Id); builder .EntitySet <GenericDocumentUnitModel>("GenericDocumentUnits") .EntityType.HasKey(p => p.Id); #region [ Functions ] FunctionConfiguration getProtocolDocumentsFunc = builder .EntityType <DocumentModel>().Collection .Function("GetDocuments"); getProtocolDocumentsFunc.Namespace = "DocumentUnitService"; getProtocolDocumentsFunc.ReturnsCollectionFromEntitySet <DocumentModel>("DocumentUnits"); getProtocolDocumentsFunc.Parameter <Guid>("uniqueId"); getProtocolDocumentsFunc.Parameter <Guid?>("workflowArchiveChainId"); FunctionConfiguration getActivityDocuments = builder .EntityType <DocumentModel>().Collection .Function("GetDocumentsByArchiveChain"); getActivityDocuments.Namespace = "DocumentUnitService"; getActivityDocuments.ReturnsCollectionFromEntitySet <DocumentModel>("DocumentUnits"); getActivityDocuments.Parameter <Guid>("idArchiveChain"); #endregion }
private static void RegisterMembershipODataActions(ODataModelBuilder builder) { var getUsersInRoleAction = builder.EntityType <KoreUser>().Collection.Action("GetUsersInRole"); getUsersInRoleAction.Parameter <string>("roleId"); getUsersInRoleAction.ReturnsCollectionFromEntitySet <KoreUser>("Users"); var assignUserToRolesAction = builder.EntityType <KoreUser>().Collection.Action("AssignUserToRoles"); assignUserToRolesAction.Parameter <string>("userId"); assignUserToRolesAction.CollectionParameter <string>("roles"); assignUserToRolesAction.Returns <IHttpActionResult>(); var changePasswordAction = builder.EntityType <KoreUser>().Collection.Action("ChangePassword"); changePasswordAction.Parameter <string>("userId"); changePasswordAction.Parameter <string>("password"); changePasswordAction.Returns <IHttpActionResult>(); var getRolesForUserAction = builder.EntityType <KoreRole>().Collection.Action("GetRolesForUser"); getRolesForUserAction.Parameter <string>("userId"); getRolesForUserAction.ReturnsCollection <EdmKoreRole>(); var assignPermissionsToRoleAction = builder.EntityType <KoreRole>().Collection.Action("AssignPermissionsToRole"); assignPermissionsToRoleAction.Parameter <string>("roleId"); assignPermissionsToRoleAction.CollectionParameter <string>("permissions"); assignPermissionsToRoleAction.Returns <IHttpActionResult>(); var getPermissionsForRoleAction = builder.EntityType <KorePermission>().Collection.Action("GetPermissionsForRole"); getPermissionsForRoleAction.Parameter <string>("roleId"); getPermissionsForRoleAction.ReturnsCollection <EdmKorePermission>(); }
public void GetIfMatchOrNoneMatch_ReturnsETag_SetETagHeaderValue(string header) { // Arrange HttpRequestMessage request = new HttpRequestMessage(); HttpConfiguration cofiguration = new HttpConfiguration(); request.SetConfiguration(cofiguration); Dictionary <string, object> properties = new Dictionary <string, object> { { "Name", "Foo" } }; EntityTagHeaderValue etagHeaderValue = new DefaultODataETagHandler().CreateETag(properties); if (header.Equals("IfMatch")) { request.Headers.IfMatch.Add(etagHeaderValue); } else { request.Headers.IfNoneMatch.Add(etagHeaderValue); } ODataModelBuilder builder = new ODataModelBuilder(); EntityTypeConfiguration <Customer> customer = builder.EntityType <Customer>(); customer.HasKey(c => c.Id); customer.Property(c => c.Id); customer.Property(c => c.Name).IsConcurrencyToken(); builder.EntitySet <Customer>("Customers"); IEdmModel model = builder.GetEdmModel(); var customers = model.FindDeclaredEntitySet("Customers"); Mock <ODataPathSegment> mockSegment = new Mock <ODataPathSegment> { CallBase = true }; mockSegment.Setup(s => s.GetEdmType(null)).Returns(model.GetEdmType(typeof(Customer))); mockSegment.Setup(s => s.GetNavigationSource(null)).Returns((IEdmNavigationSource)customers); ODataPath odataPath = new ODataPath(new[] { mockSegment.Object }); request.ODataProperties().Path = odataPath; request.ODataProperties().Model = model; ODataQueryContext context = new ODataQueryContext(model, typeof(Customer)); // Act ODataQueryOptions <Customer> query = new ODataQueryOptions <Customer>(context, request); ETag result = header.Equals("IfMatch") ? query.IfMatch : query.IfNoneMatch; dynamic dynamicResult = result; // Assert Assert.Equal("Foo", result["Name"]); Assert.Equal("Foo", dynamicResult.Name); }
private EntityTypeConfiguration <FlightPlan> ConfigureCurrent(ODataModelBuilder builder) { //var flightplan = builder.EntitySet<FlightPlan>("FlightPlans").EntityType; builder.EntitySet <FlightPlan>("FlightPlans"); var flightPlanType = builder.EntityType <FlightPlan>(); //flightPlanType // .Function("Current") // .Returns<FlightPlan>() // .Parameter<string>("flightNumber"); flightPlanType .Function("Current") .ReturnsFromEntitySet <FlightPlan>("FlightPlan"); var fnGetCurrent = builder.Function("GetCurrentFlightPlan"); fnGetCurrent.Returns <FlightPlan>(); fnGetCurrent.Parameter <string>("flightNumber"); fnGetCurrent.Parameter <string>("iataAirlineCode"); //var fnCurrent = builder.EntityType<FlightPlan>().Collection.Function("Current"); //fnCurrent.Parameter<string>("flightNumber"); //fnCurrent.ReturnsFromEntitySet<FlightPlan>("FlightPlan"); //var functionFlightPlan = builder.Function("GetFlightPlansP"); //functionFlightPlan.Returns<FlightPlan>(); //functionFlightPlan.Parameter<string>("flightNumber"); //functionFlightPlan.Parameter<string>("iataCode"); //builder.Function("GetFlightPlans") // .Returns<FlightPlan>() // .Parameter(<string>("flightNumber") return(builder.EntityType <FlightPlan>()); //var conventions = ODataRoutingConventions.CreateDefault(); //conventions.Insert(0, new CompositeKeyRoutingConvention()); // return flightplan; }
public static IEdmModel GetExplicitModel() { ODataModelBuilder builder = new ODataModelBuilder(); var fileType = builder.EntityType <File>().HasKey(f => f.FileId); fileType.Property(f => f.Name); fileType.Property(f => f.CreatedDate); fileType.Property(f => f.DeleteDate); var files = builder.EntitySet <File>("Files"); return(builder.GetEdmModel()); }
public void CtorODataQueryContext_TakingClrType_Throws_For_UnknownType(Type elementType) { // Arrange ODataModelBuilder builder = new ODataModelBuilder(); builder.EntityType <Customer>(); IEdmModel model = builder.GetEdmModel(); // Act && Assert ExceptionAssert.ThrowsArgument(() => new ODataQueryContext(model, elementType), "elementClrType", Error.Format("The given model does not contain the type '{0}'.", elementType.FullName)); }
public void HasFeedFunctionLink_ThrowsException_OnNoBoundToCollectionEntityFunctions() { // Arrange ODataModelBuilder builder = new ODataModelBuilder(); EntityTypeConfiguration <Customer> customer = builder.EntityType <Customer>(); FunctionConfiguration function = customer.Function("NonCollectionFunction"); // Act & Assert ExceptionAssert.Throws <InvalidOperationException>( () => function.HasFeedFunctionLink(ctx => new Uri("http://any"), followsConventions: false), "To register a function link factory, functions must be bindable to the collection of entity. " + "Function 'NonCollectionFunction' does not meet this requirement."); }
private static void GetModel(out IEdmModel model, out IEdmEntityTypeReference reference) { ODataModelBuilder builder = ODataModelBuilderMocks.GetModelBuilderMock <ODataConventionModelBuilder>(); EntityTypeConfiguration <TestEntity> entity = builder.EntityType <TestEntity>(); entity.Namespace = "Test"; entity.Name = "Entity"; NavigationPropertyConfiguration property = entity.HasOptional(p => p.Property); property.Name = "Alias"; model = builder.GetEdmModel(); reference = new EdmEntityTypeReference((IEdmEntityType)model.FindType("Test.Entity"), false); }
public UnboundFunctionPathSegmentTest() { ODataModelBuilder builder = new ODataModelBuilder(); builder.EntityType <MyCustomer>().HasKey(c => c.Id).Property(c => c.Name); builder.EntitySet <MyCustomer>("Customers"); FunctionConfiguration function = builder.Function("TopCustomer"); function.ReturnsFromEntitySet <MyCustomer>("Customers"); builder.Function("MyFunction").Returns <string>(); _model = builder.GetEdmModel(); _container = _model.EntityContainer; }
private static System.Web.Http.HttpServer CreateServer(string customersEntitySet) #endif { // We need to do this to avoid controllers with incorrect attribute // routing configuration in this assembly that cause an exception to // be thrown at runtime. With this, we restrict the test to the following // set of controllers. Type[] controllers = new Type[] { typeof(OnlyFilterAllowedCustomersController), typeof(OnlyFilterAndEqualsAllowedCustomersController), typeof(FilterDisabledCustomersController), typeof(EverythingAllowedCustomersController), typeof(OtherLimitationsCustomersController), }; ODataModelBuilder builder = ODataConventionModelBuilderFactory.Create(); builder.EntitySet <EnableQueryCustomer>(customersEntitySet); builder.EntityType <PremiumEnableQueryCustomer>(); builder.EntitySet <EnableQueryCategory>("EnableQueryCategories"); builder.EntityType <PremiumEnableQueryCategory>(); builder.EntitySet <EnableQueryOrder>("EnableQueryOrders"); builder.EntityType <DiscountedEnableQueryOrder>(); builder.EntitySet <EnableQueryOrderLine>("EnableQueryOrderLines"); builder.ComplexType <EnableQueryAddress>(); IEdmModel model = builder.GetEdmModel(); return(TestServerFactory.Create(controllers, (config) => { config.MapODataServiceRoute("odata", "odata", model); config.Count().OrderBy().Filter().Expand().MaxTop(null).Select().SkipToken(); })); }
protected override ODataModelBuilder OnCreateEdmModel(ODataModelBuilder oDataModelBuilder) { oDataModelBuilder.Namespace = "Example"; oDataModelBuilder.EntitySet <Product>("Products"); oDataModelBuilder.AddPluralizedEntitySet <Book>(); oDataModelBuilder.AddPluralizedEntitySet <Author>(); oDataModelBuilder.AddPluralizedEntitySet <Publisher>(); oDataModelBuilder.EntityType <Publisher>().HasKey(c => new { c.PublisherId1, c.PublisherId2 }); return(oDataModelBuilder); }
public void HasActionLink_ThrowsException_OnNoBoundToEntityActions() { // Arrange ODataModelBuilder builder = new ODataModelBuilder(); EntityTypeConfiguration <Customer> customer = builder.EntityType <Customer>(); ActionConfiguration action = customer.Collection.Action("CollectionAction"); // Act & Assert ExceptionAssert.Throws <InvalidOperationException>( () => action.HasActionLink(ctx => new Uri("http://any"), followsConventions: false), "To register an action link factory, actions must be bindable to a single entity. " + "Action 'CollectionAction' does not meet this requirement."); }
public void ReturnsCollection_ThrowsInvalidOperationException_IfReturnTypeIsEntity() { // Arrange ODataModelBuilder builder = new ODataModelBuilder(); builder.EntityType <Movie>(); var action = builder.Action("action"); // Act & Assert ExceptionAssert.Throws <InvalidOperationException>(() => action.ReturnsCollection <Movie>(), "The EDM type 'Microsoft.AspNet.OData.Test.Builder.Movie' is already declared as an entity type. Use the " + "method 'ReturnsCollectionFromEntitySet' if the return type is an entity collection."); }
public void HasManyPath_AddBindindPath_Derived(bool contained) { // Assert ODataModelBuilder builder = new ODataModelBuilder(); var customerType = builder.EntityType <BindingCustomer>(); var navigationSource = builder.EntitySet <BindingCustomer>("Customers"); StructuralTypeConfiguration addressType = builder.StructuralTypes.FirstOrDefault(c => c.Name == "BindingAddress"); Assert.Null(addressType); // Guard Assert.Empty(customerType.Properties); // Guard // Act var binding = new BindingPathConfiguration <BindingCustomer>(builder, customerType, navigationSource.Configuration); var newBinding = binding.HasManyPath((BindingVipCustomer v) => v.VipAddresses, contained); // Assert addressType = builder.StructuralTypes.FirstOrDefault(c => c.Name == "BindingAddress"); Assert.NotNull(addressType); Assert.Empty(customerType.Properties); StructuralTypeConfiguration vipCustomerType = builder.StructuralTypes.FirstOrDefault(c => c.Name == "BindingVipCustomer"); Assert.NotNull(vipCustomerType); var vipAddressesProperty = Assert.Single(vipCustomerType.Properties); Assert.Equal("VipAddresses", vipAddressesProperty.Name); if (contained) { Assert.Equal(EdmTypeKind.Entity, addressType.Kind); Assert.Equal(PropertyKind.Navigation, vipAddressesProperty.Kind); NavigationPropertyConfiguration navigationProperty = Assert.IsType <NavigationPropertyConfiguration>(vipAddressesProperty); Assert.Equal(EdmMultiplicity.Many, navigationProperty.Multiplicity); Assert.True(navigationProperty.ContainsTarget); } else { Assert.Equal(EdmTypeKind.Complex, addressType.Kind); Assert.Equal(PropertyKind.Collection, vipAddressesProperty.Kind); CollectionPropertyConfiguration collection = Assert.IsType <CollectionPropertyConfiguration>(vipAddressesProperty); Assert.Equal(typeof(BindingAddress), collection.ElementType); } // different bindings Assert.NotSame(binding, newBinding); Assert.Equal("", binding.BindingPath); Assert.IsType <BindingPathConfiguration <BindingAddress> >(newBinding); Assert.Equal("Microsoft.AspNet.OData.Test.Formatter.BindingVipCustomer/VipAddresses", newBinding.BindingPath); }
private static IEdmModel CreateModel() { var builder = new ODataModelBuilder(); builder.Namespace = "HS"; var personType = builder.EntityType <Person>() .HasKey(p => p.Id); personType.Property(p => p.Name); personType.Property(p => p.Age); personType.OrderBy().Select().Filter().Expand().Count(); personType.Action("Mark").Parameter <string>("comment"); // Entity Function var function = personType .Function("ToLongString"); function.Parameter <string>("prefix"); function.Returns <string>(); // Collection Functions var allAdultsFunction = personType .Collection .Function("AllAdults"); allAdultsFunction.ReturnsCollectionFromEntitySet <Person>("Persons"); var allChildrenFunction = personType .Collection .Function("AllChildren"); allChildrenFunction.ReturnsCollectionFromEntitySet <Person>("Persons"); // Unbound Function var addFunction = builder.Function("Add"); addFunction.Parameter <int>("z1"); addFunction.Parameter <int>("z2"); addFunction.Returns <int>(); // Unbound Action var clearAction = builder.Action("ClearLoggingTable"); clearAction.Parameter <int>("days"); builder.EntitySet <Person>("Persons"); return(builder.GetEdmModel()); }
private static IEdmModel GetExplicitEdmModel() { var builder = new ODataModelBuilder(); // enum type "Color" var color = builder.EnumType<Color>(); color.Member(Color.Red); color.Member(Color.Green); color.Member(Color.Blue); color.Member(Color.Yellow); color.Member(Color.Pink); color.Member(Color.Purple); // complex type "Address" var address = builder.ComplexType<Address>(); address.Property(a => a.City); address.Property(a => a.Street); // entity type "Customer" var customer = builder.EntityType<Customer>().HasKey(c => c.CustomerId); customer.Property(c => c.Name); customer.Property(c => c.Token); // customer.Property(c => c.Email).IsNotNavigable(); // you can call Fluent API customer.Property(c => c.Email); customer.CollectionProperty(c => c.Addresses); customer.CollectionProperty(c => c.FavoriateColors); customer.HasMany(c => c.Orders); // entity type "Order" var order = builder.EntityType<Order>().HasKey(o => o.OrderId); order.Property(o => o.Price); // entity sets builder.EntitySet<Customer>("Customers").HasManyBinding(c => c.Orders, "Orders"); builder.EntitySet<Order>("Orders"); return builder.GetEdmModel(); }
public void NonbindingParameterConfigurationThrowsWhenParameterTypeIsEntity() { // Arrange ODataModelBuilder builder = new ODataModelBuilder(); builder.EntityType<Customer>(); // Act & Assert ArgumentException exception = Assert.Throws<ArgumentException>(() => { NonbindingParameterConfiguration configuration = new NonbindingParameterConfiguration("name", builder.GetTypeConfigurationOrNull(typeof(Customer))); }); Assert.True(exception.Message.Contains(string.Format("'{0}'", typeof(Customer).FullName))); Assert.Equal("parameterType", exception.ParamName); }
public static IEdmModel GetExplicitModel(WebRouteConfiguration configuration) { ODataModelBuilder builder = new ODataModelBuilder(); var employee = builder.EntityType <Employee>(); employee.HasKey(c => c.ID); employee.Property(c => c.Name); employee.CollectionProperty <Skill>(c => c.SkillSet); employee.EnumProperty <Gender>(c => c.Gender); employee.EnumProperty <AccessLevel>(c => c.AccessLevel); employee.ComplexProperty <FavoriteSports>(c => c.FavoriteSports); employee.HasInstanceAnnotations(c => c.InstanceAnnotations); var skill = builder.EnumType <Skill>(); skill.Member(Skill.CSharp); skill.Member(Skill.Sql); skill.Member(Skill.Web); var gender = builder.EnumType <Gender>(); gender.Member(Gender.Female); gender.Member(Gender.Male); var accessLevel = builder.EnumType <AccessLevel>(); accessLevel.Member(AccessLevel.Execute); accessLevel.Member(AccessLevel.Read); accessLevel.Member(AccessLevel.Write); var favoriteSports = builder.ComplexType <FavoriteSports>(); favoriteSports.EnumProperty <Sport>(f => f.LikeMost); favoriteSports.CollectionProperty <Sport>(f => f.Like); var sport = builder.EnumType <Sport>(); sport.Member(Sport.Basketball); sport.Member(Sport.Pingpong); AddBoundActionsAndFunctions(employee); AddUnboundActionsAndFunctions(builder); EntitySetConfiguration <Employee> employees = builder.EntitySet <Employee>("Employees"); employees.HasEditLink(link, true); employees.HasIdLink(link, true); builder.Namespace = "NS"; return(builder.GetEdmModel()); }
public void CanCreateFunctionThatBindsToEntityCollection() { // Arrange & Act ODataModelBuilder builder = new ODataModelBuilder(); EntityTypeConfiguration <Customer> customer = builder.EntityType <Customer>(); FunctionConfiguration sendEmail = customer.Collection.Function("SendEmail"); // Assert Assert.True(sendEmail.IsBindable); Assert.NotNull(sendEmail.Parameters); Assert.Single(sendEmail.Parameters); Assert.Equal(BindingParameterConfiguration.DefaultBindingParameterName, sendEmail.Parameters.Single().Name); Assert.Equal(string.Format("Collection({0})", typeof(Customer).FullName), sendEmail.Parameters.Single().TypeConfiguration.FullName); }
public void CreateStreamPrimitiveProperty() { ODataModelBuilder builder = new ODataModelBuilder(); var file = builder.EntityType<File>(); var data = file.Property(f => f.StreamData); var model = builder.GetServiceModel(); var fileType = model.SchemaElements.OfType<IEdmEntityType>().Single(); var streamProperty = fileType.DeclaredProperties.SingleOrDefault(p => p.Name == "StreamData"); Assert.Equal(PropertyKind.Primitive, data.Kind); Assert.NotNull(streamProperty); Assert.Equal("Edm.Stream", streamProperty.Type.FullName()); }
private static void BuildFunctions(ODataModelBuilder builder) { FunctionConfiguration function = builder.EntityType<DCustomer>().Function("BoundFunction") .ReturnsCollectionViaEntitySetPath<DCustomer>("bindingParameter"); function.Parameter<Date>("modifiedDate"); function.Parameter<TimeOfDay>("modifiedTime"); function.Parameter<Date?>("nullableModifiedDate"); function.Parameter<TimeOfDay?>("nullableModifiedTime"); function = builder.Function("UnboundFunction").ReturnsCollectionFromEntitySet<DCustomer>("DCustomers"); function.Parameter<Date>("modifiedDate"); function.Parameter<TimeOfDay>("modifiedTime"); function.Parameter<Date?>("nullableModifiedDate"); function.Parameter<TimeOfDay?>("nullableModifiedTime"); }
public void CanCreateEntityWithCompoundKey() { var builder = new ODataModelBuilder(); var customer = builder.EntityType<Customer>(); customer.HasKey(c => new { c.CustomerId, c.Name }); customer.Property(c => c.SharePrice); customer.Property(c => c.ShareSymbol); customer.Property(c => c.Website); var model = builder.GetServiceModel(); var customerType = model.FindType(typeof(Customer).FullName) as IEdmEntityType; Assert.Equal(5, customerType.Properties().Count()); Assert.Equal(2, customerType.DeclaredKey.Count()); Assert.NotNull(customerType.DeclaredKey.SingleOrDefault(k => k.Name == "CustomerId")); Assert.NotNull(customerType.DeclaredKey.SingleOrDefault(k => k.Name == "Name")); }
public void GetEntry_UsesRouteModel_ForMultipleModels() { // Model 1 only has Name, Model 2 only has Age ODataModelBuilder builder1 = new ODataModelBuilder(); var personType1 = builder1.EntityType<FormatterPerson>(); personType1.HasKey(p => p.PerId); personType1.Property(p => p.Name); builder1.EntitySet<FormatterPerson>("People").HasIdLink(p => new Uri("http://link/"), false); var model1 = builder1.GetEdmModel(); ODataModelBuilder builder2 = new ODataModelBuilder(); var personType2 = builder2.EntityType<FormatterPerson>(); personType2.HasKey(p => p.PerId); personType2.Property(p => p.Age); builder2.EntitySet<FormatterPerson>("People").HasIdLink(p => new Uri("http://link/"), false); var model2 = builder2.GetEdmModel(); var config = new[] { typeof(PeopleController) }.GetHttpConfiguration(); config.MapODataServiceRoute("OData1", "v1", model1); config.MapODataServiceRoute("OData2", "v2", model2); using (HttpServer host = new HttpServer(config)) using (HttpClient client = new HttpClient(host)) { using (HttpResponseMessage response = client.GetAsync("http://localhost/v1/People(10)").Result) { Assert.True(response.IsSuccessStatusCode); JToken json = JToken.Parse(response.Content.ReadAsStringAsync().Result); // Model 1 has the Name property but not the Age property Assert.NotNull(json["Name"]); Assert.Null(json["Age"]); } using (HttpResponseMessage response = client.GetAsync("http://localhost/v2/People(10)").Result) { Assert.True(response.IsSuccessStatusCode); JToken json = JToken.Parse(response.Content.ReadAsStringAsync().Result); // Model 2 has the Age property but not the Name property Assert.Null(json["Name"]); Assert.NotNull(json["Age"]); } } }
public static IEdmModel GetExplicitModel() { ODataModelBuilder builder = new ODataModelBuilder(); var fileType = builder.EntityType<File>().HasKey(f => f.FileId); fileType.Property(f => f.Name); fileType.Property(f => f.CreatedDate); fileType.Property(f => f.DeleteDate); fileType.CollectionProperty(f => f.ModifiedDates); var files = builder.EntitySet<File>("Files"); files.HasIdLink(link, true); files.HasEditLink(link, true); BuildFunctions(builder); BuildActions(builder); return builder.GetEdmModel(); }
public void CanCreateEntityWithCompoundKey_ForDateAndTimeOfDay() { // Arrange var builder = new ODataModelBuilder(); var entity = builder.EntityType<EntityTypeWithDateAndTimeOfDay>(); entity.HasKey(e => new { e.Date, e.TimeOfDay }); // Act var model = builder.GetServiceModel(); // Assert var entityType = model.SchemaElements.OfType<IEdmEntityType>().Single(e => e.Name == "EntityTypeWithDateAndTimeOfDay"); Assert.Equal(2, entityType.Properties().Count()); Assert.Equal(2, entityType.DeclaredKey.Count()); Assert.NotNull(entityType.DeclaredKey.SingleOrDefault(k => k.Name == "Date")); Assert.NotNull(entityType.DeclaredKey.SingleOrDefault(k => k.Name == "TimeOfDay")); }
public void CreateDatePrimitiveProperty() { // Arrange ODataModelBuilder builder = new ODataModelBuilder(); EntityTypeConfiguration<File> file = builder.EntityType<File>(); PrimitivePropertyConfiguration date = file.Property(f => f.DateProperty); // Act IEdmModel model = builder.GetServiceModel(); // Assert Assert.Equal(PropertyKind.Primitive, date.Kind); IEdmEntityType fileType = Assert.Single(model.SchemaElements.OfType<IEdmEntityType>()); IEdmProperty dateProperty = Assert.Single(fileType.DeclaredProperties.Where(p => p.Name == "DateProperty")); Assert.NotNull(dateProperty); Assert.Equal("Edm.Date", dateProperty.Type.FullName()); }
private static void BuildActions(ODataModelBuilder builder) { ActionConfiguration action = builder.EntityType<DCustomer>().Action("BoundAction"); action.Parameter<Date>("modifiedDate"); action.Parameter<TimeOfDay>("modifiedTime"); action.Parameter<Date?>("nullableModifiedDate"); action.Parameter<TimeOfDay?>("nullableModifiedTime"); action.CollectionParameter<Date>("dates"); action = builder.Action("UnboundAction"); action.Parameter<Date>("modifiedDate"); action.Parameter<TimeOfDay>("modifiedTime"); action.Parameter<Date?>("nullableModifiedDate"); action.Parameter<TimeOfDay?>("nullableModifiedTime"); action.CollectionParameter<Date>("dates"); // just for reset the data source builder.Action("ResetDataSource"); }
private static void AddBoundActionsAndFunctions(ODataModelBuilder builder) { var paymentInstrumentType = builder.EntityType<PaymentInstrument>(); var actionConfiguration = paymentInstrumentType.Collection.Action("Clear"); actionConfiguration.Parameter<string>("nameContains"); actionConfiguration.Returns<int>();// deleted count // Bug 2021-Should support Action/Function returns contained entities. //paymentInstrumentType.Action("Duplicate").Returns<PaymentInstrument>(); paymentInstrumentType.Action("Delete"); var functionConfiguration = paymentInstrumentType.Collection.Function("GetCount"); functionConfiguration.Parameter<string>("nameContains"); functionConfiguration.Returns<int>(); builder.Action("ResetDataSource"); }
public void GetIfMatchOrNoneMatch_ReturnsETag_SetETagHeaderValue(string header) { // Arrange HttpRequestMessage request = new HttpRequestMessage(); HttpConfiguration cofiguration = new HttpConfiguration(); request.SetConfiguration(cofiguration); Dictionary<string, object> properties = new Dictionary<string, object> { { "Name", "Foo" } }; EntityTagHeaderValue etagHeaderValue = new DefaultODataETagHandler().CreateETag(properties); if (header.Equals("IfMatch")) { request.Headers.IfMatch.Add(etagHeaderValue); } else { request.Headers.IfNoneMatch.Add(etagHeaderValue); } ODataModelBuilder builder = new ODataModelBuilder(); EntityTypeConfiguration<Customer> customer = builder.EntityType<Customer>(); customer.HasKey(c => c.Id); customer.Property(c => c.Id); customer.Property(c => c.Name).IsConcurrencyToken(); builder.EntitySet<Customer>("Customers"); IEdmModel model = builder.GetEdmModel(); var customers = model.FindDeclaredEntitySet("Customers"); Mock<ODataPathSegment> mockSegment = new Mock<ODataPathSegment> { CallBase = true }; mockSegment.Setup(s => s.GetEdmType(null)).Returns(model.GetEdmType(typeof(Customer))); mockSegment.Setup(s => s.GetNavigationSource(null)).Returns((IEdmNavigationSource)customers); ODataPath odataPath = new ODataPath(new[] { mockSegment.Object }); request.ODataProperties().Path = odataPath; request.ODataProperties().Model = model; ODataQueryContext context = new ODataQueryContext(model, typeof(Customer)); // Act ODataQueryOptions<Customer> query = new ODataQueryOptions<Customer>(context, request); ETag result = header.Equals("IfMatch") ? query.IfMatch : query.IfNoneMatch; dynamic dynamicResult = result; // Assert Assert.Equal("Foo", result["Name"]); Assert.Equal("Foo", dynamicResult.Name); }
public static IEdmModel GetExplicitModel() { ODataModelBuilder builder = new ODataModelBuilder(); EntityTypeConfiguration<Window> windowType = builder.EntityType<Window>(); windowType.HasKey(a => a.Id); windowType.Property(a => a.Name).IsRequired(); windowType.ComplexProperty(w => w.CurrentShape); windowType.CollectionProperty(w => w.OptionalShapes); windowType.HasOptional<Window>(w => w.Parent); ComplexTypeConfiguration<Shape> shapeType = builder.ComplexType<Shape>(); shapeType.Property(s => s.HasBorder); shapeType.Abstract(); ComplexTypeConfiguration<Circle> circleType = builder.ComplexType<Circle>(); circleType.ComplexProperty(c => c.Center); circleType.Property(c => c.Radius); circleType.DerivesFrom<Shape>(); ComplexTypeConfiguration<Polygon> polygonType = builder.ComplexType<Polygon>(); polygonType.CollectionProperty(p => p.Vertexes); polygonType.DerivesFrom<Shape>(); ComplexTypeConfiguration<Rectangle> rectangleType = builder.ComplexType<Rectangle>(); rectangleType.ComplexProperty(r => r.TopLeft); rectangleType.Property(r => r.Width); rectangleType.Property(r => r.Height); rectangleType.DerivesFrom<Polygon>(); ComplexTypeConfiguration<Point> pointType = builder.ComplexType<Point>(); pointType.Property(p => p.X); pointType.Property(p => p.Y); EntitySetConfiguration<Window> windows = builder.EntitySet<Window>("Windows"); windows.HasEditLink(link, true); windows.HasIdLink(link, true); builder.Namespace = typeof(Window).Namespace; return builder.GetEdmModel(); }
public static IEdmModel GetExplicitModel() { ODataModelBuilder builder = new ODataModelBuilder(); var employee = builder.EntityType<Employee>(); employee.HasKey(c => c.ID); employee.Property(c => c.Name); employee.CollectionProperty<Skill>(c => c.SkillSet); employee.EnumProperty<Gender>(c => c.Gender); employee.EnumProperty<AccessLevel>(c => c.AccessLevel); employee.ComplexProperty<FavoriteSports>(c => c.FavoriteSports); var skill = builder.EnumType<Skill>(); skill.Member(Skill.CSharp); skill.Member(Skill.Sql); skill.Member(Skill.Web); var gender = builder.EnumType<Gender>(); gender.Member(Gender.Female); gender.Member(Gender.Male); var accessLevel = builder.EnumType<AccessLevel>(); accessLevel.Member(AccessLevel.Execute); accessLevel.Member(AccessLevel.Read); accessLevel.Member(AccessLevel.Write); var favoriteSports = builder.ComplexType<FavoriteSports>(); favoriteSports.EnumProperty<Sport>(f => f.LikeMost); favoriteSports.CollectionProperty<Sport>(f => f.Like); var sport = builder.EnumType<Sport>(); sport.Member(Sport.Basketball); sport.Member(Sport.Pingpong); AddBoundActionsAndFunctions(employee); AddUnboundActionsAndFunctions(builder); EntitySetConfiguration<Employee> employees = builder.EntitySet<Employee>("Employees"); builder.Namespace = typeof(Employee).Namespace; return builder.GetEdmModel(); }
public void NonbindingParameterConfigurationSupportsParameterCollectionTypeAs(Type type, bool isNullable) { // Arrange ODataModelBuilder builder = new ODataModelBuilder(); builder.EntityType<Customer>(); builder.ComplexType<Address>(); builder.EnumType<Color>(); Type elementType; Assert.True(type.IsCollection(out elementType)); // Act Type underlyingType = TypeHelper.GetUnderlyingTypeOrSelf(elementType); IEdmTypeConfiguration elementTypeConfiguration = builder.GetTypeConfigurationOrNull(underlyingType); CollectionTypeConfiguration collectionType = new CollectionTypeConfiguration(elementTypeConfiguration, typeof(IEnumerable<>).MakeGenericType(elementType)); NonbindingParameterConfiguration parameter = new NonbindingParameterConfiguration("name", collectionType); // Assert Assert.Equal(isNullable, parameter.OptionalParameter); }
public void CreateDatePrimitiveProperty_FromDateTime() { // Arrange ODataModelBuilder builder = new ODataModelBuilder(); EntityTypeConfiguration<File> file = builder.EntityType<File>(); file.Property(f => f.Birthday).AsDate(); file.Property(f => f.PublishDay).AsDate(); // Act IEdmModel model = builder.GetServiceModel(); // Assert IEdmEntityType fileType = Assert.Single(model.SchemaElements.OfType<IEdmEntityType>()); IEdmProperty birthdayProperty = Assert.Single(fileType.DeclaredProperties.Where(p => p.Name == "Birthday")); Assert.NotNull(birthdayProperty); Assert.False(birthdayProperty.Type.IsNullable); Assert.Equal("Edm.Date", birthdayProperty.Type.FullName()); IEdmProperty publishDayProperty = Assert.Single(fileType.DeclaredProperties.Where(p => p.Name == "PublishDay")); Assert.NotNull(publishDayProperty); Assert.True(publishDayProperty.Type.IsNullable); Assert.Equal("Edm.Date", publishDayProperty.Type.FullName()); }