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()); }
public static Microsoft.OData.Edm.IEdmModel GetModel() { var builder = new ODataConventionModelBuilder(); builder.EntitySet<Product>("Products"); builder.EntitySet<Supplier>("Suppliers"); //配置一个函数 //builder.EntitySet<Product>("Products").EntityType.Collection.Function("MostExpensive").Returns<double>(); //获取最贵产品价格的路由设置 //配置一个Action //builder.EntitySet<Product>("Products").EntityType.Action("Rate").Parameter<int>("Rating"); #region 服务的另一种配置方法 //http://www.asp.net/web-api/overview/odata-support-in-aspnet-web-api/odata-v4/odata-actions-and-functions builder.Namespace = "ProductService"; builder.EntityType<Product>().Collection .Function("MostExpensive") //函数路由 .Returns<double>(); builder.Namespace = "ProductService"; builder.EntityType<Product>() .Action("Rate") //Action路由 .Parameter<int>("Rating"); #endregion 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(); }
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 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()); }
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 GetEdmModel() { var builder = new ODataConventionModelBuilder(); builder.EntitySet<Product>("Products"); builder.EntitySet<Part>("Parts"); return builder.GetEdmModel(); }
private IEdmModel GetEdmModel() { ODataModelBuilder builder = new ODataConventionModelBuilder(); builder.EntitySet<Billing_Rules>("Billing_Rules"); builder.EntitySet<ApplyAt>("ApplyAts"); builder.EntitySet<Charge>("Charges"); builder.EntitySet<ChargesType>("ChargesTypes"); builder.EntitySet<BillTime>("BillTimes"); builder.EntitySet<BoardType>("BoardTypes"); builder.EntitySet<Country>("Countries"); builder.EntitySet<Currency>("Currencies"); builder.EntitySet<Document_Type>("Document_Types"); builder.EntitySet<Language>("Languages"); builder.EntitySet<MemberType>("MemberTypes"); builder.EntitySet<PaymentMode>("PaymentModes"); builder.EntitySet<ReservationStatusType>("ReservationStatusTypes"); builder.EntitySet<RoomStatusType>("RoomStatusTypes"); builder.EntitySet<RateType>("RateTypes"); builder.EntitySet<WaitingListStatus>("WaitingListStatus"); 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 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); }
private static IEdmModel GetEdmModel() { var builder = new ODataConventionModelBuilder(); builder.EntitySet<ResponseDataModel>("Users"); builder.EntitySet<CustomerCardAdministrationDataModel>("CustomerCards"); return builder.GetEdmModel(); }
private static IEdmModel GetSampleModel() { ODataConventionModelBuilder builder = new ODataConventionModelBuilder(); builder.EntitySet<Employee>("employees"); builder.EntitySet<WorkItem>("workitems"); return builder.GetEdmModel(); }
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(); }
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 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() })); }
static void AddODataSupport( ServerHost server ) { var objectModelBuilder = new ODataConventionModelBuilder(); var bornInfo = objectModelBuilder.ComplexType<BornInfoView>(); bornInfo.Property( bi => bi.When ); bornInfo.Property( bi => bi.Where ); var person = objectModelBuilder.EntitySet<PersonView>( "PeopleView" ) .EntityType.HasKey( p => p.Id ); person.Property( p => p.Name ); person.Property( p => p.Version ); person.ComplexProperty( p => p.BornInfo ); var address = objectModelBuilder.EntitySet<AddressView>( "AddressesView" ) .EntityType.HasKey( a => a.AddressId ); address.Property( a => a.Street ); address.Property( a => a.PersonId ); server.AddHttpConfigurationCustomization( cfg => { cfg.MapODataServiceRoute( routeName: "ODataRoute", routePrefix: null, model: objectModelBuilder.GetEdmModel() ); } ); }
public static void Register(HttpConfiguration config) { ODataModelBuilder builder = new ODataConventionModelBuilder(); builder.EntitySet<Product>("Products"); builder.EntitySet<Customer>("Customers"); builder.EntitySet<ApplicationUser>("Users"); config.MapODataServiceRoute( routeName: "ODataRoute", routePrefix: null, model: builder.GetEdmModel()); // Web API configuration and services // Configure Web API to use only bearer token authentication. //config.SuppressDefaultHostAuthentication(); //config.Filters.Add(new HostAuthenticationFilter(OAuthDefaults.AuthenticationType)); // Web API routes config.MapHttpAttributeRoutes(); config.Routes.MapHttpRoute( name: "DefaultApi", routeTemplate: "api/{controller}/{id}", defaults: new { id = RouteParameter.Optional } ); Seeder.EnsureDatabase(new ApplicationDbContext()); }
public static void Register(HttpConfiguration config) { // Web API configuration and services // TOOD: change it in production 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 } ); var builder = new ODataConventionModelBuilder(); builder.EnableLowerCamelCase(); config.Formatters.Add(new FlatFormatter(new QueryStringMapping("$format", "flat", "application/json"))); builder.EntitySet<Namespace>("Namespaces"); builder.EntitySet<Translation>("Translations"); config.MapODataServiceRoute( routeName: "ODataRoute", routePrefix: null, model: builder.GetEdmModel()); }
private void Application_Start(object sender, EventArgs e) { GlobalConfiguration.Configure(config => { // Enable OData query config.EnableQuerySupport(); // Build the OData EDM var builder = new ODataConventionModelBuilder(); builder.EntitySet<WebApi.OData.Controllers.Test>("test"); // Normal entities set builder.EntitySet<Entity1>("Entities1"); // Composite key builder.EntitySet<Entity2>("Entities2").EntityType.HasKey(e => e.Key1).HasKey(e=> e.Key2); // Build model var model = builder.GetEdmModel(); // Add routing conventions var routingConventions = ODataRoutingConventions.CreateDefault(); // Add support for casting: http://example.com/odata/Entities1/Namespace.Type routingConventions.Insert(0, new OData.CastRoutingConvention()); // Add support for navigation keys: http://example.com/odata/Entities1(key)/Navigation(key) routingConventions.Insert(1, new OData.NavigationIndexRoutingConvention()); // Add support for composite keys: http://example.com/odata/Entities1(Key1=..., Key2=...) routingConventions.Insert(2, new OData.CompositeKeyRoutingConvention()); // Map the OData route and the batch handler route config.MapODataServiceRoute("ODataRoute", "odata", model, new DefaultODataPathHandler(), routingConventions, new DefaultODataBatchHandler(GlobalConfiguration.DefaultServer)); }); }
// 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); }
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 GetConventionModel() { ODataConventionModelBuilder builder = new ODataConventionModelBuilder(); EntitySetConfiguration<ModelAliasingMetadataCustomer> customers = builder.EntitySet<ModelAliasingMetadataCustomer>("ModelAliasingQueryCustomers"); customers.EntityType.Name = "Customer"; customers.EntityType.Namespace = "ModelAliasing"; customers.EntityType.ComplexProperty(c => c.BillingAddress).Name = "FinancialAddress"; customers.EntityType.Property(c => c.Name).Name = "ClientName"; customers.EntityType.HasMany(c => c.Orders).Name = "Purchases"; EntitySetConfiguration<ModelAliasingMetadataOrder> orders = builder.EntitySet<ModelAliasingMetadataOrder>("Orders"); orders.EntityType.Name = "Order"; orders.EntityType.Namespace = "AliasedNamespace"; EntityTypeConfiguration<ModelAliasingMetadataExpressOrder> expressOrder = builder.EntityType<ModelAliasingMetadataExpressOrder>().DerivesFrom<ModelAliasingMetadataOrder>(); expressOrder.Name = "ExpressOrder"; expressOrder.Namespace = "Purchasing"; expressOrder.Property(eo => eo.ExpressFee).Name = "Fee"; EntityTypeConfiguration<ModelAliasingMetadataFreeDeliveryOrder> freeDeliveryOrder = builder.EntityType<ModelAliasingMetadataFreeDeliveryOrder>().DerivesFrom<ModelAliasingMetadataOrder>(); freeDeliveryOrder.Name = "FreeDeliveryOrder"; freeDeliveryOrder.Namespace = "Purchasing"; EntitySetConfiguration<ModelAliasingMetadataProduct> products = builder.EntitySet<ModelAliasingMetadataProduct>("Products"); EntitySetConfiguration<ModelAliasingMetadataOrderLine> ordersLines = builder.EntitySet<ModelAliasingMetadataOrderLine>("OrdersLines"); ordersLines.EntityType.Property(ol => ol.Price).Name = "Cost"; ComplexTypeConfiguration<ModelAliasingMetadataRegion> region = builder.ComplexType<ModelAliasingMetadataRegion>(); region.Name = "PoliticalRegion"; region.Namespace = "Location"; ComplexTypeConfiguration<ModelAliasingMetadataAddress> address = builder.ComplexType<ModelAliasingMetadataAddress>(); address.Name = "Direction"; address.Namespace = "Location"; address.ComplexProperty<ModelAliasingMetadataRegion>(c => c.Country).Name = "Reign"; return builder.GetEdmModel(); }
private static IEdmModel GetEdmModel() { var builder = new ODataConventionModelBuilder(); builder.EntitySet<Dominio>("Dominios"); builder.EntitySet<Server>("Servers"); return builder.GetEdmModel(); }
public static IEdmModel GetEdmModel(HttpConfiguration configuration) { var builder = new ODataConventionModelBuilder(configuration); builder.EntitySet<Customer>("Customers"); builder.EntitySet<Order>("Orders"); IEdmModel model = builder.GetEdmModel(); return model; }
private static IEdmModel GetEdmModel() { ODataModelBuilder builder = new ODataConventionModelBuilder(); var customers = builder.EntitySet<UntypedCustomer>("UntypedDeltaCustomers"); customers.EntityType.Property(c => c.Name).IsRequired(); var orders = builder.EntitySet<UntypedOrder>("UntypedDeltaOrders"); return builder.GetEdmModel(); }
private static IEdmModel GetModel() { ODataConventionModelBuilder builder = new ODataConventionModelBuilder(); builder.EntitySet<Product>("Products"); builder.EntitySet<ProductFamily>("ProductFamilies"); builder.EntitySet<Supplier>("Suppliers"); return builder.GetEdmModel(); }
private static IEdmModel GetRelationshipsModel(HttpConfiguration config) { ODataModelBuilder builder = new ODataConventionModelBuilder(config); var oneToOneParentSet = builder.EntitySet<OneToOneParent>("OneToOneParent"); var oneToOneChildSet = builder.EntitySet<OneToOneChild>("OneToOneChild"); oneToOneParentSet.HasOptionalBinding(x => x.Child, "OneToOneChild"); return builder.GetEdmModel(); }
private static IEdmModel GetEdmModel() { var builder = new ODataConventionModelBuilder(); builder.EntitySet<Customer>("Customers"); builder.EntitySet<Customer>("Products"); var model = builder.GetEdmModel(); return model; }
public static IEdmModel GetModel() { ODataModelBuilder builder = new ODataConventionModelBuilder(); EntitySetConfiguration<Customer> customers = builder.EntitySet<Customer>("Customers"); EntitySetConfiguration<Order> orders = builder.EntitySet<Order>("Orders"); EntitySetConfiguration<OrderDetail> orderItems = builder.EntitySet<OrderDetail>("OrderItems"); return builder.GetEdmModel(); }
private IEdmModel GetEdmModel() { var modelBuilder = new ODataConventionModelBuilder(); modelBuilder.EntitySet<Customer>("Customers"); modelBuilder.EntitySet<Order>("Orders"); modelBuilder.EntitySet<Customer>("Response"); modelBuilder.EntitySet<Employee>("Employees"); return modelBuilder.GetEdmModel(); }
// 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 { app.UseHsts(); } // odata specific part var builder = new ODataConventionModelBuilder(); builder.EntitySet <Car>("Cars"); app.UseMvc(routebuilder => { routebuilder.Select().Expand().Filter().Count(); routebuilder.MapODataServiceRoute("odata", "odata", builder.GetEdmModel()); }); }
public void type_should_use_self_referencing_property_substitution() { // arrange var modelBuilder = new ODataConventionModelBuilder(); var company = modelBuilder.EntitySet <Company>("Companies").EntityType; company.Ignore(c => c.DateFounded); var context = NewContext(modelBuilder.GetEdmModel()); var originalType = typeof(Company); //act var subsitutedType = originalType.SubstituteIfNecessary(context); // assert subsitutedType.GetRuntimeProperties().Should().HaveCount(4); subsitutedType.Should().HaveProperty <int>(nameof(Company.CompanyId)); subsitutedType.Should().HaveProperty <string>(nameof(Company.Name)); subsitutedType.Should().Be(subsitutedType.GetRuntimeProperty(nameof(Company.ParentCompany)).PropertyType); subsitutedType.Should().Be(subsitutedType.GetRuntimeProperty(nameof(Company.Subsidiaries)).PropertyType.GetGenericArguments()[0]); }
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline. public void Configure(IApplicationBuilder app, IHostingEnvironment env) { //culture middleware app.UseAcceptanceLanguageMiddleware(); //global exception middleware app.UseExceptionHandlerMiddleware(); //odata var builder = new ODataConventionModelBuilder(app.ApplicationServices); builder.EntitySet <User>("Users"); //swagger app.UseSwagger(); app.UseSwaggerUI(c => { c.SwaggerEndpoint("/swagger/v1/swagger.json", "User management"); }); app.UseStaticFiles(); app.UseMvc(routeBuilder => { routeBuilder.Select().Expand().Filter().OrderBy().MaxTop(100).Count(); routeBuilder.MapODataServiceRoute("odataroute", "api", builder.GetEdmModel()); routeBuilder.EnableDependencyInjection(); }); }
public static void Register(HttpConfiguration config) { // Web API configuration and services // Configure Web API to use only bearer token authentication. config.SuppressDefaultHostAuthentication(); config.Filters.Add(new HostAuthenticationFilter(OAuthDefaults.AuthenticationType)); // 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 <Tenant>("Tenant"); config.Routes.MapODataServiceRoute("odata", "odata", builder.GetEdmModel()); }
public static void Register(HttpConfiguration config) { config.EnableCors(); ODataConventionModelBuilder builder = new ODataConventionModelBuilder(); var json = config.Formatters.JsonFormatter; json.SerializerSettings.PreserveReferencesHandling = Newtonsoft.Json.PreserveReferencesHandling.Objects; config.Formatters.Remove(config.Formatters.XmlFormatter); builder.EntitySet <tblT_Roomaku>("tblT_RoomakuOData"); config.Routes.MapODataServiceRoute("odata", "odata", builder.GetEdmModel()); //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: "DefaultApiWithId", routeTemplate: "api/{controller}/{id}", defaults: new { id = RouteParameter.Optional } ); config.Routes.MapHttpRoute("DefaultApiWithAction", "Api/{controller}/{action}"); config.Routes.MapHttpRoute("DefaultApiGet", "Api/{controller}", null, new { httpMethod = new HttpMethodConstraint(HttpMethod.Get) }); //OData ODataConventionModelBuilder builder = new ODataConventionModelBuilder(); builder.EntitySet <StoreTree>("StoreTreesOD"); config.Routes.MapODataServiceRoute("odata", "odata", builder.GetEdmModel()); }
public static void Register(HttpConfiguration config) { // Web API 配置和服务 // Web API 路由 config.MapHttpAttributeRoutes(); config.Routes.MapHttpRoute( name: "DefaultApi", routeTemplate: "api/{controller}/{id}", defaults: new { id = RouteParameter.Optional } ); var builder = new ODataConventionModelBuilder(); builder.EntitySet <Product>("Products"); config.MapODataServiceRoute( routeName: "ODataRoute", routePrefix: null, model: builder.GetEdmModel()); }
public static IEdmModel GetModel() { ODataConventionModelBuilder builder = new ODataConventionModelBuilder(); EntitySetConfiguration <Window> windows = builder.EntitySet <Window>("Windows"); EntityTypeConfiguration <Window> window = windows.EntityType; // Action that takes in a base complex type. ActionConfiguration actionConfiguration = window.Action("AddOptionalShape"); actionConfiguration.Parameter <Shape>("shape"); actionConfiguration.Returns <int>(); // The number of all optional shapes // Function that returns a base complex type var functionConfiguration = window.Function("GetTheLastOptionalShape"); functionConfiguration.Returns <Shape>(); builder.Namespace = typeof(Window).Namespace; return(builder.GetEdmModel()); }
public void CanBuildModelWithCollectionReferenceViaInheritance() { var builder = new ODataConventionModelBuilder(); builder.EntitySet <JustHomeDirectory>("justhomedirectory"); IEdmModel model = builder.GetEdmModel(); string fileTypeName = typeof(File).Name; string directoryTypeName = typeof(Directory).Name; var file = model.SchemaElements.First(e => e.Name == fileTypeName) as EdmComplexType; var directory = model.SchemaElements.First(e => e.Name == directoryTypeName) as EdmComplexType; Assert.Equal(fileTypeName, directory.BaseComplexType()?.Name); var filesProperty = directory.Properties().Single(p => p.Name == "Files") as EdmStructuralProperty; Assert.Equal( fileTypeName, filesProperty.Type.AsCollection()?.ElementType().AsComplex()?.ComplexDefinition().Name); }
public void CreateQueryContext_ReturnsQueryContext_ForMatchingModelOnRequest() { var builder = new ODataConventionModelBuilder(); builder.EntitySet <QueryCompositionCustomer>("customers"); var model = builder.GetEdmModel(); var entityClrType = typeof(QueryCompositionCustomer); var config = new HttpConfiguration(); var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/"); request.SetEdmModel(model); var descriptor = new ReflectedHttpActionDescriptor(); descriptor.Configuration = config; var queryModel = new QueryableAttribute().GetModel(entityClrType, request, descriptor); Assert.NotNull(queryModel); Assert.Same(model, queryModel); Assert.False(descriptor.Properties.ContainsKey("MS_EdmModelSystem.Web.Http.OData.Query.QueryCompositionCustomer")); }
public void substitute_should_get_attributes_from_property_that_has_attributes_that_takes_params() { // arrange var modelBuilder = new ODataConventionModelBuilder(); var employee = modelBuilder.EntitySet <Employee>("Employees").EntityType; employee.Ignore(e => e.FirstName); var originalType = typeof(Employee); var context = NewContext(modelBuilder.GetEdmModel()); // act var substitutionType = originalType.SubstituteIfNecessary(context); // assert var property = substitutionType.GetRuntimeProperty("Salary"); var attributeWithParams = property.GetCustomAttribute <AllowedRolesAttribute>(); Assert.Equal("Manager", attributeWithParams.AllowedRoles[0]); Assert.Equal("Employer", attributeWithParams.AllowedRoles[1]); }
private static IEdmModel GetEdmModel() { ODataConventionModelBuilder builder = new ODataConventionModelBuilder(); builder.EntitySet <UserOrdersDto>("UserOrder"); builder.EntitySet <UserMobileOrderDto>("UserMobileOrder"); builder.EntitySet <MobileDto>("Mobile"); builder.EntitySet <UsersDto>("User"); builder.EntitySet <CustomEntity>("result"); builder.EntitySet <PaymentModeMasterDto>("PaymentModeMaster"); var function = builder.Function("GetReports"); function.Parameter <string>("type"); function.ReturnsCollectionFromEntitySet <CustomEntity>("Custom"); return(builder.GetEdmModel()); }
public void Isof_SubType_Test() { var builder = new ODataConventionModelBuilder(); builder.EntitySet <A>("As"); IEdmModel model = builder.GetEdmModel(); var configuration = new[] { typeof(AsController) }.GetHttpConfiguration(); configuration.MapODataServiceRoute("odata", "odata", model); HttpServer server = new HttpServer(configuration); var client = new HttpClient(server); // Query As only the Dp is a "E" type. string payload = @"{ ""@odata.context"":""http://localhost/odata/$metadata#As"",""value"":[ { ""@odata.type"":""#Microsoft.AspNet.OData.Test.Isof.B"",""Id"":1,""Dp"":{ ""@odata.type"":""#Microsoft.AspNet.OData.Test.Isof.E"",""Prop"":""E Prop"",""Ep"":""E kind"" },""Bp"":7 } ] }"; var response = client.GetAsync("http://localhost/odata/As?$filter=isof(Dp,'Microsoft.AspNet.OData.Test.Isof.E')").Result; Assert.Equal(payload, response.Content.ReadAsStringAsync().Result); // Query As only the Dp is a "F" type. payload = @"{ ""@odata.context"":""http://localhost/odata/$metadata#As"",""value"":[ { ""@odata.type"":""#Microsoft.AspNet.OData.Test.Isof.B"",""Id"":2,""Dp"":{ ""@odata.type"":""#Microsoft.AspNet.OData.Test.Isof.F"",""Prop"":""FFFF Prop"",""Fp"":""FFFF kind"" },""Bp"":8 } ] }"; response = client.GetAsync("http://localhost/odata/As?$filter=isof(Dp,'Microsoft.AspNet.OData.Test.Isof.F')").Result; Assert.Equal(payload, response.Content.ReadAsStringAsync().Result); }
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.EnableODataDependencyInjectionSupport("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 resourceContext = new ResourceContext(serializerContext, edmType.AsReference(), new Customer { Id = 109 }); // Assert var edmAction = model.SchemaElements.OfType <IEdmAction>().First(f => f.Name == "MyAction"); Assert.NotNull(edmAction); OperationLinkBuilder actionLinkBuilder = model.GetOperationLinkBuilder(edmAction); Uri link = actionLinkBuilder.BuildLink(resourceContext); Assert.Equal("http://localhost:123/odata/Customers(109)/Default.MyAction", link.AbsoluteUri); }
public void PrimitiveTypesDeserializeAsOData(Type valueType, object value, MediaTypeHeaderValue mediaType, string resourceName) { string entity = Resources.GetString(resourceName); Assert.NotNull(entity); object expectedValue = value; ODataConventionModelBuilder modelBuilder = new ODataConventionModelBuilder(); modelBuilder.EntitySet <WorkItem>("WorkItems"); IEdmModel model = modelBuilder.GetEdmModel(); object actualValue; using (HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/WorkItems(10)/ID")) { HttpConfiguration config = new HttpConfiguration(); config.MapODataServiceRoute("default", "", model); request.SetConfiguration(config); request.EnableODataDependencyInjectionSupport("default"); ODataMediaTypeFormatter formatter = CreateFormatter(request); formatter.SupportedMediaTypes.Add(mediaType); using (StringContent content = new StringContent(entity)) { content.Headers.ContentType = mediaType; using (Stream stream = content.ReadAsStreamAsync().Result) { actualValue = formatter.ReadFromStreamAsync(valueType, stream, content, new Mock <IFormatterLogger>().Object).Result; } } } Assert.Equal(expectedValue, actualValue); }
public void GetETag_Returns_ETagInHeader_ForDouble(double value, bool isEqual) { // Arrange Dictionary <string, object> properties = new Dictionary <string, object> { { "Version", value } }; EntityTagHeaderValue etagHeaderValue = new DefaultODataETagHandler().CreateETag(properties); var builder = new ODataConventionModelBuilder(); builder.EntitySet <MyEtagCustomer>("Customers"); IEdmModel model = builder.GetEdmModel(); IEdmEntitySet customers = model.FindDeclaredEntitySet("Customers"); ODataPath odataPath = new ODataPath(new EntitySetSegment(customers)); HttpRequestMessage request = new HttpRequestMessage(); request.EnableHttpDependencyInjectionSupport(model); request.ODataProperties().Path = odataPath; // Act ETag result = request.GetETag(etagHeaderValue); dynamic dynamicResult = result; // Assert double actual = Assert.IsType <double>(result["Version"]); Assert.Equal(actual, dynamicResult.Version); if (isEqual) { Assert.Equal(value, actual); } else { Assert.NotEqual(value, actual); Assert.True(actual - value < 0.0000001); } }
public void ODataFormatter_CanReadDelta_WithAlias(string propertyName, string propertyNameAlias, string propertyJsonValue, object expectedValue) { // Arrange ODataConventionModelBuilder builder = ODataModelBuilderMocks.GetModelBuilderMock <ODataConventionModelBuilder>(); builder.ModelAliasingEnabled = true; builder.EntityType <DeltaModelWithAlias>(); builder.EntitySet <DeltaModelWithAlias>("ignored"); IEdmModel model = builder.GetEdmModel(); IEnumerable <ODataMediaTypeFormatter> odataFormatters = ODataMediaTypeFormatters.Create(); Delta <DeltaModelWithAlias> delta; using (HttpRequestMessage request = new HttpRequestMessage { RequestUri = new Uri("http://localhost") }) { IEdmEntitySet entitySet = model.EntityContainer.EntitySets().Single(); HttpConfiguration config = new HttpConfiguration(); config.MapODataServiceRoute("default", "", model); request.ODataProperties().RouteName = "default"; request.SetConfiguration(config); request.ODataProperties().Model = model; request.ODataProperties().Path = new ODataPath(new EntitySetPathSegment(entitySet)); IEnumerable <MediaTypeFormatter> perRequestFormatters = odataFormatters.Select( (f) => f.GetPerRequestFormatterInstance(typeof(Delta <DeltaModelWithAlias>), request, null)); HttpContent content = new StringContent(String.Format("{{ '{0}' : {1} }}", propertyNameAlias, propertyJsonValue)); content.Headers.ContentType = MediaTypeHeaderValue.Parse("application/json"); // Act delta = content.ReadAsAsync <Delta <DeltaModelWithAlias> >(perRequestFormatters).Result; } // Assert Assert.Equal(delta.GetChangedPropertyNames(), new[] { propertyName }); object value; Assert.True(delta.TryGetPropertyValue(propertyName, out value)); Assert.Equal(expectedValue, value); }
// Builds the EDM model for the OData service, including the OData action definitions. private static IEdmModel GetEdmModel() { var modelBuilder = new ODataConventionModelBuilder(); var moviesEntitySet = modelBuilder.EntitySet <Movie>("Movies"); // Now add actions. // http://odata.github.io/WebApi/#02-03-model-builder-nonconvention // CheckOut // URI: ~/odata/Movies(1)/ODataActionSample.Models.CheckOut ActionConfiguration checkOutAction = modelBuilder.EntityType <Movie>().Action("CheckOut"); checkOutAction.ReturnsFromEntitySet <Movie>("Movies"); // ReturnMovie // URI: ~/odata/Movies(1)/ODataActionSample.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/ODataActionSample.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()); }
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 IEdmModel GetEdmModelEmployes(IDataAccesService dataAccesService) { ODataConventionModelBuilder builder = new ODataConventionModelBuilder(); var employes = builder.EntitySet <Employe>("employes"); // ignore the list of properties to exclude /// pour recuperer les colonnes string username = DecodeBase64(BasicAuthenticationHandler.Username); // IQueryable<Colonne> colonnes = dataAccesService.GererDataAccess("amayam", "abcd"); IQueryable <Colonne> colonnes = dataAccesService.GererDataAccess("amayam"); foreach (Colonne col in colonnes) { switch (col.Nom.ToString().Trim()) { case "matricule": employes.EntityType.Ignore(e => e.Matricule); break; case "Code_Empl": employes.EntityType.Ignore(e => e.Code_Empl); break; case "rib": employes.EntityType.Ignore(e => e.Rib); break; case "nas": employes.EntityType.Ignore(e => e.Nas); break; case "tin": employes.EntityType.Ignore(e => e.Tin); break; } } return(builder.GetEdmModel()); }
public static IEdmModel CreateModel() { var modelBuilder = new ODataConventionModelBuilder(); modelBuilder.EnableLowerCamelCase(); #region ENTITY TYPE var searchEntity = modelBuilder.EntityType <SearchViewModel>(); searchEntity.Name = Camelize(searchEntity.Name); searchEntity.Namespace = "search"; searchEntity.HasKey(entity => entity.Count); #endregion #region COMPLEX TYPE modelBuilder.ComplexType <SearchResultViewModel>(); #endregion #region ENITY SET modelBuilder.EntitySet <SearchViewModel>("search"); #endregion #region FUNCTIONS FunctionConfiguration frontiersResult = modelBuilder.EntityType <SearchViewModel>().Collection.Function("frontiers"); frontiersResult.Parameter <string>("type"); frontiersResult.Namespace = GET_FUNCTION_NAMESPACE; frontiersResult.ReturnsFromEntitySet <SearchViewModel>("search"); frontiersResult.Namespace = GET_FUNCTION_NAMESPACE; #endregion return(modelBuilder.GetEdmModel()); }
public static void Register(HttpConfiguration config) { // Web API routes config.MapHttpAttributeRoutes(); var builder = new ODataConventionModelBuilder(); builder.EntitySet <ApiPerson>("People"); builder.EntitySet <ApiContribution>("Contributions"); builder.EntitySet <ApiContributionFund>("Funds"); builder.EntitySet <ApiMeeting>("Meetings"); builder.EntitySet <ApiOrganization>("Organizations"); builder.EntitySet <ApiOrganizationMember>("OrganizationMembers"); builder.EntitySet <ApiChAiPerson>("ChAiPeople"); builder.EntitySet <ApiChAiGift>("ChAiGifts"); config.Count().Filter().OrderBy().Expand().Select().MaxTop(100); config.MapODataServiceRoute( routeName: "ODataApiRoot", routePrefix: "api", model: builder.GetEdmModel()); var builderlookup = new ODataConventionModelBuilder(); builderlookup.EntitySet <ApiLookup>("Campuses"); builderlookup.EntitySet <ApiLookup>("Genders"); builderlookup.EntitySet <ApiLookup>("MaritalStatuses"); builderlookup.EntitySet <ApiLookup>("FamilyPositions"); builderlookup.EntitySet <ApiLookup>("ContributionTypes"); builderlookup.EntitySet <ApiLookup>("BundleHeaderTypes"); config.MapODataServiceRoute( routeName: "ODataApiLookupRoute", routePrefix: "api/lookup", model: builderlookup.GetEdmModel()); config.Filters.Add(new ApiAuthorizeAttribute()); config.MessageHandlers.Add(new ApiMessageLoggingHandler()); // fix for XML support (use Accept: application/xml) var formatters = ODataMediaTypeFormatters.Create(); config.Formatters.InsertRange(0, formatters); var jsonFormatter = config.Formatters.OfType <JsonMediaTypeFormatter>().First(); jsonFormatter.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver(); jsonFormatter.SerializerSettings.Formatting = Newtonsoft.Json.Formatting.Indented; }
public static IEdmModel GetEdmModel() { ODataConventionModelBuilder builder = new ODataConventionModelBuilder(); builder.EntitySet <StreamCustomer>("StreamCustomers"); EdmModel model = builder.GetEdmModel() as EdmModel; IEdmEntityType streamCustomerType = model.SchemaElements.OfType <IEdmEntityType>().FirstOrDefault(c => c.Name == "StreamCustomer"); Assert.NotNull(streamCustomerType); IEdmProperty photoProperty = streamCustomerType.FindProperty("Photo"); EdmStringConstant strConstant1 = new EdmStringConstant("application/javascript"); EdmStringConstant strConstant2 = new EdmStringConstant("image/png"); EdmCollectionExpression collectionExpression = new EdmCollectionExpression(strConstant1, strConstant2); EdmVocabularyAnnotation annotation = new EdmVocabularyAnnotation(photoProperty, CoreVocabularyModel.AcceptableMediaTypesTerm, collectionExpression); annotation.SetSerializationLocation(model, EdmVocabularyAnnotationSerializationLocation.Inline); model.AddVocabularyAnnotation(annotation); return(model); }
public static void Register(HttpConfiguration config) { // Web API configuration and services // Web API routes config.MapHttpAttributeRoutes(); ODataConventionModelBuilder builder = new ODataConventionModelBuilder(); builder.EntitySet <CompanyProfilePoco>("Company"); ODataRoute route = config.MapODataServiceRoute("odata", "odata", builder.GetEdmModel()); config.Count().Filter().OrderBy().Expand().Select(); //config.Routes.MapHttpRoute( // name: "DefaultApi", // routeTemplate: "api/{controller}/{id}", // defaults: new { id = RouteParameter.Optional } //); }
public void Validate_Throw_WithInvalidMaxExpansionDepth() { int maxExpansionDepth = -1; // Arrange string expand = "Parent($levels=1)"; 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); // Act & Assert Assert.Throws <ArgumentOutOfRangeException>( () => validator.Validate( selectExpandQueryOption, new ODataValidationSettings { MaxExpansionDepth = maxExpansionDepth }), "Value must be greater than or equal to 0.\r\nParameter name: value\r\nActual value was -1."); }
public void Apply_Doesnot_Override_UserConfiguration() { // Arrange ODataConventionModelBuilder builder = ODataConventionModelBuilderFactory.Create(); var customers = builder.EntitySet <Customer>("Customers"); var paintAction = customers.EntityType.Action("Paint"); paintAction.HasActionLink(ctxt => new Uri("http://localhost/ActionTestWorks"), followsConventions: false); ActionLinkGenerationConvention convention = new ActionLinkGenerationConvention(); // Act convention.Apply(paintAction, builder); IEdmModel model = builder.GetEdmModel(); var edmCustomers = model.EntityContainer.FindEntitySet("Customers"); var edmCustomer = model.SchemaElements.OfType <IEdmEntityType>().First(c => c.Name == "Customer"); var edmAction = model.SchemaElements.OfType <IEdmAction>().First(a => a.Name == "Paint"); Assert.NotNull(edmAction); string routeName = "OData"; var configuration = RoutingConfigurationFactory.CreateWithRootContainer(routeName); configuration.MapODataServiceRoute(routeName, null, model); var request = RequestFactory.Create(HttpMethod.Get, "http://localhost", configuration, routeName); OperationLinkBuilder actionLinkBuilder = model.GetOperationLinkBuilder(edmAction); var serializerContext = ODataSerializerContextFactory.Create(model, edmCustomers, request); var entityContext = new ResourceContext(serializerContext, edmCustomer.AsReference(), new Customer { Id = 2009 }); // Assert Uri link = actionLinkBuilder.BuildLink(entityContext); Assert.Equal("http://localhost/ActionTestWorks", link.AbsoluteUri); }
public void substitute_should_generate_type_for_action_parameters_with_substituted_types() { // arrange var modelBuilder = new ODataConventionModelBuilder(); var contact = modelBuilder.EntitySet <Contact>("Contacts").EntityType; contact.Ignore(c => c.Email); var action = contact.Action("PlanInterview"); action.Parameter <DateTime>("when"); action.Parameter <Contact>("interviewer"); action.Parameter <Contact>("interviewee"); var context = NewContext(modelBuilder.GetEdmModel()); var model = context.Model; var qualifiedName = $"{model.EntityContainer.Namespace}.{action.Name}"; var operation = (IEdmAction)model.FindDeclaredOperations(qualifiedName).Single(); var services = new ServiceCollection(); services.AddSingleton(model); // act var substitutionType = context.ModelTypeBuilder.NewActionParameters(services.BuildServiceProvider(), operation, ApiVersion.Default, contact.Name); // assert substitutionType.GetRuntimeProperties().Should().HaveCount(3); substitutionType.Should().HaveProperty <DateTimeOffset>("when"); var contactType = substitutionType.GetRuntimeProperty("interviewer").PropertyType; contactType.Should().Be(substitutionType.GetRuntimeProperty("interviewee").PropertyType); contactType.GetRuntimeProperties().Should().HaveCount(5); contactType.Should().HaveProperty <int>("ContactId"); contactType.Should().HaveProperty <string>("FirstName"); contactType.Should().HaveProperty <string>("LastName"); contactType.Should().HaveProperty <string>("Phone"); contactType.Should().HaveProperty <List <Address> >("Addresses"); }
public void SelfLinksGenerationConvention_Uses_GetByIdWithoutCast_IfDerivedTypeDoesnotHaveNavigationProperty() { ODataConventionModelBuilder builder = new ODataConventionModelBuilder(); var motorcycles = builder.EntitySet <Motorcycle>("motorcycles"); IEdmModel model = builder.GetEdmModel(); IEdmEntitySet vehiclesEdmEntitySet = model.EntityContainer.EntitySets().Single(); IEdmEntityType sportbikeType = model.AssertHasEntityType(typeof(SportBike)); 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, sportbikeType.AsReference(), new SportBike { Model = 2009, Name = "Ninja" }); EntitySelfLinks selfLinks = linkBuilder.BuildEntitySelfLinks(entityContext, ODataMetadataLevel.FullMetadata); Assert.Equal("http://localhost/motorcycles(Model=2009,Name='Ninja')", selfLinks.IdLink.ToString()); }
public void CreateCollection_From_OrderByNode_Succeeds() { // Arrange ODataConventionModelBuilder builder = new ODataConventionModelBuilder(); builder.EntitySet <SampleClass>("entityset"); IEdmModel model = builder.GetEdmModel(); IEdmEntityType sampleClassEntityType = model.SchemaElements.Single(t => t.Name == "SampleClass") as IEdmEntityType; OrderByClause orderbyNode = ODataUriParser.ParseOrderBy("Property1 desc, Property2 asc", model, sampleClassEntityType); // Act ICollection <OrderByPropertyNode> nodes = OrderByPropertyNode.CreateCollection(orderbyNode); // Assert Assert.Equal(2, nodes.Count); Assert.Equal("Property1", nodes.First().Property.Name); Assert.Equal(OrderByDirection.Descending, nodes.First().Direction); Assert.ReferenceEquals("Property2", nodes.Last().Property.Name); Assert.Equal(OrderByDirection.Ascending, nodes.Last().Direction); }
protected ODataQueryOptions <T> GetOdataQueryOptions <T>(ApiController controller) where T : class { // Criamos um request para simular uma chamada HTTP para os testes HttpRequestMessage request = new HttpRequestMessage(); request.SetConfiguration(new HttpConfiguration()); request.GetConfiguration().AddODataQueryFilter(); request.GetConfiguration().EnableDependencyInjection(); request.GetConfiguration().Count().Select().Filter().OrderBy().MaxTop(null); request.GetConfiguration().AddODataQueryFilter(); // Criamos um model do odata para a nossa chamada http var modelBuilder = new ODataConventionModelBuilder(); modelBuilder.EntitySet <T>(typeof(T).Name); var model = modelBuilder.GetEdmModel(); // Criamos um context do odata conforme nossa chamada http mockada ODataQueryContext context = new ODataQueryContext(model, typeof(T), new ODataPath()); controller.Request = request; // Retornamos opções do odata mockadas return(new ODataQueryOptions <T>(context, request)); }