public static void Register(System.Web.Http.HttpConfiguration config) { // Web-API-Konfiguration und -Dienste // Web-API-Routen config.MapHttpAttributeRoutes(); //ODataModelBuilder builder = new ODataConventionModelBuilder(); //builder.EntitySet<Contracts.IResident>("Residents"); //config.AddODataQueryFilter(new System.Web.Http.Filters.ActionFilterAttribute() ); //config.Routes.MapODataRoute("ODataRoute", "odata", GetEdmModel()); //ODataModelBuilder builder = new ODataConventionModelBuilder(); //builder.EntitySet<Models.ResidentViewModel>("Residents"); //config.MapODataServiceRoute( // routeName: "ODataRoute", // routePrefix: "odata", // model: builder.GetEdmModel()); ODataConventionModelBuilder builder = new ODataConventionModelBuilder(); builder.EntitySet<Models.ResidentViewModel>("ResidentViewModels"); config.AddODataQueryFilter(); //config.MapODataServiceRoute(routeName: "oDataRoute", routePrefix: "odata", model: builder.GetEdmModel()); config.MapODataServiceRoute(routeName: "oDataRoute", routePrefix: "odata", model: builder.GetEdmModel()); config.Routes.MapHttpRoute( name: "DefaultApi", routeTemplate: "api/{controller}/{id}", defaults: new { id = RouteParameter.Optional } ); //config.MapODataServiceRoute( "odata", null, GetEdmModel(), new DefaultODataBatchHandler(GlobalConfiguration.DefaultServer)); config.EnsureInitialized(); }
public static void Register(HttpConfiguration config) { // Web API configuration and services // Web API routes config.MapHttpAttributeRoutes(); config.Routes.MapHttpRoute( name: "DefaultApi", routeTemplate: "api/{controller}/{id}", defaults: new { id = RouteParameter.Optional } ); // OData ODataModelBuilder builder = new ODataConventionModelBuilder(); builder.EntitySet<Player>("Players"); builder.EntitySet<BattingDetail>("BattingDetails"); builder.EntitySet<BowlingDetail>("BowlingDetails"); builder.EntitySet<Country>("Countrys"); builder.EntitySet<Match>("Matches").EntityType.HasKey(m => m.MatchNumber); config.AddODataQueryFilter(); config.MapODataServiceRoute( routeName: "odata", routePrefix: "odata", model: builder.GetEdmModel()); }
private static IEdmModel GetEdmModel(HttpConfiguration config) { var modelBuilder = new ODataConventionModelBuilder(config); var moviesEntitySet = modelBuilder.EntitySet<Movie>("Movies"); // Now add actions. // CheckOut // URI: ~/odata/Movies(1)/ODataActionsSample.Models.CheckOut ActionConfiguration checkOutAction = modelBuilder.EntityType<Movie>().Action("CheckOut"); checkOutAction.ReturnsFromEntitySet<Movie>("Movies"); // ReturnMovie // URI: ~/odata/Movies(1)/ODataActionsSample.Models.Return // Binds to a single entity; no parameters. ActionConfiguration returnAction = modelBuilder.EntityType<Movie>().Action("Return"); returnAction.ReturnsFromEntitySet<Movie>("Movies"); // CheckOutMany action // URI: ~/odata/Movies/ODataActionsSample.Models.CheckOutMany // Binds to a collection of entities. This action accepts a collection of parameters. ActionConfiguration checkOutManyAction = modelBuilder.EntityType<Movie>().Collection.Action("CheckOutMany"); checkOutManyAction.CollectionParameter<int>("MovieIDs"); checkOutManyAction.ReturnsCollectionFromEntitySet<Movie>("Movies"); // CreateMovie action // URI: ~/odata/CreateMovie // Unbound action. It is invoked from the service root. ActionConfiguration createMovieAction = modelBuilder.Action("CreateMovie"); createMovieAction.Parameter<string>("Title"); createMovieAction.ReturnsFromEntitySet<Movie>("Movies"); modelBuilder.Namespace = typeof(Movie).Namespace; return modelBuilder.GetEdmModel(); }
public void NavigationLinksGenerationConvention_GeneratesLinksWithCast_ForDerivedProperties() { ODataConventionModelBuilder builder = new ODataConventionModelBuilder(); builder.EntitySet<Vehicle>("vehicles"); builder.EntitySet<Manufacturer>("manufacturers"); IEdmModel model = builder.GetEdmModel(); IEdmEntitySet vehiclesEdmEntitySet = model.EntityContainer.FindEntitySet("vehicles"); IEdmEntityType carType = model.AssertHasEntityType(typeof(Car)); IEdmNavigationProperty carManufacturerProperty = carType.AssertHasNavigationProperty(model, "Manufacturer", typeof(CarManufacturer), isNullable: true, multiplicity: EdmMultiplicity.ZeroOrOne); HttpConfiguration configuration = new HttpConfiguration(); string routeName = "Route"; configuration.Routes.MapODataServiceRoute(routeName, null, model); HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, "http://localhost"); request.SetConfiguration(configuration); request.ODataProperties().RouteName = routeName; NavigationSourceLinkBuilderAnnotation linkBuilder = model.GetNavigationSourceLinkBuilder(vehiclesEdmEntitySet); var serializerContext = new ODataSerializerContext { Model = model, NavigationSource = vehiclesEdmEntitySet, Url = request.GetUrlHelper() }; var entityContext = new EntityInstanceContext(serializerContext, carType.AsReference(), new Car { Model = 2009, Name = "Accord" }); Uri uri = linkBuilder.BuildNavigationLink(entityContext, carManufacturerProperty, ODataMetadataLevel.Default); Assert.Equal("http://localhost/vehicles(Model=2009,Name='Accord')/System.Web.OData.Builder.TestModels.Car/Manufacturer", uri.AbsoluteUri); }
public static void Register(HttpConfiguration httpConfiguration) { ODataModelBuilder builder = new ODataConventionModelBuilder(); builder.Namespace = "ODataV4TestService.Models"; builder.EntitySet<Product>("Products"); builder.EntitySet<SuppliedProduct>("SuppliedProducts"); builder.EntitySet<Supplier>("Suppliers"); builder.EntitySet<Product>("OtherProducts"); builder.ComplexType<Description>(); builder.EntityType<Product>() .Action("Rate") .Parameter<int>("Rating"); builder.EntityType<Product>().Collection .Function("Best") .ReturnsCollectionFromEntitySet<Product>("Products"); var funcConfig = builder .EntityType<Product>() .Function("RelatedProducts") .SetBindingParameter("product", builder.GetTypeConfigurationOrNull(typeof(Product))) //.AddParameter("start", new PrimitiveTypeConfiguration(builder, builder.GetTypeConfigurationOrNull(typeof(DateTimeOffset)), typeof(DateTimeOffset)). .ReturnsCollectionFromEntitySet<Product>("Products"); funcConfig .Parameter<DateTimeOffset>("start"); funcConfig .Parameter<DateTimeOffset>("end"); //builder.Function("GetSalesTaxRate") // .Returns<double>() // .Parameter<int>("PostalCode"); builder.EntitySet<Account>("Accounts"); builder.EntityType<PaymentInstrument>() .Collection .Function("GetCount") .Returns<int>() .Parameter<string>("NameContains"); var model = builder.GetEdmModel(); var conventions = ODataRoutingConventions.CreateDefault(); conventions.Insert(0, new AttributeRoutingConvention(model, httpConfiguration)); var server = new BatchServer(httpConfiguration); httpConfiguration.MapODataServiceRoute( routeName: "ODataRoute", routePrefix: null, model: model, pathHandler: new DefaultODataPathHandler(), routingConventions: conventions, batchHandler: new DefaultODataBatchHandler(server)); httpConfiguration.MessageHandlers.Add(new TracingMessageHandler()); }
public static IEdmModel GetModel() { ODataModelBuilder builder = new ODataConventionModelBuilder(); builder.Namespace = "D"; builder.ContainerName = "Default"; EntitySetConfiguration<City> cities = builder.EntitySet<City>("City"); EntitySetConfiguration<Stadium> stadiums = builder.EntitySet<Stadium>("Stadium"); // Per Collection Stadium FunctionConfiguration getStadiumsWithFunction = stadiums.EntityType.Collection.Function("GetStadiumsWithFunction"); getStadiumsWithFunction.ReturnsCollectionFromEntitySet<Stadium>("Stadium"); // Per Collection Stadium, returns single entity FunctionConfiguration getStadiumsTest = stadiums.EntityType.Collection.Function("GetStadiumTest"); getStadiumsTest.Parameter<string>("test"); getStadiumsTest.Parameter<string>("name"); getStadiumsTest.ReturnsFromEntitySet<Stadium>("Stadium"); // Per Entity (Single key property) City FunctionConfiguration getStadiumFromCityWithFunction = cities.EntityType.Function("GetStadiumsFromCityWithFunction"); getStadiumFromCityWithFunction.ReturnsCollectionFromEntitySet<Stadium>("Stadium"); // Per Entity composite key Stadium FunctionConfiguration getCityFromStadiumWithFunction = stadiums.EntityType.Function("GetCityFromStadiumWithFunction"); getCityFromStadiumWithFunction.ReturnsFromEntitySet<City>("City"); // Global Function builder.Function("GlobalFunction").ReturnsCollectionFromEntitySet<Stadium>("Stadium"); return builder.GetEdmModel(); }
// Builds the EDM model private static IEdmModel GetEdmModel() { var builder = new ODataConventionModelBuilder(); builder.EntitySet<Customer>("Customers"); builder.EntitySet<Order>("Orders"); return builder.GetEdmModel(); }
public void NavigationLinksGenerationConvention_GeneratesLinksWithCast_ForDerivedProperties() { ODataConventionModelBuilder builder = new ODataConventionModelBuilder(); builder.EntitySet<Vehicle>("vehicles"); builder.EntitySet<Manufacturer>("manufacturers"); IEdmModel model = builder.GetEdmModel(); IEdmEntitySet vehiclesEdmEntitySet = model.EntityContainers().Single().FindEntitySet("vehicles"); IEdmEntityType carType = model.AssertHasEntityType(typeof(Car)); IEdmNavigationProperty carManufacturerProperty = carType.AssertHasNavigationProperty(model, "Manufacturer", typeof(CarManufacturer), isNullable: true, multiplicity: EdmMultiplicity.ZeroOrOne); HttpConfiguration configuration = new HttpConfiguration(); configuration.EnableOData(model); HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, "http://localhost"); request.Properties[HttpPropertyKeys.HttpConfigurationKey] = configuration; request.Properties[HttpPropertyKeys.HttpRouteDataKey] = new HttpRouteData(new HttpRoute()); IEntitySetLinkBuilder linkBuilder = model.GetEntitySetLinkBuilder(vehiclesEdmEntitySet); Uri uri = linkBuilder.BuildNavigationLink( new EntityInstanceContext() { EdmModel = model, EntitySet = vehiclesEdmEntitySet, EntityType = carType, UrlHelper = request.GetUrlHelper(), PathHandler = new DefaultODataPathHandler(model), EntityInstance = new Car { Model = 2009, Name = "Accord" } }, carManufacturerProperty); Assert.Equal("http://localhost/vehicles(Model=2009,Name='Accord')/System.Web.Http.OData.Builder.TestModels.Car/Manufacturer", uri.AbsoluteUri); }
public void Apply_Doesnot_Override_UserConfiguration() { ODataConventionModelBuilder builder = new ODataConventionModelBuilder(); var vehicles = builder.EntitySet<Vehicle>("vehicles"); var car = builder.AddEntityType(typeof(Car)); var paintAction = vehicles.EntityType.Action("Paint"); paintAction.HasActionLink(ctxt => new Uri("http://localhost/ActionTestWorks"), followsConventions: false); ActionLinkGenerationConvention convention = new ActionLinkGenerationConvention(); convention.Apply(paintAction, builder); IEdmModel model = builder.GetEdmModel(); var vehiclesEdmSet = model.EntityContainer.FindEntitySet("vehicles"); var carEdmType = model.FindDeclaredType("System.Web.OData.Builder.TestModels.Car") as IEdmEntityType; var paintEdmAction = model.GetAvailableProcedures( model.FindDeclaredType("System.Web.OData.Builder.TestModels.Car") as IEdmEntityType).Single() as IEdmAction; Assert.NotNull(paintEdmAction); HttpConfiguration configuration = new HttpConfiguration(); configuration.Routes.MapODataServiceRoute(model); HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, "http://localhost"); request.SetConfiguration(configuration); ActionLinkBuilder actionLinkBuilder = model.GetActionLinkBuilder(paintEdmAction); var serializerContext = new ODataSerializerContext { Model = model, NavigationSource = vehiclesEdmSet, Url = request.GetUrlHelper() }; var entityContext = new EntityInstanceContext(serializerContext, carEdmType.AsReference(), new Car { Model = 2009, Name = "Contoso" }); Uri link = actionLinkBuilder.BuildActionLink(entityContext); Assert.Equal("http://localhost/ActionTestWorks", link.AbsoluteUri); }
private IEdmModel GetEdmModel() { ODataConventionModelBuilder builder = new ODataConventionModelBuilder(); builder.EntitySet<Customer>("FormatCustomers"); builder.Singleton<Customer>("This"); // Singleton return builder.GetEdmModel(); }
public void Validate_DepthChecks_DollarLevels(string expand, int maxExpansionDepth) { // Arrange var validator = new SelectExpandQueryValidator(); var builder = new ODataConventionModelBuilder(); builder.EntitySet<ODataLevelsTest.LevelsEntity>("Entities"); IEdmModel model = builder.GetEdmModel(); var context = new ODataQueryContext(model, typeof(ODataLevelsTest.LevelsEntity)); var selectExpandQueryOption = new SelectExpandQueryOption(null, expand, context); selectExpandQueryOption.LevelsMaxLiteralExpansionDepth = 1; // Act & Assert Assert.Throws<ODataException>( () => validator.Validate( selectExpandQueryOption, new ODataValidationSettings { MaxExpansionDepth = maxExpansionDepth }), String.Format( CultureInfo.CurrentCulture, "The request includes a $expand path which is too deep. The maximum depth allowed is {0}. " + "To increase the limit, set the 'MaxExpansionDepth' property on EnableQueryAttribute or ODataValidationSettings.", maxExpansionDepth)); Assert.DoesNotThrow( () => validator.Validate( selectExpandQueryOption, new ODataValidationSettings { MaxExpansionDepth = maxExpansionDepth + 1 })); }
private static IEdmModel GetModel() { ODataModelBuilder builder = new ODataConventionModelBuilder(); builder.ContainerName = "CustomersContext"; builder.EntitySet<Customer>("Customers"); return builder.GetEdmModel(); }
private static IEdmModel GetModel() { const string UsersSet = "Users"; const string FriendshipsSet = "Friendships"; const string TweetsSet = "Tweets"; var builder = new ODataConventionModelBuilder(); var users = builder.EntitySet<User>(UsersSet); builder.EntitySet<Friendship>(FriendshipsSet); builder.EntitySet<Tweet>(TweetsSet); users.EntityType.Ignore(u => u.Password); users.EntityType.Ignore(u => u.Email); // nameof(...) == "Login" builder.Namespace = "TwitterApi"; var login = users.EntityType.Collection.Action(nameof(UsersController.Login)); login.Parameter<string>(nameof(User.Password)); login.Parameter<string>(nameof(User.Email)); login.Returns<AuthenticateResponse>(); var me = users.EntityType.Collection.Function(nameof(UsersController.Me)); me.ReturnsFromEntitySet<User>(UsersSet); return builder.GetEdmModel(); }
public static void Register(HttpConfiguration config) { // Web API configuration and services // Web API routes //config.MapHttpAttributeRoutes(); //config.Routes.MapHttpRoute( // name: "DefaultApi", // routeTemplate: "api/{controller}/{id}", // defaults: new { id = RouteParameter.Optional } //); config.EnableCors(); var appXmlType = config.Formatters.XmlFormatter.SupportedMediaTypes.FirstOrDefault(t => t.MediaType == "application/xml"); config.Formatters.XmlFormatter.SupportedMediaTypes.Remove(appXmlType); ODataConventionModelBuilder builder = new ODataConventionModelBuilder(); builder.Namespace = "Demos"; builder.ContainerName = "DefaultContainer"; builder.EntitySet<Person>("Peoples"); config.MapODataServiceRoute( routeName: "ODataRoute", routePrefix: "odata", model: builder.GetEdmModel()); // config.MapODataServiceRoute("odata", "odata", GetEdmModel(), new DefaultODataBatchHandler(GlobalConfiguration.DefaultServer)); config.EnsureInitialized(); }
public static IEdmModel GetEdmModel() { var builder = new ODataConventionModelBuilder(); builder.EntitySet<Product>("Products"); builder.EntitySet<Part>("Parts"); return builder.GetEdmModel(); }
private static IEdmModel GetEdmModel() { var builder = new ODataConventionModelBuilder(); builder.EntitySet<ResponseDataModel>("Users"); builder.EntitySet<CustomerCardAdministrationDataModel>("CustomerCards"); return builder.GetEdmModel(); }
private static IEdmModel GetInheritanceModel(HttpConfiguration config) { ODataModelBuilder builder = new ODataConventionModelBuilder(config); var baseEntitySet = builder.EntitySet<BaseEntity>("BaseEntity"); var derivedEntityType = builder.EntityType<DerivedEntity>().DerivesFrom<BaseEntity>(); return builder.GetEdmModel(); }
public ParameterAliasNodeTranslatorTest() { var builder = new ODataConventionModelBuilder(); builder.EntitySet<ParameterAliasCustomer>("Customers"); builder.EntitySet<ParameterAliasOrder>("Orders"); builder.EntityType<ParameterAliasCustomer>().Function("CollectionFunctionCall") .ReturnsCollection<int>().Parameter<int>("p1"); builder.EntityType<ParameterAliasCustomer>().Function("EntityCollectionFunctionCall") .ReturnsCollectionFromEntitySet<ParameterAliasCustomer>("Customers").Parameter<int>("p1"); builder.EntityType<ParameterAliasCustomer>().Function("SingleEntityFunctionCall") .Returns<ParameterAliasCustomer>().Parameter<int>("p1"); builder.EntityType<ParameterAliasCustomer>().Function("SingleEntityFunctionCallWithoutParameters") .Returns<ParameterAliasCustomer>(); builder.EntityType<ParameterAliasCustomer>().Function("SingleValueFunctionCall") .Returns<int>().Parameter<int>("p1"); _model = builder.GetEdmModel(); _customersEntitySet = _model.FindDeclaredEntitySet("Customers"); _customerEntityType = _customersEntitySet.EntityType(); _parameterAliasMappedNode = new ConstantNode(123); }
private static IEdmModel GetSampleModel() { ODataConventionModelBuilder builder = new ODataConventionModelBuilder(); builder.EntitySet<Employee>("employees"); builder.EntitySet<WorkItem>("workitems"); return builder.GetEdmModel(); }
public override IEdmModel GetModel(Type elementClrType, HttpRequestMessage request, HttpActionDescriptor actionDescriptor) { // Get model for the request IEdmModel model = request.ODataProperties().Model; if (model == null) { // user has not configured anything or has registered a model without the element type // let's create one just for this type and cache it in the action descriptor model = actionDescriptor.Properties.GetOrAdd("System.Web.OData.Model+" + elementClrType.FullName, _ => { ODataConventionModelBuilder builder = new ODataConventionModelBuilder(actionDescriptor.Configuration, isQueryCompositionMode: true); builder.EnableLowerCamelCase(); EntityTypeConfiguration entityTypeConfiguration = builder.AddEntityType(elementClrType); builder.AddEntitySet(elementClrType.Name, entityTypeConfiguration); IEdmModel edmModel = builder.GetEdmModel(); Contract.Assert(edmModel != null); return edmModel; }) as IEdmModel; } Contract.Assert(model != null); return model; }
public static void Register(HttpConfiguration config) { // Web API 配置和服务 // 将 Web API 配置为仅使用不记名令牌身份验证。 config.SuppressDefaultHostAuthentication(); config.Filters.Add(new HostAuthenticationFilter(OAuthDefaults.AuthenticationType)); // Web API 路由 config.MapHttpAttributeRoutes(); config.Routes.MapHttpRoute( name: "DefaultApi", routeTemplate: "api/{controller}/{id}", defaults: new { id = RouteParameter.Optional } ); //有关OData //使用ODataConventionModelBuilder创建EDM使用了一些惯例 //如果要对创建EDM有更多的控制,使用ODataModelBuilder ODataModelBuilder builder = new ODataConventionModelBuilder(); builder.EntitySet<Product>("Products");//创建EntityDataModel(EDM) builder.EntitySet<Supplier>("Suppliers"); config.MapODataServiceRoute( routeName: "ODataRoute", routePrefix: "odata", model: builder.GetEdmModel()); }
private static IEdmModel GetModel() { ODataConventionModelBuilder builder = new ODataConventionModelBuilder(); EntitySetConfiguration<Trade> tradesConfiguration = builder.EntitySet<Trade>("Trades"); //Add bound function var boundFunction = tradesConfiguration.EntityType.Collection.Function("GetTradingVolume"); boundFunction.Parameter<string>("productName"); boundFunction.Parameter<Country>("portingCountry"); boundFunction.Returns<long?>(); //Add bound function boundFunction = tradesConfiguration.EntityType.Collection.Function("GetTopTrading"); boundFunction.Parameter<string>("productName"); boundFunction.ReturnsFromEntitySet<Trade>("Trades"); boundFunction.IsComposable = true; //Add unbound function var unboundFunction = builder.Function("GetTradeByCountry"); unboundFunction.Parameter<Country>("portingCountry"); unboundFunction.ReturnsCollectionFromEntitySet<Trade>("Trades"); builder.Namespace = typeof(Country).Namespace; return builder.GetEdmModel(); }
public static void Register(HttpConfiguration config) { config.EnableCors(); config.MapHttpAttributeRoutes(); config.Routes.MapHttpRoute( name: "DefaultApi", routeTemplate: "api/{controller}/{id}", defaults: new { id = RouteParameter.Optional } ); ODataConventionModelBuilder builder = new ODataConventionModelBuilder(); builder.EntitySet<Exercise>("Exercises"); builder.EntitySet<Workout>("Workouts"); builder.EntitySet<WorkoutSession>("WorkoutSessions"); builder.EntitySet<ExerciseSet>("ExerciseSets"); builder.EnableLowerCamelCase(); // Need this. Otherwise SingleResult<WorkoutSession> GetWorkoutSession tries to return null and then fails to serialize the null value. config.MapODataServiceRoute( "odata" , "odata" , builder.GetEdmModel() , defaultHandler: HttpClientFactory.CreatePipeline( innerHandler: new HttpControllerDispatcher(config) , handlers: new[] { new ODataNullValueMessageHandler() })); }
private static IEdmModel GetEdmModel() { ODataConventionModelBuilder builder = new ODataConventionModelBuilder(); builder.EntitySet<Person>("Persons"); var edmModel = builder.GetEdmModel(); return edmModel; }
private static IEdmModel GetEdmModel() { ODataModelBuilder builder = new ODataConventionModelBuilder(); builder.Singleton<Corporation>("Oscorp"); builder.EntitySet<Subsidiary>("OscorpSubs"); return builder.GetEdmModel(); }
// For more information on configuring authentication, please visit http://go.microsoft.com/fwlink/?LinkId=301864 public void ConfigureWebApi(IAppBuilder app) { var config = new HttpConfiguration(); // Web API routes config.MapHttpAttributeRoutes(); //NB Must come before OData route mapping config.Routes.MapHttpRoute("DefaultApi", "api/{controller}/{id}", new { id = RouteParameter.Optional }); // OData: Create the OData model. Here, we're using the convention model builder that will use OData // convention defaults for model creation and routing. ODataConventionModelBuilder builder = new ODataConventionModelBuilder(); // All entity properties should be in lower camel case builder.EnableLowerCamelCase(); // Because PersonSearchHit inherits from SearchHit, we'll ignore it. // This gets around the convention builder's decision to create an entity out of the SearchHit object. builder.Ignore<PersonSearchHit>(); // Create two entity sets: // One for search features and one that will retrieve a given person. builder.EntitySet<IndexSearch>("Search"); builder.EntitySet<Person>("People"); // OData model registration and route creation config.MapODataServiceRoute("ODataRoute", null, builder.GetEdmModel()); // Set up the bearer token that will be required to do OData calls. WebApiConfigBearerToken.Configure(config); app.UseWebApi(config); }
private static IEdmModel GenerateEdmModel() { var builder = new ODataConventionModelBuilder(); builder.EntitySet<Product>("Products"); return builder.GetEdmModel(); }
public void Convention_GeneratesUri_ForActionBoundToEntity() { // Arrange ODataConventionModelBuilder builder = new ODataConventionModelBuilder(); builder.EntitySet<Customer>("Customers"); var action = builder.EntityType<Customer>().Action("MyAction"); action.Parameter<string>("param"); IEdmModel model = builder.GetEdmModel(); // Act HttpConfiguration configuration = new HttpConfiguration(); configuration.MapODataServiceRoute("odata", "odata", model); HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, "http://localhost:123"); request.SetConfiguration(configuration); request.ODataProperties().RouteName = "odata"; IEdmEntitySet customers = model.EntityContainer.FindEntitySet("Customers"); var edmType = model.SchemaElements.OfType<IEdmEntityType>().First(e => e.Name == "Customer"); var serializerContext = new ODataSerializerContext { Model = model, NavigationSource = customers, Url = request.GetUrlHelper() }; var entityContext = new EntityInstanceContext(serializerContext, edmType.AsReference(), new Customer { Id = 109 }); // Assert var edmAction = model.SchemaElements.OfType<IEdmAction>().First(f => f.Name == "MyAction"); Assert.NotNull(edmAction); ActionLinkBuilder actionLinkBuilder = model.GetActionLinkBuilder(edmAction); Uri link = actionLinkBuilder.BuildActionLink(entityContext); Assert.Equal("http://localhost:123/odata/Customers(109)/Default.MyAction", link.AbsoluteUri); }
protected static IEdmModel GetEdmModel(HttpConfiguration config) { ODataModelBuilder builder = new ODataConventionModelBuilder(config); var entitySet = builder.EntitySet<StubEntity>("StubEntity"); entitySet.EntityType.Collection.Action("Paged").ReturnsCollectionFromEntitySet<StubEntity>("StubEntity"); return builder.GetEdmModel(); }
private static IEdmModel GetModel() { ODataModelBuilder builder = new ODataConventionModelBuilder(); EntitySetConfiguration<OrderByCustomer> customers = builder.EntitySet<OrderByCustomer>("OrderByCustomers"); EntitySetConfiguration<OrderByOrder> orders = builder.EntitySet<OrderByOrder>("OrderByOrders"); return builder.GetEdmModel(); }
public static IEdmModel GetEdmModel(IServiceProvider provider) { var builder = new ODataConventionModelBuilder(provider); builder.EntitySet <Developer>(nameof(Developer)).EntityType .Filter() .OrderBy() .Count() .Page() .Select() .Expand(); // .Expand(SelectExpandType.Automatic) // Enables Select for TaskToDo IF it isn't configured // .HasMany(t => t.TasksToDo).Select(); builder.EntitySet <TaskToDo>(nameof(TaskToDo)).EntityType .Expand() .Filter() .OrderBy() .Select(); return(builder.GetEdmModel()); }
public void ConcurrencyCheckAttributeEdmPropertyConvention_DoesnotOverwriteExistingConfiguration() { // Arrange MockType type = new MockType("Entity") .Property(typeof(int), "ID") .Property(typeof(int?), "Count", new ConcurrencyCheckAttribute()); // Act ODataConventionModelBuilder builder = new ODataConventionModelBuilder(); builder.AddEntity(type).AddProperty(type.GetProperty("Count")).IsOptional(); IEdmModel model = builder.GetEdmModel(); // Assert IEdmEntityType entity = model.AssertHasEntityType(type); IEdmStructuralProperty property = entity.AssertHasPrimitiveProperty( model, "Count", EdmPrimitiveTypeKind.Int32, isNullable: true); Assert.Equal(EdmConcurrencyMode.None, property.ConcurrencyMode); }
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline. public void Configure(IApplicationBuilder app, IHostingEnvironment env) { if (env.IsDevelopment()) { app.UseDeveloperExceptionPage(); } else { // The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts. app.UseHsts(); } var odataModelBuilder = new ODataConventionModelBuilder(app.ApplicationServices); app.UseHttpsRedirection(); app.UseMvc(routeBuilder => { routeBuilder.EnableDependencyInjection(); routeBuilder.Select().Filter().Expand().MaxTop(100).OrderBy().Count(); routeBuilder.MapODataServiceRoute("odata", "api", odataModelBuilder.GetEdmModel()); }); }
public void ODataMetadataSerializer_Works_ForSingleton() { // Arrange ODataConventionModelBuilder builder = new ODataConventionModelBuilder(); builder.Singleton <Customer>("Me"); builder.EntitySet <Order>("MyOrders"); IEdmModel model = builder.GetEdmModel(); ODataMetadataSerializer serializer = new ODataMetadataSerializer(); MemoryStream stream = new MemoryStream(); IODataResponseMessage message = new ODataMessageWrapper(stream); ODataMessageWriterSettings settings = new ODataMessageWriterSettings(); // Act serializer.WriteObject(model, typeof(IEdmModel), new ODataMessageWriter(message, settings, model), new ODataSerializerContext()); // Assert stream.Seek(0, SeekOrigin.Begin); string result = new StreamReader(stream).ReadToEnd(); Assert.Contains("<Singleton Name=\"Me\" Type=\"System.Web.OData.Formatter.Serialization.Models.Customer\">", result); }
private static IEdmModel GetEdmModel() { ODataConventionModelBuilder builder = new ODataConventionModelBuilder() { Namespace = "Books" }; EntityTypeConfiguration <Book> booksConfiguration = builder.EntitySet <Book>("Books").EntityType; booksConfiguration.Function("Details").Returns <JsonResult>(); booksConfiguration.Function("Download").Returns <FileResult>(); builder.EntitySet <Author>("Authors").EntityType .Function("Books").ReturnsCollectionFromEntitySet <Book>("Books"); builder.EntitySet <Genre>("Genres").EntityType .Function("Books").ReturnsCollectionFromEntitySet <Book>("Books"); builder.EntitySet <Series>("Series").EntityType .Function("Books").ReturnsCollectionFromEntitySet <Book>("Books"); return(builder.GetEdmModel()); }
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline. public void Configure(IApplicationBuilder app, IHostingEnvironment env) { app.UseAuthentication(); app.UseHealthChecks("/healthcheck"); app.UseMvc(); var builder = new ODataConventionModelBuilder(app.ApplicationServices); //builder.EntitySet<Model.Entity.Company>("Companys"); //builder.EntitySet<Branch>("Branchs"); app.UseMvc(routeBuilder => { routeBuilder.MapODataServiceRoute("ODataRoute", "odata", builder.GetEdmModel()); routeBuilder.Expand(Microsoft.AspNet.OData.Query.QueryOptionSetting.Allowed).Select().Count().OrderBy().Filter().MaxTop(null); routeBuilder.EnableDependencyInjection(); }); app.UseSwagger(); app.UseMvcWithDefaultRoute(); app.UseSwaggerUI(c => { c.SwaggerEndpoint("/swagger/v1/swagger.json", "LiveLarn.Service.User"); }); }
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline. public void Configure(IApplicationBuilder app, IHostingEnvironment env) { if (env.IsDevelopment()) { app.UseDeveloperExceptionPage(); } var builder = new ODataConventionModelBuilder(app.ApplicationServices); builder.Namespace = "Service"; builder.EnableLowerCamelCase(); builder.EntitySet <Product>("Products"); builder.ComplexType <ProductCategory>(); app.UseMvc(routeBuilder => { routeBuilder.MapODataServiceRoute("OData", "odata", builder.GetEdmModel()); // Work-around for #1175 routeBuilder.EnableDependencyInjection(); }); }
public static void Register(HttpConfiguration config) { // Web API configuration and services // Web API routes config.MapHttpAttributeRoutes(); config.Routes.MapHttpRoute( name: "DefaultApi", routeTemplate: "api/{controller}/{id}", defaults: new { id = RouteParameter.Optional } ); ODataConventionModelBuilder builder = new ODataConventionModelBuilder(); config.Count().Filter().OrderBy().Expand().Select().MaxTop(null); builder.EntitySet <LocationCollection>("LocationCollections"); builder.EntitySet <Collection>("Collections"); builder.EntitySet <Location>("Locations"); builder.EntitySet <Shelving>("Shelvings"); builder.EntitySet <ShelfType>("ShelfTypes"); config.MapODataServiceRoute("odata", "odata", builder.GetEdmModel()); }
public void SelfLinksGenerationConvention_Uses_GetByIdWithCast_IfDerivedTypeHasNavigationProperty() { ODataConventionModelBuilder builder = new ODataConventionModelBuilder(); var vehicles = builder.EntitySet <Vehicle>("vehicles"); IEdmModel model = builder.GetEdmModel(); IEdmEntitySet vehiclesEdmEntitySet = model.EntityContainer.EntitySets().Single(); IEdmEntityType carType = model.AssertHasEntityType(typeof(Car)); HttpRequestMessage request = GetODataRequest(model); NavigationSourceLinkBuilderAnnotation linkBuilder = model.GetNavigationSourceLinkBuilder(vehiclesEdmEntitySet); var serializerContext = new ODataSerializerContext { Model = model, NavigationSource = vehiclesEdmEntitySet, Url = request.GetUrlHelper() }; var entityContext = new EntityInstanceContext(serializerContext, carType.AsReference(), new Car { Model = 2009, Name = "Contoso" }); EntitySelfLinks selfLinks = linkBuilder.BuildEntitySelfLinks(entityContext, ODataMetadataLevel.FullMetadata); Assert.Equal("http://localhost/vehicles(Model=2009,Name='Contoso')", selfLinks.IdLink.ToString()); Assert.Equal("http://localhost/vehicles(Model=2009,Name='Contoso')/System.Web.OData.Builder.TestModels.Car", selfLinks.EditLink.ToString()); }
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline. public void Configure(IApplicationBuilder app, IWebHostEnvironment env) { if (env.IsDevelopment()) { app.UseDeveloperExceptionPage(); } app.UseHttpsRedirection(); app.UseRouting(); ODataConventionModelBuilder modelBuilder = new ODataConventionModelBuilder(); modelBuilder.EntitySet <Order>("Orders"); app.UseMvc(routeBuilder => { // and this line to enable OData query option, for example $filter routeBuilder.Select().Expand().Filter().OrderBy().MaxTop(100).Count(); routeBuilder.MapODataServiceRoute("ODataRoute", "odata", modelBuilder.GetEdmModel()); routeBuilder.MapRoute( name: "default", template: "{controller=Orders}/{action=GetById}/{id?}"); routeBuilder.Expand().Select().Filter().Count().OrderBy().MaxTop(1000); }); }
public static void Register(HttpConfiguration config) { // Web API configuration and services ODataConventionModelBuilder builder = new ODataConventionModelBuilder(); var json = config.Formatters.JsonFormatter; json.SerializerSettings.PreserveReferencesHandling = Newtonsoft.Json.PreserveReferencesHandling.Objects; config.Formatters.Remove(config.Formatters.XmlFormatter); builder.EntitySet <Employee>("OdataEmployees"); builder.EntitySet <Department>("Department"); config.Routes.MapODataServiceRoute("odata", "odata", builder.GetEdmModel()); // Web API routes config.MapHttpAttributeRoutes(); config.Routes.MapHttpRoute( name: "DefaultApi", routeTemplate: "api/{controller}/{id}", defaults: new { id = RouteParameter.Optional } ); }
private static void RegisterOData(HttpConfiguration config) { ODataModelBuilder modelBuilder = new ODataConventionModelBuilder(); modelBuilder.EntitySet <Employee>("EmployeesOData"); modelBuilder.EntitySet <Team>("TeamsOData"); modelBuilder.EntitySet <Office>("OfficesOData"); modelBuilder.EntitySet <EmployeePicture>("EmployeePicturesOData"); modelBuilder.EntitySet <Calendar>("CalendarsOData"); modelBuilder.EntitySet <CalendarHolidays>("CalendarHolidaysOData"); modelBuilder.EntitySet <VacationRequest>("VacationRequestsOData"); modelBuilder.Entity <VacationRequest>().Action("AcceptVacation") .Parameter <string>("Reason"); modelBuilder.Entity <VacationRequest>().Action("RejectVacation") .Parameter <string>("Reason"); Microsoft.Data.Edm.IEdmModel model = modelBuilder.GetEdmModel(); config.Routes.MapODataRoute("ODataRoute", "odata", model); config.EnableQuerySupport(); }
private static IEdmModel GetModel() { var builder = new ODataConventionModelBuilder(); var objects = builder.EntitySet <Object>("Objects"); var objectsWithManualExpanding = builder.EntitySet <Object>("ObjectsWithManualExpanding"); var relationships = builder.EntitySet <Relationship>("Relationships"); var objectEntity = objects.EntityType; var relationshipEntity = relationships.EntityType; var objectWithManualExpandingEntity = objectsWithManualExpanding.EntityType; builder.EntitySet <AttributeValue>("AttributeValues"); objectEntity.Expand(nameof(Object.AttributeValues)); relationshipEntity.Expand(nameof(Relationship.AttributeValues)); objectWithManualExpandingEntity.Expand(nameof(Object.AttributeValues)); builder.AddComplexType(typeof(ChoiceValue)); builder.AddComplexType(typeof(HyperlinkValue)); return(builder.GetEdmModel()); }
public static void Register(HttpConfiguration config) { // Web API configuration and services ODataConventionModelBuilder builder = new ODataConventionModelBuilder(); builder.EnableLowerCamelCase(); builder.EntitySet <Core.Entities.User>("Users"); EntityTypeConfiguration <Core.Entities.Organization> organization = builder.EntitySet <Core.Entities.Organization>("Organizations").EntityType; builder.EntitySet <Core.Entities.Affiliation>("Affiliations"); builder.AddEntityType(typeof(Core.Entities.Affiliation)); builder.EntitySet <Core.Entities.Action>("Actions"); builder.EntitySet <Core.Entities.Beacon>("Beacons"); builder.EntitySet <Core.Entities.Event>("Events"); organization.Function("GetAffiliations").ReturnsCollection <Core.Entities.Affiliation>(); organization.Action("AddAffiliation").Parameter <Core.Entities.Affiliation>("affiliation"); organization.Action("RemoveAffiliation").Parameter <Core.Entities.Affiliation>("affiliation"); IEdmModel model = builder.GetEdmModel(); config.MapODataServiceRoute("odata", "api/beta", model); config.SetSerializeNullDynamicProperty(true); }
public static void Register(HttpConfiguration config) { // Web API 設定和服務 ODataConventionModelBuilder builder = new ODataConventionModelBuilder(); builder.EntitySet <Member>("Members"); builder.EntitySet <Item>("Items"); builder.EntitySet <CartBuy>("CartBuys"); config.Routes.MapODataServiceRoute("odata", "odata", builder.GetEdmModel()); builder.EntitySet <CartBuy>("CartBuys"); builder.EntitySet <Item>("Items"); // Web API 路由 config.MapHttpAttributeRoutes(); config.Routes.MapHttpRoute( name: "DefaultApi", routeTemplate: "api/{controller}/{id}", defaults: new { id = RouteParameter.Optional } ); }
public static void Register(HttpConfiguration config) { // Web API configuration and services // Web API routes config.MapHttpAttributeRoutes(); config.Routes.MapHttpRoute( name: "DefaultApi", routeTemplate: "api/{controller}/{id}", defaults: new { id = RouteParameter.Optional } ); config.AddODataQueryFilter(); ODataConventionModelBuilder builder = new ODataConventionModelBuilder(); var people = builder.EntitySet <Person>("People"); var reservations = builder.EntitySet <Reservation>("Reservations"); reservations.EntityType.Ignore(r => r.Price); config.Routes.MapODataServiceRoute("odata", "odata", builder.GetEdmModel()); }
/// <summary> /// Registers the specified configuration. /// </summary> /// <param name="config">The configuration.</param> public static void Register(HttpConfiguration config) { // Web API routes config.MapHttpAttributeRoutes(); config.Routes.MapHttpRoute( name: "DefaultApi", routeTemplate: "api/{controller}/{id}", defaults: new { id = RouteParameter.Optional } ); //OData var builder = new ODataConventionModelBuilder(); builder.EntitySet <Project>("ProjectsOData"); builder.EntitySet <DocumentSet>("DocumentSets"); config.Routes.MapODataRoute("odata", "odata", builder.GetEdmModel()); //JSON serialization var json = config.Formatters.JsonFormatter; json.SerializerSettings.PreserveReferencesHandling = PreserveReferencesHandling.Objects; config.Formatters.Remove(config.Formatters.XmlFormatter); }
public static IEdmModel GetModel() { ODataConventionModelBuilder builder = new ODataConventionModelBuilder(); EntitySetConfiguration <Employee> employees = builder.EntitySet <Employee>("Employees"); EntityTypeConfiguration <Employee> employee = employees.EntityType; // Action that adds a skill to the skill set. ActionConfiguration actionConfiguration = employee.Action("AddAccessLevel"); actionConfiguration.Parameter <string>("AccessLevel");// Now action parameters does not support Enum type, so use string instead. actionConfiguration.Returns <AccessLevel>(); // Function that tells whether an employee has the given AccessLevel var functionConfiguration = builder.Function("HasAccessLevel"); functionConfiguration.Parameter <int>("ID"); functionConfiguration.Parameter <AccessLevel>("AccessLevel"); functionConfiguration.Returns <bool>(); builder.Namespace = typeof(Employee).Namespace; return(builder.GetEdmModel()); }
internal static IEdmModel GetEdmModel(this HttpActionDescriptor actionDescriptor, Type entityClrType) { if (actionDescriptor == null) { throw Error.ArgumentNull("actionDescriptor"); } if (entityClrType == null) { throw Error.ArgumentNull("entityClrType"); } // save the EdmModel to the action descriptor return(actionDescriptor.Properties.GetOrAdd(EdmModelKey + entityClrType.FullName, _ => { ODataConventionModelBuilder builder = new ODataConventionModelBuilder(isQueryCompositionMode: true); IEntityTypeConfiguration entityTypeConfiguration = builder.AddEntity(entityClrType); builder.AddEntitySet(entityClrType.Name, entityTypeConfiguration); IEdmModel edmModel = builder.GetEdmModel(); Contract.Assert(edmModel != null); return edmModel; }) as IEdmModel); }
public void ChangeNavigationLinkShouldWork() { ODataConventionModelBuilder mb = new ODataConventionModelBuilder(); var products = mb.EntitySet <Product>("Products"); mb.OnModelCreating = mb2 => { products.HasNavigationPropertiesLink( products.EntityType.NavigationProperties, (entityContext, navigationProperty) => { object id; entityContext.EdmObject.TryGetPropertyValue("ID", out id); return(new Uri(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)))); }, false); }; var model = mb.GetEdmModel(); }
public static void Register(HttpConfiguration config) { // Web API configuration and services config.EnableQuerySupport(); var cors = new EnableCorsAttribute("*", "*", "*"); config.EnableCors(cors); // Web API routes config.MapHttpAttributeRoutes(); config.Routes.MapHttpRoute( name: "DefaultApi", routeTemplate: "api/{controller}/{id}", defaults: new { id = RouteParameter.Optional } ); ODataConventionModelBuilder builder = new ODataConventionModelBuilder(); builder.EntitySet <Car>("Cars"); config.Routes.MapODataRoute("odata", "odata", builder.GetEdmModel()); }
public void ApplyToEnums_ReturnsCorrectQueryable() { // Arrange var builder = new ODataConventionModelBuilder(); builder.EntitySet <EnumModel>("EnumModels"); var model = builder.GetEdmModel(); var context = new ODataQueryContext(model, typeof(EnumModel)); var orderbyOption = new OrderByQueryOption("Flag", context); IEnumerable <EnumModel> enumModels = FilterQueryOptionTest.EnumModelTestData; // Act IQueryable queryable = orderbyOption.ApplyTo(enumModels.AsQueryable()); // Assert Assert.NotNull(queryable); IEnumerable <EnumModel> actualCustomers = Assert.IsAssignableFrom <IEnumerable <EnumModel> >(queryable); Assert.Equal( new int[] { 2, 1, 3 }, actualCustomers.Select(enumModel => enumModel.Id)); }
public void ConfigureServices(IServiceCollection services) { ODataConventionModelBuilder builder = new ODataConventionModelBuilder(); builder.EntitySet <UserSettingGroup>("UserSettingGroups"); services.AddRazorPages(); // for test preview 3 //services.AddRouting(); //services.AddOData(opt => //{ // opt.SetTimeZoneInfo(TimeZoneInfo.Utc); // opt.Select().Expand().Filter().OrderBy().SetMaxTop(null).Count(); // opt.AddModel("api", builder.GetEdmModel()); //}); services.AddControllers().AddOData(opt => { opt.SetTimeZoneInfo(TimeZoneInfo.Utc); opt.Select().Expand().Filter().OrderBy().SetMaxTop(null).Count(); opt.AddModel("api", builder.GetEdmModel()); }); }
public static void Register(HttpConfiguration config) { ODataModelBuilder builder = new ODataConventionModelBuilder(); builder.EntitySet <JOB>("JOBs"); builder.EntitySet <JOBOTHER>("JOBOTHERs"); builder.EntitySet <JOBLINKsModel>("JOBLINKs"); builder.EntitySet <ACTION_JOB>("ActionJob"); config.Routes.MapODataServiceRoute("odata", "odata", builder.GetEdmModel()); // Web API 配置和服务 // Web API 路由 config.MapHttpAttributeRoutes(); //config.Routes.MapODataServiceRoute( // routeName: "odata", // routePrefix: "odata", // model:builder.GetEdmModel() //); config.EnableQuerySupport(); }
public static IEdmModel getEdmModel(IServiceProvider serviceProvider) { var builder = new ODataConventionModelBuilder(serviceProvider); var products = builder.EntitySet <Product>("Products"); var categories = builder.EntitySet <Category>("Categories"); products.EntityType .Count() .Filter() .Expand(1, new string[] { "Category" }) .Page(5, 2) .OrderBy(new string[] { "ID", "Name" }); categories.EntityType .Count() .Filter() .Expand(1, new string[] { "Products" }) .Page(5, 2) .OrderBy(new string[] { "ID", "Name" }); return(builder.GetEdmModel()); }
private static IEdmModel GetEdmModel(HttpConfiguration configuration) { var builder = new ODataConventionModelBuilder(configuration); EntitySetConfiguration <SelectCustomer> customers = builder.EntitySet <SelectCustomer>("SelectCustomer"); customers.EntityType.Action("CreditRating").Returns <double>(); customers.EntityType.Collection.Action("PremiumCustomers").ReturnsCollectionFromEntitySet <SelectCustomer>("SelectCustomer"); builder.EntitySet <AutoExpandCustomer>("AutoExpandCustomer"); builder.EntitySet <EFSelectCustomer>("EFSelectCustomers"); builder.EntitySet <EFSelectOrder>("EFSelectOrders"); builder.EntitySet <SelectOrderDetail>("SelectOrderDetail"); builder.EntityType <SelectPremiumCustomer>(); builder.EntitySet <SelectOrder>("SelectOrder"); builder.EntitySet <SelectBonus>("SelectBonus"); builder.EntitySet <AutoExpandStuff>("Stuff"); builder.Action("ResetDataSource"); IEdmModel model = builder.GetEdmModel(); return(model); }
public static void Register(HttpConfiguration config) { config.Formatters.Clear(); config.Formatters.Add(new JsonMediaTypeFormatter()); // Web API configuration and services config.EnableCors(); ODataModelBuilder builder = new ODataConventionModelBuilder(); //builder.EntitySet<Part>("parts"); builder.EntitySet <Log>("parser"); config.Routes.MapODataServiceRoute("api", "api", builder.GetEdmModel()); // Web API routes config.MapHttpAttributeRoutes(); config.Routes.MapHttpRoute( name: "DefaultApi", routeTemplate: "api/{controller}/{id}", defaults: new { controller = "Parts", id = RouteParameter.Optional } ); }
public void CreateCollection_PropertyAliased_IfEnabled(bool modelAliasing, string typeName, string propertyName) { // Arrange ODataConventionModelBuilder builder = ODataConventionModelBuilderHelper.CreateWithModelAliasing(modelAliasing); builder.EntitySet <PropertyAlias>("entityset"); IEdmModel model = builder.GetEdmModel(); IEdmEntityType entityType = model.SchemaElements.Single(t => t.Name == typeName) as IEdmEntityType; Assert.NotNull(entityType); // Guard IEdmEntitySet entitySet = model.EntityContainer.FindEntitySet("entityset"); Assert.NotNull(entitySet); // Guard ODataQueryOptionParser parser = new ODataQueryOptionParser(model, entityType, entitySet, new Dictionary <string, string> { { "$orderby", propertyName + " desc, Id asc" } }); OrderByClause orderbyNode = parser.ParseOrderBy(); // Act ICollection <OrderByNode> nodes = OrderByNode.CreateCollection(orderbyNode); // Assert Assert.False(nodes.OfType <OrderByItNode>().Any()); IEnumerable <OrderByPropertyNode> propertyNodes = nodes.OfType <OrderByPropertyNode>(); Assert.Equal(2, propertyNodes.Count()); Assert.Equal(propertyName, propertyNodes.First().Property.Name); Assert.Equal(OrderByDirection.Descending, propertyNodes.First().Direction); Assert.Equal(propertyName, propertyNodes.First().PropertyPath); Assert.Equal("Id", propertyNodes.Last().Property.Name); Assert.Equal(OrderByDirection.Ascending, nodes.Last().Direction); Assert.Equal("Id", propertyNodes.Last().PropertyPath); }
public IEdmModel GetEdmModel(IServiceProvider serviceProvider) { var builder = new ODataConventionModelBuilder(serviceProvider); builder.EntitySet <Book>(nameof(Book)) .EntityType .Filter() // Allow for the $filter Command .Count() // Allow for the $count Command .Expand() // Allow for the $expand Command .OrderBy() // Allow for the $orderby Command .Page() // Allow for the $top and $skip Commands .Select(); // Allow for the $select Command; builder.EntitySet <Author>(nameof(Author)) .EntityType .Filter() // Allow for the $filter Command .Count() // Allow for the $count Command .Expand() // Allow for the $expand Command .OrderBy() // Allow for the $orderby Command .Page() // Allow for the $top and $skip Commands .Select() // Allow for the $select Command .ContainsMany(x => x.Books) .Expand(); builder.EntitySet <Publisher>(nameof(Publisher)) .EntityType .Filter() // Allow for the $filter Command .Count() // Allow for the $count Command .Expand() // Allow for the $expand Command .OrderBy() // Allow for the $orderby Command .Page() // Allow for the $top and $skip Commands .Select() // Allow for the $select Command .HasMany(x => x.Books) .Expand(); return(builder.GetEdmModel()); }
public void CreateCollection_From_OrderByNode_Succeeds() { // Arrange ODataConventionModelBuilder builder = ODataModelBuilderMocks.GetModelBuilderMock <ODataConventionModelBuilder>(); builder.EntitySet <SampleClass>("entityset"); IEdmModel model = builder.GetEdmModel(); IEdmEntityType sampleClassEntityType = model.SchemaElements.Single(t => t.Name == "SampleClass") as IEdmEntityType; Assert.NotNull(sampleClassEntityType); // Guard IEdmEntitySet entitySet = model.EntityContainer.FindEntitySet("entityset"); Assert.NotNull(entitySet); // Guard ODataQueryOptionParser parser = new ODataQueryOptionParser(model, sampleClassEntityType, entitySet, new Dictionary <string, string> { { "$orderby", "Property1 desc, Property2 asc" } }); OrderByClause orderbyNode = parser.ParseOrderBy(); // Act ICollection <OrderByNode> nodes = OrderByNode.CreateCollection(orderbyNode); // Assert Assert.False(nodes.OfType <OrderByItNode>().Any()); IEnumerable <OrderByPropertyNode> propertyNodes = nodes.OfType <OrderByPropertyNode>(); Assert.Equal(2, propertyNodes.Count()); Assert.Equal("Property1", propertyNodes.First().Property.Name); Assert.Equal(OrderByDirection.Descending, propertyNodes.First().Direction); Assert.Equal("Property1", propertyNodes.First().PropertyPath); Assert.Equal("Property2", propertyNodes.Last().Property.Name); Assert.Equal(OrderByDirection.Ascending, nodes.Last().Direction); Assert.Equal("Property2", propertyNodes.Last().PropertyPath); }