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));
}
