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