public static void Register(HttpConfiguration config)
{
// Web API configuration and services
// Configure Web API to use only bearer token authentication.
config.SuppressDefaultHostAuthentication();
config.Filters.Add(new HostAuthenticationFilter(OAuthDefaults.AuthenticationType));
// Web API routes
config.MapHttpAttributeRoutes();
// enable EnableQuery (global)
config.AddODataQueryFilter();
// enable external consuming
config.EnableCors();
config.Routes.MapHttpRoute(
name: "DefaultApiWithAction",
routeTemplate: "api/{controller}/{action}/{id}",
defaults: new { id = RouteParameter.Optional });
// config.Routes.MapHttpRoute(
// name: "DefaultApi",
// routeTemplate: "api/{controller}/{id}",
// defaults: new { id = RouteParameter.Optional });
// return JSON
config.Formatters.JsonFormatter.SupportedMediaTypes.Add(new MediaTypeHeaderValue("text/html"));
}
private static void Configuration(IAppBuilder builder)
{
HttpConfiguration configuration = new HttpConfiguration();
var server = new HttpServer(configuration);
configuration.Routes.MapDynamicODataServiceRoute(
"odata",
"odata",
server);
DynamicOData.AddDataSource(new maskx.OData.Sql.SQLDataSource(_DataSourceName));
//DynamicOData.AddDataSource(new maskx.OData.Sql.SQL2008(_DataSourceName,
// ConnectionString,
// (action, target) =>
// {
// Console.WriteLine("{0}\t{1}\t{2}", "permissionCheck", action, target);
// return true;
// }));
//DynamicOData.BeforeExcute = (ri) =>
//{
// ri.Parameters["UserId"] = new JValue(3003);
// Console.WriteLine("BeforeExcute:{0}", ri.Target);
//};
configuration.AddODataQueryFilter();
builder.UseWebApi(configuration);
}
public void Configuration(IAppBuilder app)
{
// For more information on how to configure your application, visit http://go.microsoft.com/fwlink/?LinkID=316888
//app.UseWelcomePage();
var config = new HttpConfiguration();
config.Formatters.Clear();
config.Formatters.Add(new JsonMediaTypeFormatter());
config.MapHttpAttributeRoutes();
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
config.AddODataQueryFilter();
app.UseWebApi(config);
//app.MapSignalR();
//ADD DUMMY DATA
IList<Person> persons = new List<Person>();
persons.Add(new Person() { Id = 1, Age = 34, Name = "Claudio" });
persons.Add(new Person() { Id = 2, Age = 28, Name = "Fabi" });
Singleton.Instance.Persons = new List<Person>(persons);
}
public static void Register(HttpConfiguration config)
{
config.Filters.Add(new CheckPermissionAttribute { Permission = PredefinedPermissions.SecurityCallApi });
// Web API routes
config.MapHttpAttributeRoutes();
config.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always;
//config.Routes.MapHttpRoute("DefaultApiGet", "api/{controller}/{id}", new { id = RouteParameter.Optional }, new { id = @"^[0-9]+$" });
config.Routes.MapHttpRoute("DefaultApi", "api/{controller}/{action}/{id}", new { id = RouteParameter.Optional, action = RouteParameter.Optional });
var formatter = config.Formatters.JsonFormatter;
formatter.SerializerSettings.ContractResolver = new DeltaContractResolver(formatter);
formatter.SerializerSettings.ReferenceLoopHandling = ReferenceLoopHandling.Ignore;
formatter.SerializerSettings.DateTimeZoneHandling = DateTimeZoneHandling.Utc;
//formatter.SerializerSettings.DefaultValueHandling = DefaultValueHandling.Ignore;
formatter.SerializerSettings.NullValueHandling = NullValueHandling.Ignore;
//config.Formatters.JsonFormatter.SerializerSettings.
// Uncomment the following line of code to enable query support for actions with an IQueryable or IQueryable<T> return type.
// To avoid processing unexpected or malicious queries, use the validation settings on QueryableAttribute to validate incoming queries.
// For more information, visit http://go.microsoft.com/fwlink/?LinkId=279712.
//config.EnableQuerySupport();
config.AddODataQueryFilter();
var json = config.Formatters.JsonFormatter;
json.SerializerSettings.PreserveReferencesHandling = PreserveReferencesHandling.None;
json.SerializerSettings.Formatting = Formatting.Indented;
config.Formatters.Remove(config.Formatters.XmlFormatter);
}
public static void Register(HttpConfiguration config)
{
// Web API configuration and services
// Web API routes
config.MapHttpAttributeRoutes();
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
// OData
ODataModelBuilder builder = new ODataConventionModelBuilder();
builder.EntitySet<Player>("Players");
builder.EntitySet<BattingDetail>("BattingDetails");
builder.EntitySet<BowlingDetail>("BowlingDetails");
builder.EntitySet<Country>("Countrys");
builder.EntitySet<Match>("Matches").EntityType.HasKey(m => m.MatchNumber);
config.AddODataQueryFilter();
config.MapODataServiceRoute(
routeName: "odata",
routePrefix: "odata",
model: builder.GetEdmModel());
}
public static void Register(HttpConfiguration config)
{
// OData configuration
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.EntitySet<Author>("authors");
builder.EntitySet<Blog>("blogs");
builder.EntitySet<Comment>("comments");
builder.EntitySet<Post>("posts");
builder.ContainerName = "BlogItDataService";
config.Routes.MapODataServiceRoute("OData", "api/odata", builder.GetEdmModel());
var queryAttributes = new EnableQueryAttribute()
{
PageSize = 100,
MaxTop = 100,
EnsureStableOrdering = false
};
config.AddODataQueryFilter(queryAttributes);
// Web API attribute routing
config.MapHttpAttributeRoutes();
// Additional formatters
config.Formatters.Add(new BsonMediaTypeFormatter());
}
public static void Register(HttpConfiguration config)
{
config.Filters.Add(new CheckPermissionAttribute { Permission = PredefinedPermissions.SecurityCallApi });
// Web API routes
config.MapHttpAttributeRoutes();
config.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always;
var formatter = config.Formatters.JsonFormatter;
formatter.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
formatter.SerializerSettings.ReferenceLoopHandling = ReferenceLoopHandling.Ignore;
formatter.SerializerSettings.DateTimeZoneHandling = DateTimeZoneHandling.Utc;
//formatter.SerializerSettings.DefaultValueHandling = DefaultValueHandling.Ignore;
formatter.SerializerSettings.NullValueHandling = NullValueHandling.Ignore;
formatter.SerializerSettings.Converters.Add(new StringEnumConverter { CamelCaseText = true });
//config.Formatters.JsonFormatter.SerializerSettings.
// Uncomment the following line of code to enable query support for actions with an IQueryable or IQueryable<T> return type.
// To avoid processing unexpected or malicious queries, use the validation settings on QueryableAttribute to validate incoming queries.
// For more information, visit http://go.microsoft.com/fwlink/?LinkId=279712.
//config.EnableQuerySupport();
config.AddODataQueryFilter();
var json = config.Formatters.JsonFormatter;
json.SerializerSettings.PreserveReferencesHandling = PreserveReferencesHandling.None;
json.SerializerSettings.Formatting = Formatting.Indented;
json.SerializerSettings.Error += (sender, args) =>
{
//Need escalate any JSON serialization exception as HTTP error
HttpContext.Current.AddError(args.ErrorContext.Error);
};
config.Formatters.Remove(config.Formatters.XmlFormatter);
}
public static void Register(HttpConfiguration config)
{
// Web API configuration and services
// Web API routes
config.MapHttpAttributeRoutes();
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
//config.Formatters.JsonFormatter.SerializerSettings.ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Serialize;
//config.Formatters.JsonFormatter.SerializerSettings.PreserveReferencesHandling = Newtonsoft.Json.PreserveReferencesHandling.Objects;
config.Formatters.JsonFormatter.SupportedMediaTypes.Add(new MediaTypeHeaderValue("text/html"));
config.Formatters.JsonFormatter.SupportedMediaTypes.Add(new MediaTypeHeaderValue("multipart/form-data"));
config.Formatters.JsonFormatter.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
config.Formatters.JsonFormatter.SerializerSettings.Formatting = Formatting.Indented;
config.Formatters.JsonFormatter.SerializerSettings.DateTimeZoneHandling = DateTimeZoneHandling.Local;
config.Formatters.JsonFormatter.SerializerSettings.DateFormatString = "yyyy-MM-ddTHH:mm:ss";
config.AddODataQueryFilter();
//Odata case insensitive
config.EnableCaseInsensitive(true);
}
public static void Register(HttpConfiguration config)
{
// Attribute routing.
config.MapHttpAttributeRoutes();
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "v1/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
// Uncomment the following line of code to enable query support for actions with an IQueryable or IQueryable<T> return type.
// To avoid processing unexpected or malicious queries, use the validation settings on QueryableAttribute to validate incoming queries.
// For more information, visit http://go.microsoft.com/fwlink/?LinkId=279712.
config.AddODataQueryFilter();
var builder = new ODataConventionModelBuilder();
builder.EntitySet<Repository>("Repositories");
builder.EntitySet<Session>("Sessions");
builder.EntitySet<LogEntry>("LogEntries");
config.Routes.MapODataServiceRoute("odata", "odata/v1", builder.GetEdmModel());
// To disable tracing in your application, please comment out or remove the following line of code
// For more information, refer to: http://www.asp.net/web-api
config.EnableSystemDiagnosticsTracing();
// Use camel case for JSON data.
config.Formatters.JsonFormatter.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
}
public static void Register(HttpConfiguration config)
{
// Web API configuration and services
// Configure Web API to use only bearer token authentication.
config.SuppressDefaultHostAuthentication();
config.Filters.Add(new HostAuthenticationFilter(OAuthDefaults.AuthenticationType));
// Web API routes
config.MapHttpAttributeRoutes();
config.AddODataQueryFilter();
config.Routes.MapHttpRoute(
name: "PostsApi",
routeTemplate: "api/{controller}/{action}"
);
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
config.Formatters.JsonFormatter.SerializerSettings.ContractResolver =
new CamelCasePropertyNamesContractResolver();
}
public static void Register(HttpConfiguration config)
{
// Web API configuration and services
// Configure Web API to use only bearer token authentication.
config.SuppressDefaultHostAuthentication();
config.Filters.Add(new HostAuthenticationFilter(OAuthDefaults.AuthenticationType));
// Web API routes
config.MapHttpAttributeRoutes();
config.AddODataQueryFilter();
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{action}/{id}",
defaults: new { id = RouteParameter.Optional }
);
config.Formatters.JsonFormatter.SerializerSettings.PreserveReferencesHandling = Newtonsoft.Json.PreserveReferencesHandling.None;
config.Formatters.Remove(config.Formatters.XmlFormatter);
//var corsAttr = new EnableCorsAttribute("*", "*", "*");
//config.EnableCors(corsAttr);
config.EnableCors(new EnableCorsAttribute("*", "*", "*"));
}
public static void UpdateConfiguration(HttpConfiguration configuration)
{
configuration.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always;
var conventions = ODataRoutingConventions.CreateDefault();
configuration.MapODataServiceRoute("CustomActionConventions", "CustomActionConventions", GetCustomActionConventionsModel(configuration), new DefaultODataPathHandler(), ODataRoutingConventions.CreateDefault());
configuration.AddODataQueryFilter();
}
public static void Register(HttpConfiguration config)
{
config.MapHttpAttributeRoutes();
config.EnableCors();
config.AddODataQueryFilter();
config.Routes.MapHttpRoute("DefaultApi", "api/{controller}/{action}/{id}", new { id = RouteParameter.Optional });
}
public static void Register(HttpConfiguration config)
{
DynamicModelHelper.CustomMapODataServiceRoute(
config.Routes,
"odata",
"odata");
config.AddODataQueryFilter();
}
public static void UpdateConfiguration(HttpConfiguration configuration)
{
configuration.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always;
IList<IODataRoutingConvention> conventions = ODataRoutingConventions.CreateDefault();
conventions.Insert(0, new ReflectedPropertyRoutingConvention());
configuration.MapODataServiceRoute("OData", null, GetEdmModel(configuration), new DefaultODataPathHandler(), conventions);
configuration.AddODataQueryFilter();
}
public void AddQuerySupport_AddsQueryableFilterProvider()
{
HttpConfiguration configuration = new HttpConfiguration();
configuration.AddODataQueryFilter();
var queryFilterProviders = configuration.Services.GetFilterProviders().OfType<QueryFilterProvider>();
Assert.Equal(1, queryFilterProviders.Count());
var queryAttribute = Assert.IsType<EnableQueryAttribute>(queryFilterProviders.First().QueryFilter);
}
public void Configuration(IAppBuilder app)
{
var httpConfiguration = new HttpConfiguration();
httpConfiguration.AddODataQueryFilter();
// Configure Web API Routes:
// - Enable Attribute Mapping
// - Enable Default routes at /api.
//httpConfiguration.MapHttpAttributeRoutes();
//httpConfiguration.Routes.MapHttpRoute(
// name: "DefaultApi",
// //routeTemplate: "api/{controller}/{id}",
// routeTemplate: "api/{namespace}/{controller}/{id}",
// defaults: new { id = RouteParameter.Optional }
//);
//httpConfiguration.Services.Replace(typeof(IHttpControllerSelector), new VersionHttpControllerSelector(httpConfiguration));
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
//var route = httpConfiguration.Routes.Where(r => r is System.Web.Http.OData.Routing.ODataRoute).First();
//var odataRoute = route as System.Web.Http.OData.Routing.ODataRoute;
//httpConfiguration.MapODataServiceRoute(
// routeName: "OrdersRoute",
// routePrefix: "odata",
// model: builder.GetEdmModel(),
// pathHandler: odataRoute.Constraints.PathHandler,
// routingConventions: odataRoute.PathRouteConstraint.RoutingConventions);
builder.EntitySet<Order>("Orders");
builder.EntitySet<OrderItem>("OrderItems");
builder.EntitySet<OrderItemOption>("OrderItemOptions");
// mock the route prefix to api/v1 until the proper versioning is implemented
httpConfiguration.MapODataServiceRoute("OData", "api/v1", builder.GetEdmModel()); //, new DefaultODataBatchHandler(GlobalConfiguration.DefaultServer));
app.UseWebApi(httpConfiguration);
var odataFormatters = ODataMediaTypeFormatters.Create(new NullSerializerProvider(), new DefaultODataDeserializerProvider());
httpConfiguration.Formatters.InsertRange(0, odataFormatters);
httpConfiguration.EnsureInitialized();
// Make ./public the default root of the static files in our Web Application.
app.UseFileServer(new FileServerOptions
{
RequestPath = new PathString(string.Empty),
FileSystem = new PhysicalFileSystem("./public"),
EnableDirectoryBrowsing = true,
});
app.UseStageMarker(PipelineStage.MapHandler);
}
public static void Register(HttpConfiguration config)
{
config.MapHttpAttributeRoutes();
config.EnableCors();
config.AddODataQueryFilter();
config.Routes.MapHttpRoute("DefaultApi", "api/{controller}/{action}/{id}", new { id = RouteParameter.Optional });
config.Formatters.JsonFormatter.SerializerSettings.PreserveReferencesHandling = PreserveReferencesHandling.None;
config.Formatters.Remove(config.Formatters.XmlFormatter);
}
public static void UpdateConfiguration(HttpConfiguration configuration)
{
configuration.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always;
configuration.Routes.MapODataServiceRoute("Relationships", "Relationships", GetRelationshipsModel(configuration));
configuration.Routes.MapODataServiceRoute("Inheritance", "Inheritance", GetInheritanceModel(configuration));
configuration.Routes.MapODataServiceRoute("CustomNavigationPropertyConventions", "CustomNavigationPropertyConventions", GetCustomNavigationPropertyConventionsModel(configuration));
configuration.Routes.MapODataServiceRoute("CustomReadLinkConventions", "CustomReadLinkConventions", GetCustomReadLinkConventionsModel(configuration));
configuration.Routes.MapODataServiceRoute("CustomEditLinkConventions", "CustomEditLinkConventions", GetCustomEditLinkConventionsModel(configuration));
configuration.Routes.MapODataServiceRoute("CustomIdLinkConventions", "CustomIdLinkConventions", GetCustomIdLinkConventionsModel(configuration));
configuration.AddODataQueryFilter();
}
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));
// Routes
config.MapHttpAttributeRoutes();
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{action}/{id}",
defaults: new { id = RouteParameter.Optional }
);
// OData
// Query support
//config.EnableQuerySupport();
var odataFilter = new EnableQueryAttribute() { MaxExpansionDepth = 4 };
config.AddODataQueryFilter(odataFilter);
//config.Routes.MapODataRoute(
// routeName: "ODataRoute",
// routePrefix: "odata",
// model: edm,
// batchHandler: new BatchHandler(GlobalConfiguration.DefaultServer));
// Add the CompositeKeyRoutingConvention
var conventions = System.Web.Http.OData.Routing.Conventions.ODataRoutingConventions.CreateDefault();
conventions.Insert(0, new CompositeKeyRoutingConvention());
// Routes
var edm = DbUtility.GetWealthEconomyContextEdm();
config.Routes.MapODataServiceRoute(
routeName: "ODataRoute",
routePrefix: "odata",
model: edm,
pathHandler: new System.Web.Http.OData.Routing.DefaultODataPathHandler(),
routingConventions: conventions,
batchHandler: new BatchHandler(GlobalConfiguration.DefaultServer));
// Json formatter
config.Formatters.JsonFormatter.SerializerSettings.ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Ignore;
// Exception logger
config.Services.Add(typeof(IExceptionLogger), new ElmahExceptionLogger());
// Exception handler
config.Services.Replace(typeof(IExceptionHandler), new GenericExceptionHandler());
}
// This code configures Web API. The Startup class is specified as a type
// parameter in the WebApp.Start method.
public void Configuration(IAppBuilder appBuilder)
{
// Configure Web API for self-host.
HttpConfiguration config = new HttpConfiguration();
config.AddODataQueryFilter();
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
appBuilder.UseWebApi(config);
}
public static void Register(HttpConfiguration config)
{
// Web API configuration and services
// Configure Web API to use only bearer token authentication.
config.SuppressDefaultHostAuthentication();
config.Filters.Add(new HostAuthenticationFilter(OAuthDefaults.AuthenticationType));
// Web API routes
config.MapHttpAttributeRoutes();
var attribute = new EnableCorsAttribute("*", "*", "*");
config.EnableCors(attribute);
config.AddODataQueryFilter();
// CHEATING:
//to cheat use "nickname=IAmCheater&sessionKey=IndeedIAm" - the system will act as if you're logged in
// MAIN ROUTES:
//DefaultApi + api/{controller}/all?nickname={nickname}&sessionKey={sessionKey}
//DefaultApi + api/{controller}/select?id={id}&nickname={nickname}&sessionKey={sessionKey}
//DefaultApi + api/{controller}/add?nickname={nickname}&sessionKey={sessionKey} (+ objectToAdd in body)
//DefaultApi + api/{controller}/edit?id={id}&nickname={nickname}&sessionKey={sessionKey} (+ editedObject in body)
//DefaultApi + api/{controller}/delete?id={id}&nickname={nickname}&sessionKey={sessionKey}
// CUSTOM ROUTES:
//DefaultApi + api/çomments/byuser?id={id}&nickname={nickname}&sessionKey={sessionKey}
//DefaultApi + api/çomments/onrecepie?id={id}&nickname={nickname}&sessionKey={sessionKey}
//DefaultApi + api/recepiephases/byrecepie?id={id}&nickname={nickname}&sessionKey={sessionKey}
//DefaultApi + api/favourites/byuser?id={id}&nickname={nickname}&sessionKey={sessionKey} - returns recepies
//DefaultApi + api/favourites/byrecepie?id={id}&nickname={nickname}&sessionKey={sessionKey} - returns users
//DefaultApi + api/recepies/minutes?id={id}&nickname={nickname}&sessionKey={sessionKey} - returns time to prepare (int)
//DefaultApi + api/userinfo/register(+ UserObject in body)
//DefaultApi + api/userinfo/login(+ UserObject in body)
//DefaultApi + api/userinfo/logout?nickname={nickname}&sessionKey={sessionKey}
// OTHER
//Favourites has NO "All" method!
//Favourites has NO "Select" method!
//Favourites has NO "Edit" method!
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{action}/{id}",
defaults: new { id = RouteParameter.Optional }
);
config.Formatters.JsonFormatter.SerializerSettings.PreserveReferencesHandling = PreserveReferencesHandling.None;
config.Formatters.Remove(config.Formatters.XmlFormatter);
}
public static void Register(HttpConfiguration config)
{
// Web API configuration and services
config.AddODataQueryFilter(); //need odata package
config.Formatters.Add(new BrowserJsonFormatter());
// Web API routes
config.MapHttpAttributeRoutes();
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
}
private void ConfigureWebApi(HttpConfiguration httpConfig)
{
httpConfig.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
httpConfig.MapODataServiceRoute(
routeName: "ODataRoute",
routePrefix: "OData",
model: GenerateEdmModel()
);
httpConfig.AddODataQueryFilter();
}
public static void Register(HttpConfiguration config)
{
// Web API configuration and services
config.MapHttpAttributeRoutes();
config.EnableCors();
config.AddODataQueryFilter();
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{action}/{id}",
defaults: new { id = RouteParameter.Optional }
);
config.Formatters.JsonFormatter.SerializerSettings.PreserveReferencesHandling = Newtonsoft.Json.PreserveReferencesHandling.None;
config.Formatters.Remove(config.Formatters.XmlFormatter);
}
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.AddODataQueryFilter();
// Web API routes
config.MapHttpAttributeRoutes();
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
}
public static void Register(HttpConfiguration config)
{
config.MapHttpAttributeRoutes();
config.EnableCors();
config.AddODataQueryFilter();
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{action}/{id}",
defaults: new { id = RouteParameter.Optional }
);
config.Formatters.JsonFormatter.SerializerSettings.PreserveReferencesHandling = Newtonsoft.Json.PreserveReferencesHandling.None;
config.Formatters.JsonFormatter.SupportedMediaTypes.Add(new MediaTypeHeaderValue("text/html"));
config.Formatters.Remove(config.Formatters.XmlFormatter);
config.EnableCors(new EnableCorsAttribute("*", "*", "*"));
}
public static void UpdateConfiguration(HttpConfiguration configuration)
{
configuration.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always;
var conventions = ODataRoutingConventions.CreateDefault();
conventions.Insert(0, new NavigationRoutingConvention2());
conventions.Insert(0, new LinkRoutingConvention2());
configuration.Routes.MapODataServiceRoute(
ODataTestConstants.DefaultRouteName,
null,
GetEdmModel(configuration),
new DefaultODataPathHandler(),
conventions);
configuration.AddODataQueryFilter();
}
public static void Register(HttpConfiguration config)
{
// Web API configuration and services
config.Formatters.JsonFormatter.SupportedMediaTypes.Add(new MediaTypeHeaderValue("text/html"));
config.EnableCors();
config.AddODataQueryFilter();
// Web API routes
config.MapHttpAttributeRoutes();
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{action}/{id}",
defaults: new { id = RouteParameter.Optional }
);
}
public void AddODataQueryFilter_WorksWithActionsWithQuerable_And_EnableQuery(string url)
{
// Arrange
HttpConfiguration configuration = new HttpConfiguration();
configuration.AddODataQueryFilter();
configuration.Routes.MapHttpRoute("api", "api/{controller}/{action}");
configuration.Routes.MapODataServiceRoute("odata", "odata", GetModel());
HttpServer server = new HttpServer(configuration);
HttpClient client = new HttpClient(server);
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, url + "?$expand=Orders");
// Act
HttpResponseMessage response = client.SendAsync(request).Result;
// Assert
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
}
public void AddODataQueryFilter_WorksWithActionsWithQuerable_And_EnableQuery(string url)
{
// Arrange
HttpConfiguration configuration = new HttpConfiguration();
configuration.AddODataQueryFilter();
configuration.Routes.MapHttpRoute("api", "api/{controller}/{action}");
configuration.Routes.MapODataServiceRoute("odata", "odata", GetModel());
HttpServer server = new HttpServer(configuration);
HttpClient client = new HttpClient(server);
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, url + "?$expand=Orders");
// Act
HttpResponseMessage response = client.SendAsync(request).Result;
// Assert
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
}
public static void Register(System.Web.Http.HttpConfiguration config)
{
// Web-API-Konfiguration und -Dienste
// Web-API-Routen
config.MapHttpAttributeRoutes();
//ODataModelBuilder builder = new ODataConventionModelBuilder();
//builder.EntitySet<Contracts.IResident>("Residents");
//config.AddODataQueryFilter(new System.Web.Http.Filters.ActionFilterAttribute() );
//config.Routes.MapODataRoute("ODataRoute", "odata", GetEdmModel());
//ODataModelBuilder builder = new ODataConventionModelBuilder();
//builder.EntitySet<Models.ResidentViewModel>("Residents");
//config.MapODataServiceRoute(
// routeName: "ODataRoute",
// routePrefix: "odata",
// model: builder.GetEdmModel());
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.EntitySet <Models.ResidentViewModel>("ResidentViewModels");
config.AddODataQueryFilter();
//config.MapODataServiceRoute(routeName: "oDataRoute", routePrefix: "odata", model: builder.GetEdmModel());
config.MapODataServiceRoute(routeName: "oDataRoute", routePrefix: "odata", model: builder.GetEdmModel());
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
//config.MapODataServiceRoute( "odata", null, GetEdmModel(), new DefaultODataBatchHandler(GlobalConfiguration.DefaultServer));
config.EnsureInitialized();
}
