private IEdmModel GetEdmModel()
{
ODataConventionModelBuilder builder = ODataConventionModelBuilderFactory.Create();
builder.EntityType <Customer>().Namespace = "NS";
builder.ComplexType <Address>().Namespace = "NS";
FunctionConfiguration getEnum = builder.Function("GetEnum");
getEnum.Parameter <SimpleEnum>("simpleEnum");
getEnum.Returns <SimpleEnum>();
FunctionConfiguration getFlagsEnum = builder.Function("GetFlagsEnum");
getFlagsEnum.Parameter <FlagsEnum>("flagsEnum");
getFlagsEnum.Returns <FlagsEnum>();
FunctionConfiguration function = builder.Function("GetNullableFlagsEnum").Returns <bool>();
function.Parameter <FlagsEnum?>("flagsEnum");
builder.Function("GetAddress").Returns <bool>().Parameter <Address>("address");
builder.Function("GetCustomer").Returns <bool>().Parameter <Customer>("customer");
return(builder.GetEdmModel());
}
public static IEdmModel Build()
{
// create OData builder instance
var builder = new ODataConventionModelBuilder();
// map the entityset which is the type returned from the endpoint onto the OData pipeline
// the string parameter is the name of the controller
// which supplies the data of type ReaderModel in this case
builder.EntitySet <ReaderModel>("ODataReaders").EntityType.HasKey(x => x.Id);
// configure a function onto the builder, AllReaders
// which is same as the name provided in the ODataRoute
var fnAllReaders = builder.Function("AllReaders");
// define what type the function returns; here it is of type ReaderModel
fnAllReaders.ReturnsCollectionFromEntitySet <ReaderModel>("ODataReaders");
// configure a function onto the builder, ReadersById
// which is same as the name provided in the ODataRoute
var fnReadersById = builder.Function("ReadersById");
// since this function takes a parameter of type id,
// define what type the parameter accepts and
// the identifier same as the one mentioned within the route
fnReadersById.Parameter <int>("id");
// define what type the function returns; here it is of type ReaderModel
fnReadersById.ReturnsCollectionFromEntitySet <ReaderModel>("ODataReaders");
// return the fully configured builder model
// on which the OData library shall be built
return(builder.GetEdmModel());
}
private static IEdmModel getEdmModel()
{
ODataConventionModelBuilder modelBuilder = new ODataConventionModelBuilder();
EntitySetConfiguration <Person> peopleEntitySet = modelBuilder.EntitySet <Person>("People");
EntityTypeConfiguration <Person> personType = peopleEntitySet.EntityType;
personType.Ignore(p => p.CreatedTime);
personType.Ignore(p => p.LastModifiedTime);
EntitySetConfiguration <Account> accountEntitySet = modelBuilder.EntitySet <Account>("Accounts");
EntityTypeConfiguration <Account> accountType = accountEntitySet.EntityType;
accountType.Ignore(a => a.LastModifyTime);
accountType.Ignore(a => a.CreateTime);
FunctionConfiguration getPersonAndDescendants = modelBuilder.Function("GetPersonAndDescendants");
getPersonAndDescendants.ReturnsFromEntitySet <Person>("People");
getPersonAndDescendants.Parameter <long>("Id"); // The id of the root person.
getPersonAndDescendants.Parameter <long>("TotalLevels"); // How many levels will be loaded and the root person is included.
getPersonAndDescendants.IsComposable = true;
FunctionConfiguration getPersonAndAncestors = modelBuilder.Function("GetPersonAndAncestors");
getPersonAndAncestors.ReturnsCollectionFromEntitySet <Person>("People");
getPersonAndAncestors.Parameter <long>("Id"); // The id of the root person.
getPersonAndAncestors.Parameter <long>("TotalLevels"); // How many levels will be loaded and the root person is included.
getPersonAndAncestors.IsComposable = true;
modelBuilder.Namespace = typeof(Person).Namespace;
return(modelBuilder.GetEdmModel());
}
public static IEdmModel GetEdmModelV2()
{
var builder = new ODataConventionModelBuilder();
builder.EntitySet <Order>("Orders");
builder.Singleton <Order>("VipOrder");
var functionWithComplexTypeParameter = builder.EntityType <Order>().Function("CanMoveToAddress").Returns <bool>();
functionWithComplexTypeParameter.Parameter <Address>("address");
// Function 1
var function = builder.Function("RateByOrder");
function.Parameter <int>("order");
function.Returns <int>();
// Function 2
function = builder.Function("CalcByOrder");
function.Parameter <string>("name");
function.Parameter <int>("order");
function.Returns <int>();
return(builder.GetEdmModel());
}
private static IEdmModel BuildEdmModel()
{
var builder = new ODataConventionModelBuilder();
builder.EntitySet <Customer>("Customers");
builder.ComplexType <Address>();
var function = builder.Function("UnboundFunction").Returns <string>();
function.Parameter <int>("p1");
function.Parameter <string>("p2");
function.Parameter <Address>("location");
function = builder.Function("ConventionUnboundFunction").Returns <string>();
function.Parameter <int>("p1");
function.Parameter <string>("p2");
function.Parameter <Address>("location");
function = builder.Function("RetrieveCustomersByFilter").ReturnsCollectionFromEntitySet <Customer>("Customers");
function.Parameter <string>("name");
function.Parameter <string>("lastName");
function.Parameter <CustomerType>("customerType");
return(builder.GetEdmModel());
}
public static IEdmModel GetEdmModelV2()
{
var builder = new ODataConventionModelBuilder();
builder.EntitySet <Order>("Orders");
builder.Singleton <Order>("VipOrder");
builder.Singleton <Category>("Categories");
var functionWithComplexTypeParameter = builder.EntityType <Order>().Function("CanMoveToAddress").Returns <bool>();
functionWithComplexTypeParameter.Parameter <Address>("address");
// function with optional parameters
var functionWithOptional = builder.EntityType <Order>().Function("GetWholeSalary").ReturnsCollectionFromEntitySet <Order>("Orders");
functionWithOptional.Parameter <int>("minSalary");
functionWithOptional.Parameter <int>("maxSalary").Optional();
functionWithOptional.Parameter <int>("aveSalary").HasDefaultValue("129");
// Function 1
var function = builder.Function("RateByOrder");
function.Parameter <int>("order");
function.Returns <int>();
// Function 2
function = builder.Function("CalcByOrder");
function.Parameter <string>("name");
function.Parameter <int>("order");
function.Returns <int>();
return(builder.GetEdmModel());
}
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 Cors
config.EnableCors();
// 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 <account>("accounts");
builder.EntitySet <customer>("customers");
builder.EntitySet <employee>("employees");
builder.EntitySet <supplier>("suppliers");
builder.EntitySet <bank>("banks");
builder.EntitySet <loan>("loans");
builder.EntitySet <payment>("payments");
builder.EntitySet <product>("products");
builder.EntitySet <sale>("sales");
builder.EntitySet <transact>("transacts");
// Configure the OData path for custom functions
// For only 1 parameter, we can omit the configuration into one line for this GetTables functions
builder.Function("GetTables").Returns <List <string> >().Parameter <string>("Database");
// Configuration for GetAttributes functions with two parameters : Database and table
var getAttributeFunction = builder.Function("GetAttributes");
getAttributeFunction.Parameter <string>("Database");
getAttributeFunction.Parameter <string>("Table");
getAttributeFunction.Returns <List <string> >();
// Configuration for GetReferencedTables functions with two parameters : Database and table
var getReferencedTablesFunction = builder.Function("GetReferencedTables");
getReferencedTablesFunction.Parameter <string>("Database");
getReferencedTablesFunction.Parameter <string>("Table");
getReferencedTablesFunction.Returns <List <string> >();
// Configuration for GetTablesReferencingTable functions with two parameters : Database and table
var getTablesReferencingTableFunction = builder.Function("GetTablesReferencingTable");
getTablesReferencingTableFunction.Parameter <string>("Database");
getTablesReferencingTableFunction.Parameter <string>("Table");
getTablesReferencingTableFunction.Returns <List <string> >();
config.MapODataServiceRoute("odata", "Service", builder.GetEdmModel());
}
private IEdmModel GetEdmModel(HttpConfiguration configuration)
{
ODataConventionModelBuilder builder = ODataModelBuilderMocks.GetModelBuilderMock <ODataConventionModelBuilder>(configuration);
builder.EntitySet <ConventionCustomer>("ConventionCustomers");
builder.EntitySet <ConventionOrder>("ConventionOrders");
builder.ComplexType <ConventionPerson>();
builder.EntityType <ConventionCustomer>().ComplexProperty <ConventionAddress>(c => c.Address);
// Top level action import
ActionConfiguration createConventionCustomerById = builder.Action("CreateConventionCustomerById");
createConventionCustomerById.Parameter <int>("ID");
createConventionCustomerById.ReturnsFromEntitySet <ConventionCustomer>("ConventionCustomers");
// Top level action import without parameter and with a collection of primitive return type
ActionConfiguration topCollectionPrimitiveAction = builder.Action("CreateCollectionMessages");
topCollectionPrimitiveAction.ReturnsCollection <string>();
// Top level function import
FunctionConfiguration getAllCustomers = builder.Function("GetAllConventionCustomers");
getAllCustomers.ReturnsCollectionFromEntitySet <ConventionCustomer>("ConventionCustomers");
// Top level function import with one parameter
FunctionConfiguration getCustomersById = builder.Function("GetConventionCustomerById");
getCustomersById.IsComposable = true;
getCustomersById.Parameter <int>("CustomerId");
getCustomersById.ReturnsFromEntitySet <ConventionCustomer>("ConventionCustomers");
// Top level function import with two parameters
FunctionConfiguration getOrder = builder.Function("GetConventionOrderByCustomerIdAndOrderName");
getOrder.Parameter <int>("CustomerId");
getOrder.Parameter <string>("OrderName");
getOrder.ReturnsFromEntitySet <ConventionOrder>("ConventionOrders");
// Top level function import with complex parameter
FunctionConfiguration complexFunction = builder.Function("ComplexFunction");
complexFunction.Parameter <ConventionAddress>("address");
complexFunction.Returns <string>();
// Top level function import with entity parameter
FunctionConfiguration entityFunction = builder.Function("EntityFunction");
entityFunction.Parameter <ConventionOrder>("order");
entityFunction.Returns <string>();
return(builder.GetEdmModel());
}
public static IEdmModel GetEdmModel()
{
var builder = new ODataConventionModelBuilder();
var entityCollection = builder.EntitySet <DollarCountEntity>("DollarCountEntities").EntityType.Collection;
// Add unbound functions that return collection.
FunctionConfiguration function = builder.Function("UnboundFunctionReturnsPrimitveCollection");
function.IsComposable = true;
function.ReturnsCollection <int>();
function = builder.Function("UnboundFunctionReturnsEnumCollection");
function.IsComposable = true;
function.ReturnsCollection <Color>();
function = builder.Function("UnboundFunctionReturnsDateTimeOffsetCollection");
function.IsComposable = true;
function.ReturnsCollection <DateTimeOffset>();
function = builder.Function("UnboundFunctionReturnsComplexCollection");
function.IsComposable = true;
function.ReturnsCollection <DollarCountComplex>();
function = builder.Function("UnboundFunctionReturnsEntityCollection");
function.IsComposable = true;
function.ReturnsCollectionFromEntitySet <DollarCountEntity>("DollarCountEntities");
// Add bound functions that return collection.
function = entityCollection.Function("BoundFunctionReturnsPrimitveCollection");
function.IsComposable = true;
function.ReturnsCollection <DateTimeOffset>();
function = entityCollection.Function("BoundFunctionReturnsEnumCollection");
function.IsComposable = true;
function.ReturnsCollection <Color>();
function = entityCollection.Function("BoundFunctionReturnsDateTimeOffsetCollection");
function.IsComposable = true;
function.ReturnsCollection <DateTimeOffset>();
function = entityCollection.Function("BoundFunctionReturnsComplexCollection");
function.IsComposable = true;
function.ReturnsCollection <DollarCountComplex>();
function = entityCollection.Function("BoundFunctionReturnsEntityCollection");
function.IsComposable = true;
function.ReturnsCollectionFromEntitySet <DollarCountEntity>("DollarCountEntities");
return(builder.GetEdmModel());
}
public void Configuration(IAppBuilder builder)
{
var odataBuilder = new ODataConventionModelBuilder();
odataBuilder.EntitySet <Player>("Players");
var player = odataBuilder.EntityType <Player>();
//collection function
player.Collection.Function("TopPpg").ReturnsCollection <Player>();
//entity function
player.Function("PercentageOfAllGoals").Returns <double>();
//service function
var serviceFunc = odataBuilder.Function("TotalTeamPoints");
serviceFunc.Returns <int>().Parameter <string>("team");
serviceFunc.IncludeInServiceDocument = true;
var edm = odataBuilder.GetEdmModel();
var config = new HttpConfiguration();
config.MapODataServiceRoute("Default OData", "odata", edm);
builder.UseWebApi(config);
}
private IEdmModel GetEdmModel()
{
ODataModelBuilder builder = new ODataConventionModelBuilder();
EntitySetConfiguration <Employee> employees = builder.EntitySet <Employee>("Employees");
EntitySetConfiguration <Department> departments = builder.EntitySet <Department>("Departments");
EntitySetConfiguration <Party> parties = builder.EntitySet <Party>("Parties");
EntitySetConfiguration <ObjectPermission> objectPermissions = builder.EntitySet <ObjectPermission>("ObjectPermissions");
EntitySetConfiguration <MemberPermission> memberPermissions = builder.EntitySet <MemberPermission>("MemberPermissions");
EntitySetConfiguration <TypePermission> typePermissions = builder.EntitySet <TypePermission>("TypePermissions");
employees.EntityType.HasKey(t => t.Oid);
departments.EntityType.HasKey(t => t.Oid);
parties.EntityType.HasKey(t => t.Oid);
FunctionConfiguration login = builder.Function("Login");
login.Returns <int>();
login.Parameter <string>("userName");
login.Parameter <string>("password");
builder.Action("Logout");
ActionConfiguration getPermissions = builder.Action("GetPermissions");
getPermissions.Parameter <string>("typeName");
getPermissions.CollectionParameter <string>("keys");
ActionConfiguration getTypePermissions = builder.Action("GetTypePermissions");
getTypePermissions.Parameter <string>("typeName");
getTypePermissions.ReturnsFromEntitySet <TypePermission>("TypePermissions");
return(builder.GetEdmModel());
}
public static IEdmModel GetEdmModel()
{
var builder = new ODataConventionModelBuilder();
builder.EntitySet <Resources>("Resources");
builder.EntitySet <ResourceSkills>("ResourceSkills");
builder.EntitySet <Skill>("Skills");
builder.EntitySet <Roles>("Roles");
builder.EntitySet <ClientLocation>("ClientLocations");
builder.EntitySet <ClientLocation>("ClientLocations");
builder.EntitySet <IntacctLocation>("IntacctLocations");
builder.EntitySet <EmployeeCertification>("EmployeeCertifications");
builder.EntitySet <SearchAnalytics>("SearchAnalytics");
builder.EntitySet <PageAnalytics>("PageAnalytics");
builder.EntitySet <Department>("Departments");
builder.EntitySet <ProjectMaster>("ProjectMasters");
builder.EntitySet <ResourceAssignments>("ResourceAssignments");
builder.EntitySet <Certifications>("Certifications");
builder.EntitySet <Resources>(nameof(Resources));
{
var function = builder.Function("GetResourceDetails");
function.Parameter <string>("skillName");
function.Parameter <string>("employeeName");
//function.Parameter<string>("availability");
//function.Parameter<string>("role");
//function.Parameter<string>("location");
function.Returns <string>();
}
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)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.EntitySet <ApplicantModel>("Applicants").EntityType.Filter(QueryOptionSetting.Allowed);
var function = builder.Function("getApplicants");
function.Parameter <string>("searchText");
function.ReturnsCollectionFromEntitySet <ApplicantModel>("Applicants");
//var model = builder.GetEdmModel();
app.UseCors(options => options
.AllowAnyHeader()
.AllowAnyMethod()
.AllowAnyOrigin()
.AllowCredentials()
);
app.UseMvc(b =>
{
b.MapODataServiceRoute("odata", "odata", builder.GetEdmModel());
b.EnableDependencyInjection();
b.Select()
.Expand()
.Filter()
.OrderBy(QueryOptionSetting.Allowed)
.MaxTop(2000)
.Count();
});
}
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 }
* );
*/
ODataModelBuilder builder = new ODataConventionModelBuilder();
builder.EntitySet <Game>("Games");
builder.EntitySet <Store>("Stores");
config.Count().Filter().OrderBy().Expand().Select().MaxTop(null);
builder.Function("Dalajlama").Returns <double>().Parameter <int>("Postal");
config.MapODataServiceRoute(
routeName: "ODataRoute",
routePrefix: null,
model: builder.GetEdmModel());
}
IEdmModel GetEdmModel(ODataConventionModelBuilder builder)
{
builder.EntitySet <Album>("Albums");
builder.EntitySet <Artist>("Artists");
builder.EntitySet <Customer>("Customers");
builder.EntitySet <Employee>("Employees");
builder.EntitySet <Genre>("Genres");
builder.EntitySet <Invoice>("Invoices");
builder.EntitySet <InvoiceLine>("InvoiceLines");
builder.EntitySet <MediaType>("MediaTypes");
builder.EntitySet <Playlist>("Playlists");
builder.EntitySet <Track>("Tracks");
builder.EntityType <Track>()
.Action("Rate")
.Parameter <int>("Rating");
builder.EntityType <Track>()
.Collection
.Function("MostExpensive")
.Returns <double>();
builder.Function("GetSalesTaxRate")
.Returns <double>()
.Parameter <int>("PostalCode");
return(builder.GetEdmModel());
}
public static void Register(HttpConfiguration config)
{
ODataModelBuilder builder = new ODataConventionModelBuilder();
builder.Namespace = "ProductService";
builder.EntitySet <Product>("Products");
builder.EntitySet <Supplier>("Suppliers");
builder.EntityType <Product>()
.Action("Rate")
.Parameter <int>("Rating");
builder.EntityType <Product>()
.Collection
.Function("MostExpensive")
.Returns <double>();
builder.Function("GetSalesTaxRate")
.Returns <double>()
.Parameter <int>("PostalCode");
config.Count().Filter().OrderBy().Expand().Select();
config.MapODataServiceRoute(
routeName: "ODataRoute",
routePrefix: null,
model: builder.GetEdmModel());
config.Filters.Add(new BasicAuthenticationAttribute());
}
private static IEdmModel GetEdmModel()
{
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.EntitySet <Bank>("Bank");
builder.EntitySet <Currency>("Coin");
builder.EntitySet <Deposit>("Deposit");
//builder.EntitySet<DepositWalletCurrency>("DepositWalletCurrency");
builder.EntitySet <EntitieBase>("EntitieBase");
builder.EntitySet <ImgUser>("ImgUser");
builder.EntitySet <User>("User");
builder.EntitySet <Wallet>("Wallet");
builder.EntitySet <Transfer>("Transfer");
var function = builder.Function("TotalCurrency");
function.Parameter <int>("userId");
function.Parameter <int>("currencyId");
function.Returns <double>();
return(builder.GetEdmModel());;
}
private static void GetProdutoPeloCodigo(ODataConventionModelBuilder builder)
{
var FunctionGetProdutoPeloCodigo = builder.Function("GetProdutoPeloCodigo");
FunctionGetProdutoPeloCodigo.ReturnsFromEntitySet <Produto>("Produtos");
FunctionGetProdutoPeloCodigo.Parameter <string>("Codigo");
}
private static void ExisteCodigoProduto(ODataConventionModelBuilder builder)
{
var FunctionExisteCodigoProduto = builder.Function("ExisteCodigoProduto");
FunctionExisteCodigoProduto.Returns <bool>();
FunctionExisteCodigoProduto.Parameter <string>("Codigo");
}
public static IEdmModel GetEdmModel()
{
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
EntityTypeConfiguration <Customer> customer = builder.EntitySet <Customer>("Customers").EntityType;
EntityTypeConfiguration <Order> order = builder.EntitySet <Order>("Orders").EntityType;
// Add unbound function for get special customer.
FunctionConfiguration getCustomersWithNameContaining = builder.Function("GetCustomersWithNameContaining");
getCustomersWithNameContaining.Parameter <string>("ContainedString");
getCustomersWithNameContaining.ReturnsCollectionFromEntitySet <Customer>("Customers");
// Add bound action for updating order price.
ActionConfiguration updateOrderPrice = order.Action("UpdateOrderPrice");
updateOrderPrice.Parameter <string>("Price");
updateOrderPrice.ReturnsFromEntitySet <Order>("Orders");
// Add bound function for delete order from customer and return the rest orders.
FunctionConfiguration deleteOrderFromCustomer = customer.Function("DeleteOrderFromCustomer");
deleteOrderFromCustomer.Parameter <int>("OrderId");
deleteOrderFromCustomer.ReturnsCollectionFromEntitySet <Order>("Orders");
return(builder.GetEdmModel());
}
private static void GetDescricaoProduto(ODataConventionModelBuilder builder)
{
var FunctionGetDescricaoProduto = builder.Function("GetDescricaoProduto");
FunctionGetDescricaoProduto.Returns <string>();
FunctionGetDescricaoProduto.Parameter <string>("Codigo");
}
private static void GetDescricaoAplicativo(ODataConventionModelBuilder builder)
{
var Function = builder.Function("GetDescricaoAplicativo");
Function.Parameter <string>("Codigo");
Function.Returns <string>();
}
public static IEdmModel GetConventionModel()
{
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
EntitySetConfiguration<Employee> employees = builder.EntitySet<Employee>("Employees");
EntityTypeConfiguration<Employee> employee = employees.EntityType;
employee.EnumProperty<Gender>(e => e.Sex).Name = "Gender";
employee.Collection.Function("GetEarliestTwoEmployees").ReturnsCollectionFromEntitySet<Employee>("Employees");
var functionConfiguration = builder.Function("GetAddress");
functionConfiguration.Parameter<int>("id");
functionConfiguration.Returns<Address>();
var actionConfiguration = builder.Action("SetAddress");
actionConfiguration.Parameter<int>("id");
actionConfiguration.Parameter<Address>("address");
actionConfiguration.ReturnsFromEntitySet(employees);
var resetDataSource = builder.Action("ResetDataSource");
builder.Namespace = typeof(Employee).Namespace;
builder.EnableLowerCamelCase();
var edmModel = builder.GetEdmModel();
return edmModel;
}
public static IEdmModel GetEdmModelV1()
{
var builder = new ODataConventionModelBuilder();
builder.EntitySet <Customer>("Customers");
builder.Singleton <Customer>("Me");
var function = builder.Function("RateByOrder");
function.Parameter <int>("order");
function.Returns <int>();
var action = builder.EntityType <Customer>().Action("RateByName");
action.Parameter <string>("name");
action.Parameter <int>("age");
action.Returns <string>();
// bound action
ActionConfiguration boundAction = builder.EntityType <Customer>().Action("BoundAction");
boundAction.Parameter <int>("p1");
boundAction.Parameter <Address>("p2");
boundAction.Parameter <Color?>("color");
boundAction.CollectionParameter <string>("p3");
boundAction.CollectionParameter <Address>("p4");
boundAction.CollectionParameter <Color?>("colors");
return(builder.GetEdmModel());
}
private static IEdmModel GetModel(WebRouteConfiguration configuration)
{
ODataConventionModelBuilder builder = configuration.CreateConventionModelBuilder();
EntitySetConfiguration <Trade> tradesConfiguration = builder.EntitySet <Trade>("Trades");
//Add bound function
var boundFunction = tradesConfiguration.EntityType.Collection.Function("GetTradingVolume");
boundFunction.Parameter <string>("productName");
boundFunction.Parameter <CountryOrRegion>("PortingCountryOrRegion");
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 <CountryOrRegion>("PortingCountryOrRegion");
unboundFunction.ReturnsCollectionFromEntitySet <Trade>("Trades");
builder.Namespace = typeof(CountryOrRegion).Namespace;
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 }
);
ODataModelBuilder builder = new ODataConventionModelBuilder();
builder.EntitySet <Product>("Products");
builder.EntitySet <Supplier>("Suppliers");
builder.Namespace = "ProductService";
builder.EntityType <Product>()
.Action("Rate")
.Parameter <int>("Rating");
builder.EntityType <Product>().Collection
.Function("MostExpensive")
.Returns <double>();
builder.Function("GetSalesTaxRate")
.Returns <double>()
.Parameter <int>("PostalCode");
config.MapODataServiceRoute(
routeName: "ODataRoute",
routePrefix: null,
model: builder.GetEdmModel());
}
private IEdmModel GetEdmModel()
{
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
FunctionConfiguration getEnum = builder.Function("GetEnum");
getEnum.Parameter <SimpleEnum>("simpleEnum");
getEnum.Returns <SimpleEnum>();
FunctionConfiguration getFlagsEnum = builder.Function("GetFlagsEnum");
getFlagsEnum.Parameter <FlagsEnum>("flagsEnum");
getFlagsEnum.Returns <FlagsEnum>();
return(builder.GetEdmModel());
}
private IEdmModel GetEdmModel()
{
ODataModelBuilder builder = new ODataConventionModelBuilder();
EntitySetConfiguration <Employee> employees = builder.EntitySet <Employee>("Employees");
EntitySetConfiguration <Party> parties = builder.EntitySet <Party>("Parties");
EntitySetConfiguration <PermissionContainer> permissions = builder.EntitySet <PermissionContainer>("Permissions");
EntitySetConfiguration <Department> departments = builder.EntitySet <Department>("Departments");
permissions.EntityType.HasKey(t => t.Key);
employees.EntityType.HasKey(t => t.Oid);
parties.EntityType.HasKey(t => t.Oid);
departments.EntityType.HasKey(t => t.Oid);
FunctionConfiguration logon = builder.Function("Login");
logon.Returns <int>();
logon.Parameter <string>("userName");
logon.Parameter <string>("password");
builder.Action("Logoff");
ActionConfiguration getPermissions = builder.Action("GetPermissions");
getPermissions.Parameter <string>("typeName");
getPermissions.CollectionParameter <string>("keys");
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 static void Register(HttpConfiguration config)
{
var builder = new ODataConventionModelBuilder();
//http://stackoverflow.com/questions/39515218/odata-error-the-query-specified-in-the-uri-is-not-valid-the-property-cannot-be
config.Count().Filter().OrderBy().Expand().Select().MaxTop(null);
//builder.EntitySet<Product>("Products").EntityType.Ignore( p => p.ProductCategory); // needed for serialization to work
builder.EntitySet <Product>("Products");
builder.EntitySet <Category>("Categories");
builder.EntitySet <Order>("Orders");
builder.EntitySet <OrderItem>("OrderItems");
builder.Namespace = "ProductService";
builder.EntityType <Product>()
.Action("ChangeCategory")
.Parameter <int>("CategoryId");
builder.EntityType <Product>().Collection
.Function("MostPopular")
.Returns <int>()
.Parameter <int>("CategoryId");
builder.Function("ProductCount")
.Returns <int>();
config.MapODataServiceRoute("ODataRoute", "ODataAPI", builder.GetEdmModel());
}
public static IEdmModel GetConventionModel()
{
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
EntitySetConfiguration <Employee> employees = builder.EntitySet <Employee>("Employees");
EntityTypeConfiguration <Employee> employee = employees.EntityType;
employee.EnumProperty <Gender>(e => e.Sex).Name = "Gender";
employee.Collection.Function("GetEarliestTwoEmployees").ReturnsCollectionFromEntitySet <Employee>("Employees");
var functionConfiguration = builder.Function("GetAddress");
functionConfiguration.Parameter <int>("id");
functionConfiguration.Returns <Address>();
var actionConfiguration = builder.Action("SetAddress");
actionConfiguration.Parameter <int>("id");
actionConfiguration.Parameter <Address>("address");
actionConfiguration.ReturnsFromEntitySet(employees);
var resetDataSource = builder.Action("ResetDataSource");
builder.Namespace = typeof(Employee).Namespace;
builder.EnableLowerCamelCase();
var edmModel = builder.GetEdmModel();
return(edmModel);
}
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 ODataSwaggerConverterTest()
{
var builder = new ODataConventionModelBuilder();
builder.EntitySet<Customer>("Customers");
builder.EntitySet<Order>("Orders");
builder.Function("UnboundFunction").Returns<string>().Parameter<int>("param");
builder.Action("UnboundAction").Parameter<double>("param");
builder.EntityType<Customer>().Function("BoundFunction").Returns<double>().Parameter<string>("name");
_model = builder.GetEdmModel();
}
private static IEdmModel GetEdmModel()
{
var builder = new ODataConventionModelBuilder();
builder.EntitySet<Customer>("Customers");
builder.EntitySet<Order>("Orders");
builder.Function("UnboundFunction").Returns<string>().Parameter<int>("param");
builder.Action("UnboundAction").Parameter<double>("param");
builder.EntityType<Customer>().Function("BoundFunction").Returns<double>().Parameter<string>("name");
return builder.GetEdmModel();
}
static StoreModel()
{
var builder = new ODataConventionModelBuilder();
builder.Namespace = "Microsoft.Restier.WebApi.Test";
builder.EntitySet<Product>("Products");
builder.Function("GetBestProduct").ReturnsFromEntitySet<Product>("Products");
builder.Action("RemoveWorstProduct").ReturnsFromEntitySet<Product>("Products");
Model = (EdmModel)builder.GetEdmModel();
Product = (IEdmEntityType)Model.FindType("Microsoft.Restier.WebApi.Test.Product");
}
private IEdmModel GetEdmMode()
{
ODataModelBuilder builder = new ODataConventionModelBuilder();
builder.EntitySet<OptionSet>("OptionSets");
builder.EntitySet<OptionSetEntity>("OptionSetEntities");
builder.EntitySet<GroupItemType>("GroupItemTypes");
builder.EntitySet<Group>("Groups");
builder.EntitySet<GroupItem>("GroupItems");
builder.Function("GetAllTables")
.ReturnsCollection<BaseTable>();
builder.Function("GetAllColumns")
.ReturnsCollection<BaseTable>()
.Parameter<string>("TableName");
return builder.GetEdmModel();
}
private static IEdmModel GetModel()
{
ODataModelBuilder builder = new ODataConventionModelBuilder();
builder.EntitySet<DerivedTypeA>("SetA");
builder.EntitySet<DerivedTypeB>("SetB");
builder.EntityType<BaseType>(); // this line is necessary.
builder.Function("ReturnAll").ReturnsCollection<BaseType>();
return builder.GetEdmModel();
}
private static IEdmModel GetEdmModel()
{
var builder = new ODataConventionModelBuilder();
builder.EntitySet<Customer>("Customers");
builder.EntitySet<Order>("Orders");
builder.Function("UnboundFunction").Returns<string>().Parameter<int>("param");
builder.Action("UnboundAction").Parameter<double>("param");
builder.EntityType<Customer>().Function("BoundFunction").Returns<double>().Parameter<string>("name");
builder.EntitySet<CompositeKeyItem>("CompositeKeyItems");
builder.EntityType<CompositeKeyItem>().HasKey(x => new { x.FirstKey, x.SecondKey });
return builder.GetEdmModel();
}
private static IEdmModel GetEdmModel()
{
ODataModelBuilder builder = new ODataConventionModelBuilder();
builder.EntitySet<Product2>("Products");
builder.Function("ProductsWithIds")
.ReturnsCollectionFromEntitySet<Product2>("Products")
.CollectionParameter<int>("Ids");
return builder.GetEdmModel();
}
private static IEdmModel GetEdmModel()
{
var builder = new ODataConventionModelBuilder();
builder.EntitySet<Pin>("Pins");
builder.Function("Foo").Returns<int>();
builder.EntityType<Pin>().Collection.Function("Archived").ReturnsCollection<Pin>();
return builder.GetEdmModel();
}
public static void ConfigureSsisService(this IAppBuilder app)
{
Debug.Assert(app != null);
//// build EDM model
var builder = new ODataConventionModelBuilder()
{
Namespace = typeof(SsisController).Namespace,
ContainerName = "DefaultContainer"
};
builder.ComplexType<JobParameter>();
builder.ComplexType<JobStatusResult>();
builder.EnumType<JobStatus>();
builder.EnumType<JobParameterType>();
{
var function = builder.Function("GetStatus");
function.Parameter<string>("name").OptionalParameter = false;
function.Returns<JobStatusResult>();
}
{
var action = builder.Action("Run");
action.Parameter<string>("name").OptionalParameter = false;
action.CollectionParameter<JobParameter>("parameters").OptionalParameter = false;
action.Returns<string>();
}
{
var action = builder.Action("Stop");
action.Parameter<string>("name").OptionalParameter = false;
action.Returns<string>();
}
var edmModel = builder.GetEdmModel();
//// configure web API
var config = new HttpConfiguration() { IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always };
config.MapODataServiceRoute("SsisService", "ssisservice", edmModel);
config.Services.Replace(typeof(IHttpControllerSelector), new ClientHttpControllerSelector(config, typeof(SsisServiceHelper)));
config.EnsureInitialized();
app.UseWebApi(config);
}
private static IEdmModel GetEdmModel(HttpConfiguration config)
{
ODataModelBuilder builder = new ODataConventionModelBuilder(config);
builder.EntitySet<Product>("Products");
var productType = builder.EntityType<Product>();
// Function bound to a collection
// Returns the most expensive product, a single entity
productType.Collection
.Function("MostExpensive")
.Returns<double>();
// Function bound to a collection
// Returns the top 10 product, a collection
productType.Collection
.Function("Top10")
.ReturnsCollectionFromEntitySet<Product>("Products");
// Function bound to a single entity
// Returns the instance's price rank among all products
productType
.Function("GetPriceRank")
.Returns<int>();
// Function bound to a single entity
// Accept a string as parameter and return a double
// This function calculate the general sales tax base on the
// state
productType
.Function("CalculateGeneralSalesTax")
.Returns<double>()
.Parameter<string>("state");
// Unbound Function
builder.Function("GetSalesTaxRate")
.Returns<double>()
.Parameter<string>("state");
return builder.GetEdmModel();
}
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();
}
public static void Register(HttpConfiguration config)
{
ODataModelBuilder builder = new ODataConventionModelBuilder();
builder.EntitySet<Person>("Person");
builder.EntitySet<Photo>("Photo");
builder.Namespace = "webapi";
builder.EntityType<Photo>()
.Action("PhotoPrice")
.Parameter<int>("Price");
builder.EntityType<Photo>()
.Function("ChangeName")
.Returns<bool>();
builder.Function("GetAPrice").Returns<int>().Parameter<int>("Id");
config.MapODataServiceRoute(
routeName: "ODataRoute",
routePrefix: null,
model: builder.GetEdmModel());
}
public void Configuration(IAppBuilder builder)
{
var odataBuilder = new ODataConventionModelBuilder();
odataBuilder.EntitySet<Player>("Players");
var player = odataBuilder.EntityType<Player>();
//collection function
player.Collection.Function("TopPpg").ReturnsCollection<Player>();
//entity function
player.Function("PercentageOfAllGoals").Returns<double>();
//service function
var serviceFunc = odataBuilder.Function("TotalTeamPoints");
serviceFunc.Returns<int>().Parameter<string>("team");
serviceFunc.IncludeInServiceDocument = true;
var edm = odataBuilder.GetEdmModel();
var config = new HttpConfiguration();
config.MapODataServiceRoute("Default OData", "odata", edm);
builder.UseWebApi(config);
}
public static IEdmModel GetEdmModel()
{
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
EntityTypeConfiguration<Customer> customer = builder.EntitySet<Customer>("Customers").EntityType;
EntityTypeConfiguration<Order> order = builder.EntitySet<Order>("Orders").EntityType;
// Add unbound function for get special customer.
FunctionConfiguration getCustomersWithNameContaining = builder.Function("GetCustomersWithNameContaining");
getCustomersWithNameContaining.Parameter<string>("ContainedString");
getCustomersWithNameContaining.ReturnsCollectionFromEntitySet<Customer>("Customers");
// Add bound action for updating order price.
ActionConfiguration updateOrderPrice = order.Action("UpdateOrderPrice");
updateOrderPrice.Parameter<string>("Price");
updateOrderPrice.ReturnsFromEntitySet<Order>("Orders");
// Add bound function for delete order from customer and return the rest orders.
FunctionConfiguration deleteOrderFromCustomer = customer.Function("DeleteOrderFromCustomer");
deleteOrderFromCustomer.Parameter<int>("OrderId");
deleteOrderFromCustomer.ReturnsCollectionFromEntitySet<Order>("Orders");
return builder.GetEdmModel();
}
public static IEdmModel GetEdmModel()
{
var builder = new ODataConventionModelBuilder();
var entityCollection = builder.EntitySet<DollarCountEntity>("DollarCountEntities").EntityType.Collection;
// Add unbound functions that return collection.
FunctionConfiguration function = builder.Function("UnboundFunctionReturnsPrimitveCollection");
function.IsComposable = true;
function.ReturnsCollection<int>();
function = builder.Function("UnboundFunctionReturnsEnumCollection");
function.IsComposable = true;
function.ReturnsCollection<Color>();
function = builder.Function("UnboundFunctionReturnsDateTimeOffsetCollection");
function.IsComposable = true;
function.ReturnsCollection<DateTimeOffset>();
function = builder.Function("UnboundFunctionReturnsDateCollection");
function.IsComposable = true;
function.ReturnsCollection<Date>();
function = builder.Function("UnboundFunctionReturnsComplexCollection");
function.IsComposable = true;
function.ReturnsCollection<DollarCountComplex>();
function = builder.Function("UnboundFunctionReturnsEntityCollection");
function.IsComposable = true;
function.ReturnsCollectionFromEntitySet<DollarCountEntity>("DollarCountEntities");
// Add bound functions that return collection.
function = entityCollection.Function("BoundFunctionReturnsPrimitveCollection");
function.IsComposable = true;
function.ReturnsCollection<DateTimeOffset>();
function = entityCollection.Function("BoundFunctionReturnsEnumCollection");
function.IsComposable = true;
function.ReturnsCollection<Color>();
function = entityCollection.Function("BoundFunctionReturnsDateTimeOffsetCollection");
function.IsComposable = true;
function.ReturnsCollection<DateTimeOffset>();
function = entityCollection.Function("BoundFunctionReturnsComplexCollection");
function.IsComposable = true;
function.ReturnsCollection<DollarCountComplex>();
function = entityCollection.Function("BoundFunctionReturnsEntityCollection");
function.IsComposable = true;
function.ReturnsCollectionFromEntitySet<DollarCountEntity>("DollarCountEntities");
return builder.GetEdmModel();
}
private IEdmModel GetEdmModel(HttpConfiguration configuration)
{
ODataConventionModelBuilder builder = new ODataConventionModelBuilder(configuration);
builder.EntitySet<ConventionCustomer>("ConventionCustomers");
builder.EntitySet<ConventionOrder>("ConventionOrders");
builder.ComplexType<ConventionPerson>();
builder.Entity<ConventionCustomer>().ComplexProperty<ConventionAddress>(c => c.Address);
// Top level action import
ActionConfiguration createConventionCustomerById = builder.Action("CreateConventionCustomerById");
createConventionCustomerById.Parameter<int>("ID");
createConventionCustomerById.ReturnsFromEntitySet<ConventionCustomer>("ConventionCustomers");
// Top level action import without parameter and with a collection of primitive return type
ActionConfiguration topCollectionPrimitiveAction = builder.Action("CreateCollectionMessages");
topCollectionPrimitiveAction.ReturnsCollection<string>();
// Top level function import
FunctionConfiguration getAllCustomers = builder.Function("GetAllConventionCustomers");
getAllCustomers.ReturnsCollectionFromEntitySet<ConventionCustomer>("ConventionCustomers");
// Top level function import with one parameter
FunctionConfiguration getCustomersById = builder.Function("GetConventionCustomerById");
getCustomersById.Parameter<int>("CustomerId");
getCustomersById.ReturnsFromEntitySet<ConventionCustomer>("ConventionCustomers");
// Top level function import with two parameters
FunctionConfiguration getOrder = builder.Function("GetConventionOrderByCustomerIdAndOrderName");
getOrder.Parameter<int>("CustomerId");
getOrder.Parameter<string>("OrderName");
getOrder.ReturnsFromEntitySet<ConventionOrder>("ConventionOrders");
return builder.GetEdmModel();
}
private static IEdmModel GetSampleModel()
{
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.ComplexType<EnumComplex>();
FunctionConfiguration function = builder.Function("NullableEnumFunction").Returns<bool>();
function.Parameter<Color?>("ColorParameter");
return builder.GetEdmModel();
}
private IEdmModel GetEdmModel()
{
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
FunctionConfiguration getEnum = builder.Function("GetEnum");
getEnum.Parameter<SimpleEnum>("simpleEnum");
getEnum.Returns<SimpleEnum>();
FunctionConfiguration getFlagsEnum = builder.Function("GetFlagsEnum");
getFlagsEnum.Parameter<FlagsEnum>("flagsEnum");
getFlagsEnum.Returns<FlagsEnum>();
return builder.GetEdmModel();
}
private static IEdmModel GetFunctionsEdmModel()
{
ODataModelBuilder builder = new ODataConventionModelBuilder();
builder.EntitySet<Product>("Products");
var productType = builder.EntityType<Product>();
// Function bound to a collection that accepts an enum parameter
var enumParamFunction = productType.Collection.Function("EnumParam");
enumParamFunction.Parameter<int>("Id");
enumParamFunction.Parameter<MyEnum>("EnumValue");
enumParamFunction.ReturnsCollectionFromEntitySet<Product>("Products");
// Function bound to an entity that accepts an enum parameter
var enumParamEntityFunction = productType.Function("IsEnumValueMatch");
enumParamEntityFunction.Parameter<MyEnum>("EnumValue");
enumParamEntityFunction.Returns<bool>();
// Function bound to a collection that accepts multiple parameters
var multiParamFunction = productType.Collection.Function("MultipleParams");
multiParamFunction.Parameter<int>("Id");
multiParamFunction.Parameter<int>("Year");
multiParamFunction.ReturnsCollectionFromEntitySet<Product>("Products");
// Function bound to a collection
// Returns the most expensive product, a single entity
productType.Collection
.Function("MostExpensive")
.Returns<double>();
// Function bound to a collection
// Returns the top 10 product, a collection
productType.Collection
.Function("Top10")
.ReturnsCollectionFromEntitySet<Product>("Products");
// Function bound to a single entity
// Returns the instance's price rank among all products
productType
.Function("GetPriceRank")
.Returns<int>();
// Function bound to a single entity
// Accept a string as parameter and return a double
// This function calculate the general sales tax base on the
// state
productType
.Function("CalculateGeneralSalesTax")
.Returns<double>()
.Parameter<string>("state");
// Unbound Function
builder.Function("GetSalesTaxRate")
.Returns<double>()
.Parameter<string>("state");
return builder.GetEdmModel();
}
public void CanParseUndefinedEnumValue(Type enumerationType, string enumerationExpression)
{
// Arrange
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
EnumTypeConfiguration enumTypeConfiguration = builder.AddEnumType(enumerationType);
FunctionConfiguration functionConfiguration = builder.Function("FunctionWithEnumParam");
functionConfiguration.AddParameter("Enum", enumTypeConfiguration);
functionConfiguration.Returns<int>();
IEdmModel model = builder.GetEdmModel();
string uri = String.Format("FunctionWithEnumParam(Enum={0})", enumerationExpression);
// Act & Assert
Assert.DoesNotThrow(() => _parser.Parse(model, _serviceRoot, uri));
}
public void CannotParseInvalidEnumValue(Type enumerationType, string enumerationExpression)
{
// Arrange
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
EnumTypeConfiguration enumTypeConfiguration = builder.AddEnumType(enumerationType);
FunctionConfiguration functionConfiguration = builder.Function("FunctionWithEnumParam");
functionConfiguration.AddParameter("Enum", enumTypeConfiguration);
functionConfiguration.Returns<int>();
IEdmModel model = builder.GetEdmModel();
string uri = String.Format("FunctionWithEnumParam(Enum={0})", enumerationExpression);
// Act & Assert
Assert.Throws<ODataException>(
() => _parser.Parse(model, _serviceRoot, uri),
String.Format("The string '{0}' is not a valid enumeration type constant.", enumerationExpression));
}
public void UnboundFunction_ForEnumTypeInODataConventionModelBuilder()
{
// Arrange
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
FunctionConfiguration functionConfiguration = builder.Function("UnboundFunction");
functionConfiguration.Parameter<Color>("Color");
functionConfiguration.ReturnsCollection<Color>();
// Act & Assert
IEdmModel model = builder.GetEdmModel();
IEdmFunctionImport functionImport = model.EntityContainer.OperationImports().Single(o => o.Name == "UnboundFunction") as IEdmFunctionImport;
IEdmTypeReference color = functionImport.Function.Parameters.Single(p => p.Name == "Color").Type;
IEdmTypeReference returnType = functionImport.Function.ReturnType;
IEdmEnumType colorType = model.SchemaElements.OfType<IEdmEnumType>().Single(e => e.Name == "Color");
Assert.Same(colorType, color.Definition);
Assert.True(returnType.IsCollection());
Assert.Same(colorType, returnType.AsCollection().ElementType().Definition);
}
public void CanParse_FunctionParametersAlias_WithUnresolvedPathSegment()
{
// Arrange
var builder = new ODataConventionModelBuilder();
builder.EntitySet<ConventionCustomer>("Customers");
FunctionConfiguration function = builder.Function("UnboundFunction");
function.Parameter<int>("P1");
function.Parameter<int>("P2");
function.ReturnsFromEntitySet<ConventionCustomer>("Customers");
function.IsComposable = true;
IEdmModel model = builder.GetEdmModel();
// Act
ODataPath path = _parser.Parse(
model,
_serviceRoot,
"UnboundFunction(P1=@p1,P2=@p2)/unknown?@p1=1&@p3=2&@p2=@p3");
var functionSegment = (UnboundFunctionPathSegment)path.Segments.First();
object p1 = functionSegment.GetParameterValue("P1");
object p2 = functionSegment.GetParameterValue("P2");
// Assert
Assert.Equal(1, p1);
Assert.Equal(2, p2);
}
public void ODataConventionModelBuilder_HasCorrectEnumMember_AddUnboundFunctionAfterEntitySet()
{
// Arrange
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.EntitySet<EntityTypeWithEnumTypePropertyTestModel>("Entities");
builder.Function("UnboundFunction").Returns<Color>();
// Act
IEdmModel model = builder.GetEdmModel();
// Assert
Assert.NotNull(model);
IEnumerable<IEdmEnumType> colors = model.SchemaElements.OfType<IEdmEnumType>().Where(e => e.Name == "Color");
IEdmEnumType color = Assert.Single(colors);
Assert.Equal(3, color.Members.Count());
Assert.Single(color.Members.Where(m => m.Name == "Red"));
Assert.Single(color.Members.Where(m => m.Name == "Green"));
Assert.Single(color.Members.Where(m => m.Name == "Blue"));
}
public static IEdmModel GetEdmModel()
{
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.EntitySet<ConventionCustomer>("ConventionCustomers");
builder.EntitySet<ConventionOrder>("ConventionOrders");
EnumTypeConfiguration<ConventionGender> enumType = builder.EnumType<ConventionGender>();
enumType.Member(ConventionGender.Female);
enumType.Member(ConventionGender.Male);
#region functions
FunctionConfiguration getAllCustomers = builder.Function("GetAllConventionCustomers");
getAllCustomers.ReturnsCollectionFromEntitySet<ConventionCustomer>("ConventionCustomers");
getAllCustomers.IsComposable = true;
// Return all the customers whose name contains CustomerName
FunctionConfiguration getAllCustomersOverload = builder.Function("GetAllConventionCustomers");
getAllCustomersOverload.ReturnsCollectionFromEntitySet<ConventionCustomer>("ConventionCustomers");
getAllCustomersOverload.Parameter<string>("CustomerName");
getAllCustomersOverload.IsComposable = true;
FunctionConfiguration getCustomersById = builder.Function("GetConventionCustomerById");
getCustomersById.Parameter<int>("CustomerId");
getCustomersById.ReturnsFromEntitySet<ConventionCustomer>("ConventionCustomers");
getCustomersById.IsComposable = true;
FunctionConfiguration getOrder = builder.Function("GetConventionOrderByCustomerIdAndOrderName");
getOrder.Parameter<int>("CustomerId");
getOrder.Parameter<string>("OrderName");
getOrder.ReturnsFromEntitySet<ConventionOrder>("ConventionOrders");
FunctionConfiguration getCustomerNameById = builder.Function("GetConventionCustomerNameById");
getCustomerNameById.Parameter<int>("CustomerId");
getCustomerNameById.Returns<string>();
FunctionConfiguration getDefinedGenders = builder.Function("GetDefinedGenders");
getDefinedGenders.ReturnsCollection<ConventionGender>()
.IsComposable = true;
FunctionConfiguration function = builder.Function("AdvancedFunction").Returns<bool>();
function.CollectionParameter<int>("nums");
function.CollectionParameter<ConventionGender>("genders");
function.Parameter<ConventionAddress>("location");
function.CollectionParameter<ConventionAddress>("addresses");
function.EntityParameter<ConventionCustomer>("customer");
function.CollectionEntityParameter<ConventionCustomer>("customers");
#endregion
#region actions
ActionConfiguration resetDataSource = builder.Action("ResetDataSource");
// bug: error message: non-binding parameter type must be either Primitive, Complex, Collection of Primitive or a Collection of Complex.
/*
ActionConfiguration createCustomer = builder.Action("CreateCustomer");
createCustomer.Parameter<ConventionCustomer>("Customer");
createCustomer.ReturnsFromEntitySet<ConventionCustomer>("ConventionCustomers");
*/
ActionConfiguration udpateAddress = builder.Action("UpdateAddress");
udpateAddress.Parameter<ConventionAddress>("Address");
udpateAddress.Parameter<int>("ID");
udpateAddress.ReturnsCollectionFromEntitySet<ConventionCustomer>("ConventionCustomers");
ActionConfiguration action = builder.Action("AdvancedAction");
action.CollectionParameter<int>("nums");
action.CollectionParameter<ConventionGender>("genders");
action.Parameter<ConventionAddress>("location");
action.CollectionParameter<ConventionAddress>("addresses");
action.EntityParameter<ConventionCustomer>("customer");
action.CollectionEntityParameter<ConventionCustomer>("customers");
#endregion
var schemaNamespace = typeof(ConventionCustomer).Namespace;
builder.Namespace = schemaNamespace;
var edmModel = builder.GetEdmModel();
var container = edmModel.EntityContainer as EdmEntityContainer;
#region function imports
var entitySet = container.FindEntitySet("ConventionCustomers");
var getCustomersByIdOfEdmFunction = edmModel.FindDeclaredOperations(schemaNamespace + ".GetConventionCustomerById").First() as EdmFunction;
container.AddFunctionImport("GetConventionCustomerByIdImport", getCustomersByIdOfEdmFunction, new EdmEntitySetReferenceExpression(entitySet));
var functionsOfGetAllConventionCustomers = edmModel.FindDeclaredOperations(schemaNamespace + ".GetAllConventionCustomers");
var getAllConventionCustomersOfEdmFunction = functionsOfGetAllConventionCustomers.FirstOrDefault(f => f.Parameters.Count() == 0) as EdmFunction;
container.AddFunctionImport("GetAllConventionCustomersImport", getAllConventionCustomersOfEdmFunction, new EdmEntitySetReferenceExpression(entitySet));
// TODO delete this overload after bug 1640 is fixed: It can not find the correct overload function if the the function is exposed as a function import.
var getAllConventionCustomersOverloadOfEdmFunction = functionsOfGetAllConventionCustomers.FirstOrDefault(f => f.Parameters.Count() > 0) as EdmFunction;
container.AddFunctionImport("GetAllConventionCustomersImport", getAllConventionCustomersOverloadOfEdmFunction, new EdmEntitySetReferenceExpression(entitySet));
var entitySet1 = container.FindEntitySet("ConventionOrders");
var GetConventionOrderByCustomerIdAndOrderNameOfEdmFunction = edmModel.FindDeclaredOperations(schemaNamespace + ".GetConventionOrderByCustomerIdAndOrderName").First() as EdmFunction;
container.AddFunctionImport("GetConventionOrderByCustomerIdAndOrderNameImport", GetConventionOrderByCustomerIdAndOrderNameOfEdmFunction, new EdmEntitySetReferenceExpression(entitySet1));
var getConventionCustomerNameByIdOfEdmFunction = edmModel.FindDeclaredOperations(schemaNamespace + ".GetConventionCustomerNameById").First() as EdmFunction;
container.AddFunctionImport("GetConventionCustomerNameByIdImport", getConventionCustomerNameByIdOfEdmFunction, null);
#endregion
#region action imports
var resetDataSourceOfEdmAction = edmModel.FindDeclaredOperations(schemaNamespace + ".ResetDataSource").FirstOrDefault() as EdmAction;
container.AddActionImport("ResetDataSourceImport", resetDataSourceOfEdmAction);
// TODO: it is a potential issue that entity can not be used as an un-bound parameter.
/*
var createCustomerOfEdmAction = edmModel.FindDeclaredOperations(schemaNamespace + ".CreateCustomer").FirstOrDefault() as EdmAction;
container.AddActionImport("CreateCustomerImport", createCustomerOfEdmAction);
*/
var updateAddressOfEdmAction = edmModel.FindDeclaredOperations(schemaNamespace + ".UpdateAddress").FirstOrDefault() as EdmAction;
container.AddActionImport("UpdateAddressImport", updateAddressOfEdmAction, new EdmEntitySetReferenceExpression(entitySet));
#endregion
return edmModel;
}
private IEdmModel GetEdmModel()
{
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.EntityType<Customer>().Namespace = "NS";
builder.ComplexType<Address>().Namespace = "NS";
FunctionConfiguration getEnum = builder.Function("GetEnum");
getEnum.Parameter<SimpleEnum>("simpleEnum");
getEnum.Returns<SimpleEnum>();
FunctionConfiguration getFlagsEnum = builder.Function("GetFlagsEnum");
getFlagsEnum.Parameter<FlagsEnum>("flagsEnum");
getFlagsEnum.Returns<FlagsEnum>();
FunctionConfiguration function = builder.Function("GetNullableFlagsEnum").Returns<bool>();
function.Parameter<FlagsEnum?>("flagsEnum");
builder.Function("GetAddress").Returns<bool>().Parameter<Address>("address");
builder.Function("GetCustomer").Returns<bool>().Parameter<Customer>("customer");
return builder.GetEdmModel();
}
private static IEdmModel GetEdmModel()
{
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.Namespace = "ODataSamples.WebApiService.Models";
builder.ContainerName = "DefaultContainer";
builder.EntitySet<Person>("People");
builder.EntitySet<Airport>("Airports");
builder.EntitySet<Airline>("Airlines");
builder.Singleton<Person>("Me");
// Customer - Order scenarios
builder.EntitySet<Customer>("Customers");
builder.EntitySet<Order>("Orders");
#region Unbound Function & Action
builder.Action("ResetDataSource");
//TODO : Double type has some issue.
var GetNearestAirportFun = builder.Function("GetNearestAirport");
GetNearestAirportFun.Parameter<double>("lat");
GetNearestAirportFun.Parameter<double>("lon");
GetNearestAirportFun.ReturnsFromEntitySet<Airport>("Airports");
#endregion
#region Person Function & Action
var personType = builder.EntityType<Person>();
personType.Function("GetFavoriteAirline")
.ReturnsFromEntitySet<Airline>("Airlines");
//TODO: Fix this issue, the return type can't be "Trip".
personType.Function("GetFriendsTrips")
.ReturnsCollectionFromEntitySet<Airline>("Airlines")
.Parameter<string>("userName");
var shareTripAction = personType.Action("ShareTrip");
shareTripAction.Parameter<string>("userName");
shareTripAction.Parameter<int>("tripId");
#endregion
#region Trip Function & Action
// TODO: The request will fail, should fix this issue.
// GET odata/People('russellwhyte')/Trips(1001)/ODataSamples.WebApiService.Models.GetInvolvedPeople()
var tripType = builder.EntityType<Trip>();
tripType.Function("GetInvolvedPeople")
.ReturnsCollectionFromEntitySet<Person>("People");
#endregion
#region Add Navigation Target
var edmModel = builder.GetEdmModel();
var peopleEntitySet = edmModel.EntityContainer.FindEntitySet("People") as EdmEntitySet;
var meSingleton = edmModel.EntityContainer.FindSingleton("Me") as EdmSingleton;
var flightEntityType = edmModel.FindDeclaredType("ODataSamples.WebApiService.Models.Flight") as EdmEntityType;
var propertyAriline = flightEntityType.FindProperty("Airline") as EdmNavigationProperty;
var propertyFrom = flightEntityType.FindProperty("From") as EdmNavigationProperty;
var propertyTo = flightEntityType.FindProperty("To") as EdmNavigationProperty;
var targetAirlines = edmModel.EntityContainer.FindEntitySet("Airlines");
var targetAirports = edmModel.EntityContainer.FindEntitySet("Airports");
peopleEntitySet.AddNavigationTarget(propertyAriline, targetAirlines);
peopleEntitySet.AddNavigationTarget(propertyFrom, targetAirports);
peopleEntitySet.AddNavigationTarget(propertyTo, targetAirports);
meSingleton.AddNavigationTarget(propertyAriline, targetAirlines);
meSingleton.AddNavigationTarget(propertyFrom, targetAirports);
meSingleton.AddNavigationTarget(propertyTo, targetAirports);
#endregion
return edmModel;
}
public static IEdmModel GetEdmModel()
{
if (_edmModel == null)
{
var builder = new ODataConventionModelBuilder();
builder.EntitySet <Customer>("Customers");
builder.EntitySet <Order>("Orders");
// two overload function import
var function = builder.Function("CalcByRating");
function.Parameter <int>("order");
function.ReturnsFromEntitySet <Customer>("Customers");
function = builder.Function("CalcByRating");
function.Parameter <string>("name");
function.ReturnsFromEntitySet <Customer>("Customers");
// action import
var action = builder.Action("CalcByRatingAction");
action.Parameter <int>("order");
action.ReturnsFromEntitySet <Customer>("Customers");
_edmModel = builder.GetEdmModel();
}
return(_edmModel);
}
