/// <summary>
/// Builds an Entity Data Model used by the message router and controllers.
/// </summary>
/// <returns>An Entity Data Model.</returns>
/// <remarks>
/// DTOs need an EntitySet so that the OData controller can 'magically' parse the json into an object.
/// Only ONE DTO can be bound per table, so a BaseDto object is needed.
/// </remarks>
///
private static IEdmModel GetImplicitEdm()
{
var builder = new ODataConventionModelBuilder();
builder.EntitySet <LocationBaseDto>("Locations");
builder.EntitySet <LocationLogEntryBaseDto>("LocationLogEntries");
builder.EntitySet <LocationTypeBaseDto>("LocationTypes");
builder.EntitySet <DashboardBaseDto>("Dashboards");
builder.EntitySet <DashboardOptionBaseDto>("DashboardOptions");
builder.EntitySet <UnitTypeBaseDto>("UnitTypes");
builder.EntitySet <UnitTypeGroupQueryDto>("UnitTypeGroups");
builder.EntitySet <ParameterTypeQueryDto>("ParameterTypes");
builder.EntitySet <ParameterQueryDto>("Parameters");
builder.EntitySet <ParameterValidRangeQueryDto>("ParameterValidRanges");
builder.EntitySet <LimitTypeQueryDto>("LimitTypes");
builder.EntitySet <ChemicalFormTypeQueryDto>("ChemicalFormTypes");
builder.EntitySet <InAppMessageBaseDto>("InAppMessages");
// Adding the Extensions Namespace and Custom Function for In-App Messages
// See https://github.com/OData/WebApi/issues/766 for an explanation of why
// ReturnsCollectionFromEntitySet is required for this function
var inAppMessages = builder.EntityType <InAppMessageBaseDto>()
.Collection
.Function("GetByUserId")
.ReturnsCollectionFromEntitySet <InAppMessageBaseDto>("InAppMessages");
inAppMessages.Parameter <Guid>("userId");
inAppMessages.Namespace = "Extensions";
builder.EnableLowerCamelCase();
return(builder.GetEdmModel());
}
// 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.UseSwagger();
app.UseSwaggerUI(c => c.SwaggerEndpoint("/swagger/v1/swagger.json", "dotnet5_odata v1"));
}
app.UseHttpsRedirection();
app.UseRouting();
app.UseAuthorization();
var builder = new ODataConventionModelBuilder();
builder.EnableLowerCamelCase();
builder.EntitySet <Foo>("Foos");
app.UseEndpoints(endpoints =>
{
endpoints.MapControllers();
endpoints.Select().Filter();
endpoints.MapODataRoute("odata", "odata", builder.GetEdmModel());
endpoints.EnableDependencyInjection();
});
}
public static void Register(HttpConfiguration config)
{
// Web API configuration and services
// TOOD: change it in production
var cors = new EnableCorsAttribute("*", "*", "*");
config.EnableCors(cors);
// Web API routes
config.MapHttpAttributeRoutes();
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
var builder = new ODataConventionModelBuilder();
builder.EnableLowerCamelCase();
config.Formatters.Add(new FlatFormatter(new QueryStringMapping("$format", "flat", "application/json")));
builder.EntitySet<Namespace>("Namespaces");
builder.EntitySet<Translation>("Translations");
config.MapODataServiceRoute(
routeName: "ODataRoute",
routePrefix: null,
model: builder.GetEdmModel());
}
protected override void Initialize(HttpConfiguration configuration)
{
var builder = new ODataConventionModelBuilder();
builder.Namespace = "Unit.Test";
builder.EnableLowerCamelCase();
var address = builder.ComplexType <Address>();
var people = builder.EntitySet <Person>("People");
var person = people.EntityType;
address.Namespace = builder.Namespace;
address.HasAnnotation(a => a.IsPrimary);
people.HasAnnotation("Version", 2.0);
people.HasComplexAnnotations("Links", new[] { new Link("help", new Uri("http://localhost/api/help")) });
person.Namespace = builder.Namespace;
person.HasKey(p => p.Id);
person.HasAnnotation(p => p.Timestamp);
person.HasAnnotation(p => p.Flags);
person.HasAnnotations(p => p.SeoTerms);
person.HasComplexAnnotations(p => p.Links);
person.Ignore(p => p.PhotoImage);
person.Ignore(p => p.PhotoImageType);
person.HasAnnotation(p => p.Birthday).ForProperty(p => p.Age);
person.HasComplexAnnotation(p => p.DisplayStyle).ForProperty(p => p.FirstName);
var model = builder.GetEdmModelWithAnnotations();
configuration.EnableCaseInsensitive(true);
configuration.EnableInstanceAnnotations();
configuration.MapODataServiceRoute("odata", "api", model);
}
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 IEdmModel CreateModel()
{
var modelBuilder = new ODataConventionModelBuilder();
modelBuilder.EnableLowerCamelCase();
modelBuilder.Namespace = ContainerNamespace;
modelBuilder.ContainerName = "fileRepository";
var fileType = modelBuilder.EntityType <File>();
fileType.Name = Camelize(fileType.Name);
fileType.Namespace = TypeNamespace;
var uploadSessionType = modelBuilder.EntityType <UploadSession>();
uploadSessionType.Name = Camelize(uploadSessionType.Name);
uploadSessionType.Namespace = TypeNamespace;
modelBuilder.EntitySet <File>("files");
modelBuilder.EntitySet <UploadSession>("uploadSessions");
var model = modelBuilder.GetEdmModel() as EdmModel;
var edmFileType = model.FindDeclaredType(QualifiedTypeName(fileType.Name)) as EdmEntityType;
SetPrivateFieldValue(edmFileType, "hasStream", true);
model.SetDescriptionAnnotation(edmFileType, "Represents a file in the file repository.");
return(model);
}
public static void Register(HttpConfiguration config)
{
var modelBuilder = new ODataConventionModelBuilder(config);
//modelBuilder.ResolverEdmModel();
//modelBuilder.RegisterOdataEntities();
modelBuilder.EnableLowerCamelCase();
config.EnableCaseInsensitive(true);
modelBuilder.EntitySet <Person>("People");
modelBuilder.Namespace = "f";
modelBuilder.EntityType <Person>()
.Action("Acao")
.Parameter <int>("Rating");
modelBuilder.EntityType <Person>()
.Function("Funcao")
.Returns <double>()
;
config.MapODataServiceRoute(
ODataConstants.RouteName,
ODataConstants.RoutePrefix,
modelBuilder.GetEdmModel(),
new DefaultODataBatchHandler(GlobalConfiguration.DefaultServer)
);
}
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() }));
}
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 IEdmModel GetEdmModel(System.IServiceProvider serviceProvider)
{
var builder = new ODataConventionModelBuilder(serviceProvider);
//builder.EntitySet<Account>("Accounts");
//builder.EntitySet<BusinessUnit>("BusinessUnits");
builder.EntitySet <Contact>("Contacts");
builder.EntitySet <Email>("Emails");
builder.EntitySet <Content>("Contents");
/*
* builder.EntitySet<Contact>("Contacts")
* .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
* .Expand();
*
* builder.EntitySet<Email>("Emails")
* .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
* .Expand();
*/
builder.EnableLowerCamelCase();
return(builder.GetEdmModel());
}
public static void Register(HttpConfiguration config)
{
config.MapHttpAttributeRoutes();
// Web API configuration and services
var builder = new ODataConventionModelBuilder();
config.EnableUnqualifiedNameCall(true);
config.EnableEnumPrefixFree(true);
RegisterEntities(ref builder);
RegisterCustomRoutes(ref builder);
builder.Namespace = "";
builder.EnableLowerCamelCase();
ODataBatchHandler odataBatchHandler =
new DefaultODataBatchHandler(new HttpServer(config));
odataBatchHandler.MessageQuotas.MaxOperationsPerChangeset = 10;
odataBatchHandler.MessageQuotas.MaxPartsPerBatch = 10;
config.MapODataServiceRoute("odata", "odata", builder.GetEdmModel(), odataBatchHandler);
// Web API routes
}
private IEdmModel GetEdmModel(IServiceProvider serviceProvider)
{
var builder = new ODataConventionModelBuilder(serviceProvider);
builder.EnableLowerCamelCase();
builder.EntitySet <DailyReadingDTO>("DailyReading")
.EntityType
.Filter(QueryOptionSetting.Allowed)
.Count()
.OrderBy()
.Page()
.Select();
builder.EntityType <DailyReadingDTO>().Filter("type");
builder.EntitySet <SaintDTO>("Saint")
.EntityType
.Filter(QueryOptionSetting.Allowed)
.Count()
.OrderBy()
.Page()
.Select();
builder.EntityType <SaintDTO>().Filter("id");
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);
}
// 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();
}
app.UseAuthentication();
app.UseCors("AllowSpecificOrigin");
var builder = new ODataConventionModelBuilder(app.ApplicationServices);
builder.EntitySet <Author>(nameof(Author));
builder.EntitySet <Book>(nameof(Book));
builder.EnableLowerCamelCase();
AutoMapper.Mapper.Initialize(cfg =>
{
cfg.CreateMap <Author, AuthorDto>()
.ForMember(dest => dest.Name, opt => opt.MapFrom(src =>
$"{src.FirstName} {src.LastName}"))
.ForMember(dest => dest.Age, opt => opt.MapFrom(src =>
src.DateOfBirth.GetCurrentAge()));
cfg.CreateMap <Book, BookDto>();
});
app.UseMvc(routeBuilder =>
{
routeBuilder.Count().Filter().OrderBy().Expand().Select().MaxTop(null);
routeBuilder.MapODataServiceRoute("ODataRoute", "odata", builder.GetEdmModel());
routeBuilder.EnableDependencyInjection();
});
}
public static void Register(HttpConfiguration config)
{
var cors = new EnableCorsAttribute(
origins: "*",
headers: "*",
methods: "*");
config.EnableCors(cors);
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.EnableLowerCamelCase();
builder.EntitySet <Translation>("Translations");
builder.EntitySet <Category>("Categories");
builder.EntitySet <QuizQuestion>("QuizQuestions");
builder.EntitySet <LearningType>("LearningTypes");
config.MapODataServiceRoute("odata", "odata", 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)
{
var builder = new ODataConventionModelBuilder(app.ApplicationServices);
builder.EntitySet <Product>("Products");
builder.EntitySet <Product>("products");
//builder.EntitySet<ProductDetail>("Detail");
builder.ComplexType <ProductCategory>();
// Convert all query data to lower case
builder.EnableLowerCamelCase(); // with this option, "Products({Id})/Detail" must change to "Products({Id})/detail"
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
//app.UseMvc();
app.UseMvc(routeBuilder =>
{
// Enable query operators in the routing
routeBuilder.Count().Filter().OrderBy().Expand().Select().MaxTop(null);
// Odata Route: ~/odata/~
routeBuilder.MapODataServiceRoute("OData", "odata", builder.GetEdmModel());
// Workaround: https://github.com/OData/WebApi/issues/1175
routeBuilder.EnableDependencyInjection();
});
}
protected override void Initialize(HttpConfiguration configuration)
{
var builder = new ODataConventionModelBuilder();
builder.Namespace = "Test";
builder.EnableLowerCamelCase();
configuration.EnableCaseInsensitive(true);
configuration.EnableMediaResources();
var people = builder.EntitySet <Person>("People");
var person = people.EntityType;
person.Namespace = builder.Namespace;
person.HasKey(p => p.Id);
person.MediaType(p => p.PhotoImageType);
person.Ignore(p => p.Flags);
person.Ignore(p => p.Timestamp);
person.Ignore(p => p.SeoTerms);
person.Ignore(p => p.Links);
person.Ignore(p => p.PhotoImage);
person.Ignore(p => p.Birthday);
person.Ignore(p => p.DisplayStyle);
var model = builder.GetEdmModelWithAnnotations();
configuration.MapODataServiceRoute("odata", "api", model);
}
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;
}
// 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.EntitySet <Company>("Companies");
builder.EnableLowerCamelCase();
var model = builder.GetEdmModel();
app.UseMvc(routeBuilder =>
{
routeBuilder.Select().Expand().Filter().OrderBy().MaxTop(1).Count();
routeBuilder.MapODataServiceRoute(routeName: "OData", routePrefix: "odata", model: model);
routeBuilder.EnableDependencyInjection();
routeBuilder.MapRoute(name: "default", template: "{controller=Home}/{action=Index}/{id?}"); // enable mvc controllers
});
app.UseODataBatching();
}
public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
var builder = new ODataConventionModelBuilder(app.ApplicationServices);
builder.EntitySet <OrderDto>("Orders");
builder.EnableLowerCamelCase();
app.UseMvc(routeBuilder =>
{
routeBuilder.MapODataServiceRoute("ODataRoute", "odata", builder.GetEdmModel());
//// Work-around for #1175
routeBuilder.EnableDependencyInjection(containerBuilder =>
containerBuilder.AddService <ODataUriResolver>(
Microsoft.OData.ServiceLifetime.Singleton,
_ => app.ApplicationServices.GetRequiredService <ODataUriResolver>()));
});
Mapper.Initialize(cfg =>
cfg.CreateMap <BusinessOrder, OrderDto>()
.ForMember(o => o.Id, o => o.MapFrom(v => v.OrderId))
.ForMember(o => o.Name, o => o.MapFrom(v => v.OrderName))
.ForMember(o => o.Quantity, o => o.MapFrom(v => v.OrderQuantity))
.ForMember(o => o.DebugMessage, o => o.MapFrom(v => v.DebugMessage))
);
Mapper.AssertConfigurationIsValid();
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env, IServiceProvider serviceProvider)
{
app.UseCors("AllowAll");
var builder = new ODataConventionModelBuilder(serviceProvider);
builder.EnableLowerCamelCase();
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();
}
app.UseHangfireDashboard();
app.UseHttpsRedirection();
app.UseAuthentication();
app.UseMvc(routeBuilder =>
{
routeBuilder.MapODataServiceRoute("ftapi", "ftapi", builder.AddEntitySet());
routeBuilder.Count().Filter().OrderBy().Expand().Select().MaxTop(null);
routeBuilder.EnableDependencyInjection();
routeBuilder.MapRoute(
name: "DefaultApi", template: "api/{controller}/{id?}"
);
});
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
else
{
app.UseExceptionHandler("/Error");
// The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseSpaStaticFiles();
app.UseODataBatching();
//app.UseCors("CorsPolicy");
app.UseCors("AllowAllOrigins");
//app.UseSignalR(routes =>
//{
// routes.MapHub<NotifyHub>("notify");
//});
app.UseSignalR(route =>
{
route.MapHub <ChatHub>("/chathub");
route.MapHub <StockTickerHub>("/stock");
route.MapHub <DynamicChatHub>("/dynamichub");
});
app.UseMvc(routes =>
{
var builder = new ODataConventionModelBuilder();
builder.EntitySet <WeatherForecast>("SampleData");
builder.EnableLowerCamelCase();
routes.Select().Expand().Filter().OrderBy().MaxTop(100).Count();
routes.MapODataServiceRoute("odata", "odata", builder.GetEdmModel(), new DefaultODataBatchHandler());
routes.MapRoute(
name: "default",
template: "{controller}/{action=Index}/{id?}");
});
app.UseSpa(spa =>
{
// To learn more about options for serving an Angular SPA from ASP.NET Core,
// see https://go.microsoft.com/fwlink/?linkid=864501
spa.Options.SourcePath = "ClientApp";
if (env.IsDevelopment())
{
spa.UseAngularCliServer(npmScript: "start");
}
});
}
private static IEdmModel GetEdmModel()
{
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.EnableLowerCamelCase();
builder.EntitySet <Dto.Item>("Items").EntityType.Page(500, 50);
return(builder.GetEdmModel());
}
private static IEdmModel GenerateEdmModel()
{
var builder = new ODataConventionModelBuilder();
builder.EnableLowerCamelCase();
builder.EntitySet<TranslatedVideo>("Videos");
return builder.GetEdmModel();
}
private static IEdmModel GetEdmModel()
{
var builder = new ODataConventionModelBuilder();
builder.EntitySet <TestEntity>("TestEntities");
builder.EnableLowerCamelCase();
return(builder.GetEdmModel());
}
public static IEdmModel GetEdmModel()
{
var builder = new ODataConventionModelBuilder();
builder.EntitySet <WeatherForecastVm>("WeatherForecast");
builder.EnableLowerCamelCase();
return(builder.GetEdmModel());
}
public static IEdmModel ODataEntityModelFactory(Action <ODataConventionModelBuilder> action)
{
var builder = new ODataConventionModelBuilder();
action(builder);
return(builder
.EnableLowerCamelCase()
.GetEdmModel());
}
public static IEdmModel GetModel()
{
var builder = new ODataConventionModelBuilder();
builder.EnableLowerCamelCase();
var setOrders = builder.EntitySet <SchoolModel>("Schools").EntityType.HasKey(x => new { x.SchoolId });
return(builder.GetEdmModel());
}
private static IEdmModel GetEdmModel()
{
var builder = new ODataConventionModelBuilder();
builder.EnableLowerCamelCase();
builder.EntitySet <Partition>("Partition");
builder.EntitySet <Message>("Message");
builder.EntitySet <AppHistory>("AppHistory");
return(builder.GetEdmModel());
}
private static void ConfigureOData(HttpConfiguration config)
{
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.EnableLowerCamelCase();
builder.EntitySet <Models.Customer>("Customers");
config.MapODataServiceRoute("odata", "odata", builder.GetEdmModel());
}
public IEdmModel GetEdmModel(IServiceProvider serviceProvider)
{
var builder = new ODataConventionModelBuilder(serviceProvider);
builder.EnableLowerCamelCase();
builder.EntitySet <BudgetOdataViewModel>("Budgets");
return(builder.GetEdmModel());
}
public ODataApiBuilder(IServiceCollection services, bool enableLowerCamelCase)
{
Services = services;
_modelBuilder = new ODataConventionModelBuilder();
if (enableLowerCamelCase)
{
_modelBuilder.EnableLowerCamelCase();
}
_metadata = new List <EntityMetadata>();
}
private static IEdmModel GetEdmModel()
{
var odataBuilder = new ODataConventionModelBuilder();
odataBuilder.EnableLowerCamelCase();
//odataBuilder.EntitySet<ProjectTracker>("ProjectTracker");
//odataBuilder.EntitySet<Machine>("Machines");
//odataBuilder.EntitySet<Line>("Lines");
return(odataBuilder.GetEdmModel());
}
private static IEdmModel GetCustomRouteModel()
{
var builder = new ODataConventionModelBuilder();
builder.EnableLowerCamelCase();
builder.EntitySet<Customer>("Customers");
builder.EntitySet<Order>("Orders");
return builder.GetEdmModel();
}
private static IEdmModel GetEdmModel()
{
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.EnableLowerCamelCase(); // WTF
builder.EntitySet <AuthorApiViewModel>("Authors"); // CAMELCASE!
builder.EntitySet <BookApiViewModel>("Books"); // CAMELCASE!
return(builder.GetEdmModel());
}
private static IEdmModel GetProductWithEnumKeyModel()
{
var builder = new ODataConventionModelBuilder();
builder.EnableLowerCamelCase();
builder.EntitySet <ProductWithEnumKey>("ProductWithEnumKeysTest");
return(builder.GetEdmModel());
}
private static IEdmModel GetVersionedModel()
{
var builder = new ODataConventionModelBuilder();
builder.EnableLowerCamelCase();
builder.EntitySet <Customer>("Customers");
return(builder.GetEdmModel());
}
private static IEdmModel GetEdmModel()
{
var builder = new ODataConventionModelBuilder();
builder.EntitySet<ProjectSimpleResponseModel, SearchController>();
builder.EntityType<ProjectSimpleResponseModel>().Property(x => x.ShortDate);
builder.EntityType<ProjectSimpleResponseModel>().Property(x => x.TitleUrl);
builder.Namespace = typeof(ProjectSimpleResponseModel).Namespace;
builder.EnableLowerCamelCase();
return builder.GetEdmModel();
}
private static IEdmModel GetEdmModel()
{
var builder = new ODataConventionModelBuilder();
builder.EntitySet<Brand>("Brands");
builder.EnableLowerCamelCase(NameResolverOptions.ProcessReflectedPropertyNames | NameResolverOptions.ProcessExplicitPropertyNames);
builder.EntityType<Brand>().Ignore(brand => brand.Name);
return builder.GetEdmModel();
}
private static IEdmModel GetEdmModel()
{
var builder = new ODataConventionModelBuilder {Namespace = typeof (Log).Namespace};
builder.EntitySet<Log>("logs");
builder.EntitySet<Logs_Full.Result>("logs_full");
builder.EntitySet<Application>("applications");
builder.EntitySet<Environment>("environments");
builder.EntitySet<DataSource>("dataSources");
builder.EnableLowerCamelCase();
var edmModel = builder.GetEdmModel();
return edmModel;
}
private static IEdmModel GenerateEdmModel()
{
var builder = new ODataConventionModelBuilder();
builder.EnableLowerCamelCase();
builder.EntitySet<TranslatedComment>("Comments");
builder.EntitySet<TranslatedAbuse>("Abuses");
// TOOD: check why when I added lines below - author is no longer navigation property and I don't have to use: $expand=author
builder.Namespace = "Actions";
builder.EntityType<TranslatedComment>().Action("VoteUp").Parameter<VoteUp>("vote");
builder.EntityType<TranslatedComment>().Action("VoteDown").Parameter<VoteDown>("vote");
builder.EntityType<TranslatedComment>().Action("ReportAbuse").Parameter<Report>("report");
return builder.GetEdmModel();
}
private static IEdmModel GenerateEdmModel()
{
var builder = new ODataConventionModelBuilder();
builder.EnableLowerCamelCase();
builder.EntitySet<Suggestion>("Suggestions");
builder.EntitySet<VoteUp>("VotesUp");
builder.EntitySet<VoteDown>("VotesDown");
builder.EntitySet<View>("Views");
builder.Namespace = "Actions";
builder.EntityType<Suggestion>().Action("VoteUp").Parameter<VoteUp>("vote");
builder.EntityType<Suggestion>().Action("VoteDown").Parameter<VoteDown>("vote");
builder.EntityType<Suggestion>().Action("CountView").Parameter<View>("view");
return builder.GetEdmModel();
}
public static IEdmModel GetModel()
{
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
EntitySetConfiguration<Employee> employees = builder.EntitySet<Employee>("Employees");
EntityTypeConfiguration<Employee> employee = employees.EntityType;
employee.EnumProperty<Gender>(e => e.Sex).Name = "Gender";
var resetDataSource = builder.Action("ResetDataSource");
builder.Namespace = typeof(Employee).Namespace;
// All the property names in the generated Edm Model will become camel case if EnableLowerCamelCase() is called.
builder.EnableLowerCamelCase();
var edmModel = builder.GetEdmModel();
return edmModel;
}
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 ) );
config.MapHttpAttributeRoutes();
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.EnableLowerCamelCase();
builder.EntitySet<Session>( "Sessions" );
var userEntityType = builder.EntitySet<Account>( "Users" ).EntityType;
userEntityType.Ignore( e => e.Claims );
userEntityType.Ignore( e => e.Logins );
userEntityType.Ignore( u => u.Password );
builder.EntitySet<Profile>( "Profiles" );
config.MapODataServiceRoute(
"odata",
"odata",
builder.GetEdmModel(),
new ODataNullValueMessageHandler()
{
InnerHandler = new HttpControllerDispatcher( config )
} );
// Web API routes
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
}
private static IEdmModel GetFunctionsEdmModel()
{
var builder = new ODataConventionModelBuilder();
builder.EnableLowerCamelCase();
builder.EntitySet<Product>("Products");
var productType = builder.EntityType<Product>();
// Function bound to a collection that accepts an enum parameter
var enumParamFunction = productType.Collection.Function("GetByEnumValue");
enumParamFunction.Parameter<MyEnum>("EnumValue");
enumParamFunction.ReturnsCollectionFromEntitySet<Product>("Products");
// Function bound to an entity set
// Returns the most expensive product, a single entity
productType.Collection
.Function("MostExpensive")
.Returns<double>();
// Function bound to an entity set
// 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");
// Function bound to an entity set
// Accepts an array as a parameter
productType.Collection
.Function("ProductsWithIds")
.ReturnsCollectionFromEntitySet<Product>("Products")
.CollectionParameter<int>("Ids");
// An action bound to an entity set
// Accepts multiple action parameters
var createAction = productType.Collection.Action("Create");
createAction.ReturnsFromEntitySet<Product>("Products");
createAction.Parameter<string>("Name").OptionalParameter = false;
createAction.Parameter<double>("Price").OptionalParameter = false;
createAction.Parameter<MyEnum>("EnumValue").OptionalParameter = false;
// An action bound to an entity set
// Accepts an array of complex types
var postArrayAction = productType.Collection.Action("PostArray");
postArrayAction.ReturnsFromEntitySet<Product>("Products");
postArrayAction.CollectionParameter<ProductDto>("products").OptionalParameter = false;
// An action bound to an entity
productType.Action("Rate")
.Parameter<int>("Rating");
return builder.GetEdmModel();
}
private static IEdmModel GetProductWithCompositeEnumIntKeyModel()
{
var builder = new ODataConventionModelBuilder();
builder.EnableLowerCamelCase();
builder.EntitySet<ProductWithCompositeEnumIntKey>
("ProductWithCompositeEnumIntKeys");
return builder.GetEdmModel();
}
