[InlineData("GET", "http://localhost/Customers(12)/NS.SpecialCustomer/NS.GetSalary()", "GetSalaryFromSpecialCustomer_12")] // call function on derived entity type public async Task AttriubteRouting_SelectsExpectedControllerAndAction(string method, string requestUri, string expectedResult) { // Arrange CustomersModelWithInheritance model = new CustomersModelWithInheritance(); var controllers = new[] { typeof(CustomersController), typeof(MetadataAndServiceController), typeof(OrdersController) }; TestAssemblyResolver resolver = new TestAssemblyResolver(new MockAssembly(controllers)); HttpConfiguration config = new HttpConfiguration(); config.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always; config.Services.Replace(typeof(IAssembliesResolver), resolver); config.MapODataServiceRoute("odata", "", model.Model); HttpServer server = new HttpServer(config); config.EnsureInitialized(); HttpClient client = new HttpClient(server); HttpRequestMessage request = new HttpRequestMessage(new HttpMethod(method), requestUri); // Act var response = await client.SendAsync(request); // Assert if (!response.IsSuccessStatusCode) { Assert.False(true, await response.Content.ReadAsStringAsync()); } var result = await response.Content.ReadAsAsync<AttributeRoutingTestODataResponse>(); Assert.Equal(expectedResult, result.Value); }
/// <summary> /// Load the httpConfiguration /// </summary> /// <param name="config"></param> 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)); // Use camel case for JSON data and remove XML support config.Formatters.JsonFormatter.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver(); config.Formatters.JsonFormatter.SerializerSettings.Converters.Add( new StringEnumConverter { CamelCaseText = true }); config.Formatters.Remove(config.Formatters.XmlFormatter); // Set dependency injection SetAutofacContainer(config); // Web API routes config.MapHttpAttributeRoutes(); // Ensure initializations of config and starts to listen. config.EnsureInitialized(); // Enables CORS config.EnableCors(); // Ensure initialization is correct config.EnsureInitialized(); }
public static RouteInfo RouteRequest(HttpConfiguration config, HttpRequestMessage request) { // create context var controllerContext = new HttpControllerContext(config, Mock.Of<IHttpRouteData>(), request); config.EnsureInitialized(); // get route data var routeData = config.Routes.GetRouteData(request); RemoveOptionalRoutingParameters(routeData.Values); request.Properties[HttpPropertyKeys.HttpRouteDataKey] = routeData; controllerContext.RouteData = routeData; // get controller type var controllerDescriptor = new DefaultHttpControllerSelector(config).SelectController(request); controllerContext.ControllerDescriptor = controllerDescriptor; // get action name var actionMapping = new ApiControllerActionSelector().SelectAction(controllerContext); return new RouteInfo { Controller = controllerDescriptor.ControllerType, Action = actionMapping.ActionName, RouteData = controllerContext.RouteData }; }
public static void Register(HttpConfiguration config) { config.MapHttpAttributeRoutes(); config.Routes.MapHttpRoute( name: "DefaultApi", routeTemplate: "api/{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.EnableQuerySupport(); // 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(); //config.Services.Replace(typeof(IHttpControllerSelector), new VersionControllerSelector(config)); config.MessageHandlers.Add(new UserProfileMessageHandler()); config.EnsureInitialized(); }
public void Configuration(IAppBuilder app) { JsonConvert.DefaultSettings = () => { var settings = new JsonSerializerSettings { DateFormatHandling = DateFormatHandling.IsoDateFormat, DateParseHandling = DateParseHandling.DateTimeOffset, DateTimeZoneHandling = DateTimeZoneHandling.RoundtripKind, ContractResolver = new CamelCasePropertyNamesContractResolver(), MissingMemberHandling = MissingMemberHandling.Ignore, TypeNameHandling = TypeNameHandling.None }; return settings; }; var config = new HttpConfiguration(); config.MapHttpAttributeRoutes(); config.Formatters.Remove(config.Formatters.XmlFormatter); config.Formatters.JsonFormatter.SerializerSettings = JsonConvert.DefaultSettings(); config.EnsureInitialized(); ConfigureAutofac(app, config); app.UseWebApi(config); }
public static void Register(HttpConfiguration config) { config.Formatters.JsonFormatter.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver(); // Web API routes config.MapHttpAttributeRoutes(); config.Routes.MapHttpRoute( name: "ActionApi", routeTemplate: "api/{controller}/{action}/{id}", defaults: new { id = RouteParameter.Optional } ); config.Routes.MapHttpRoute( name: "ControllerOnly", routeTemplate: "api/{controller}" ); config.Routes.MapHttpRoute( name: "DefaultApi", routeTemplate: "api/{controller}/{id}", defaults: new { id = RouteParameter.Optional } ); config.MessageHandlers.Insert(0, new ServerCompressionHandler(new GZipCompressor(), new DeflateCompressor())); config.EnsureInitialized(); }
protected void Application_Start() { AreaRegistration.RegisterAllAreas(); FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters); RouteConfig.RegisterRoutes(RouteTable.Routes); BundleConfig.RegisterBundles(BundleTable.Bundles); // HelpPage config HttpConfiguration config = new HttpConfiguration(); WebApiConfig.Register(config); HelpPageConfig.Register(config); config.EnsureInitialized(); DependencyResolver.SetResolver( type => { if (type == typeof(HelpController)) { return new HelpController(config); } return null; }, type => Enumerable.Empty<object>()); }
// This code configures Web API. The Startup class is specified as a type // parameter in the WebApp.Start method. public void Configuration(IAppBuilder appBuilder) { var config = new HttpConfiguration(); //config.Routes.MapHttpRoute( // name: "DefaultApi", // routeTemplate: "api/{controller}/{id}", // defaults: new { id = RouteParameter.Optional } //); // web api config.MapHttpAttributeRoutes(); // static files appBuilder.UseFileServer(new FileServerOptions { FileSystem = new EmbeddedResourceFileSystem(typeof(Startup).Assembly, "Jukebox.Device.Web") }); config.EnsureInitialized(); appBuilder.UseWebApi(config); config.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always; }
public void Configuration(IAppBuilder appBuilder) { HttpConfiguration config = new HttpConfiguration(); PhysicalFileSystem physicalFileSystem = new PhysicalFileSystem(@".\wwwroot"); FileServerOptions fileOptions = new FileServerOptions(); fileOptions.EnableDefaultFiles = true; fileOptions.RequestPath = PathString.Empty; fileOptions.FileSystem = physicalFileSystem; fileOptions.DefaultFilesOptions.DefaultFileNames = new[] {"Default.html"}; fileOptions.StaticFileOptions.FileSystem = fileOptions.FileSystem = physicalFileSystem; fileOptions.StaticFileOptions.ServeUnknownFileTypes = true; FormatterConfig.ConfigureFormatters(config.Formatters); RouteConfig.RegisterRoutes(config); appBuilder.UseWebApi(config); appBuilder.UseFileServer(fileOptions); //CORS & SignalR appBuilder.UseCors(CorsOptions.AllowAll); HubConfiguration configR = new HubConfiguration(); configR.EnableDetailedErrors = true; appBuilder.MapSignalR(configR); GlobalHost.DependencyResolver.Register(typeof(IUserIdProvider), () => new SignalRUserIdProvider()); config.EnsureInitialized(); }
public void Configuration(IAppBuilder app) { var autoFacBuilder = new ContainerBuilder(); HttpConfiguration config = new HttpConfiguration(); ConfigureAutoFac(autoFacBuilder); autoFacBuilder.RegisterApiControllers(Assembly.GetExecutingAssembly()); autoFacBuilder.RegisterWebApiFilterProvider(config); autoFacBuilder.RegisterWebApiModelBinders(Assembly.GetExecutingAssembly()); var container = autoFacBuilder.Build(); config.DependencyResolver = new AutofacWebApiDependencyResolver(container); app.UseAutofacMiddleware(container); app.UseAutofacWebApi(config); ConfigureAuth(app); WebApiConfig.Register(config); app.UseCors(Microsoft.Owin.Cors.CorsOptions.AllowAll); app.UseWebApi(config); config.EnsureInitialized(); }
public static void Register(HttpConfiguration config) { config.MapHttpAttributeRoutes(); config.Routes.MapHttpRoute( name: "UtilitiesApi", routeTemplate: "api/utility/{action}/{id}", defaults: new { controller = "Utility", id = RouteParameter.Optional } ); config.Routes.MapHttpRoute( name: "DefaultApi", routeTemplate: "api/{controller}/{id}", defaults: new { id = RouteParameter.Optional } ); config.Routes.MapHttpRoute( name: "ActionApi", routeTemplate: "api/{controller}/{action}/{id}", defaults: new { id = RouteParameter.Optional } ); config.Filters.Add(new NHibernateActionFilter()); config.Formatters.Remove(config.Formatters.XmlFormatter); config.Formatters.JsonFormatter.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver(); config.EnsureInitialized(); }
public static void Register(HttpConfiguration config) { // Web API configuration and services // Web API routes config.MapHttpAttributeRoutes(); config.EnsureInitialized(); }
public void Start() { //Configure Container this.Container = new NetCellDependencies().Configure(); this.Container.RegisterInstance<IConnectionFactory>(new NMSConnectionFactory(MESSAGING_HOST)); //Configure Mapper var engine = new App_Start.NetCellMapping().Configure(); Container.RegisterInstance<AutoMapper.IMappingEngine>(engine); // Configure API this.ApiHost = WebApp.Start(BASE_HOST, (appBuilder) => { HttpConfiguration apiConfig = new HttpConfiguration(); apiConfig.DependencyResolver = new UnityResolver(this.Container); apiConfig.Services.Replace(typeof(IAssembliesResolver), new CustomAssemblyResolver()); apiConfig.MapHttpAttributeRoutes(); apiConfig.EnsureInitialized(); var desc = apiConfig.Services.GetApiExplorer().ApiDescriptions; appBuilder.UseWebApi(apiConfig); }); //Configure Quartz NameValueCollection config = (NameValueCollection)ConfigurationManager.GetSection("quartz"); this.SchedulerFactory = new StdSchedulerFactory(config); this.Scheduler = this.SchedulerFactory.GetScheduler(); this.Scheduler.JobFactory = new NetCellJobFactory(Container); this.Scheduler.Start(); }
public static void Register(HttpConfiguration config) { // Web API configuration and services config.Filters.Add(new ExceptionAttribute()); config.Filters.Add(new ValidationAttribute()); config.Formatters.JsonFormatter.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver(); // Web API routes config.MapHttpAttributeRoutes(); // all routes with ~/api should be resolved by web api config.Routes.MapHttpRoute( name: "DefaultApi", routeTemplate: "api/{controller}/{id}", defaults: new { id = RouteParameter.Optional } ); #if DEBUG config.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always; #else config.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Never; #endif var builder = new ContainerBuilder(); builder.RegisterApiControllers(Assembly.GetExecutingAssembly()); builder.RegisterWebApiFilterProvider(config); RegisterData(builder); RegisterServices(builder); var container = builder.Build(); config.DependencyResolver = new AutofacWebApiDependencyResolver(container); config.EnsureInitialized(); }
public static void ConfigureSecurityService(this IAppBuilder app) { Debug.Assert(app != null); //// build EDM model var builder = new ODataConventionModelBuilder() { Namespace = typeof(UsersController).Namespace, ContainerName = "DefaultContainer" }; builder.EnumType<Role>(); // TODO: how to mark the entity set as readonly var userEntityType = builder.EntitySet<User>("Users").EntityType; userEntityType.Ignore(c => c._Password); userEntityType.Ignore(c => c._IsLocked); userEntityType.Ignore(c => c._LockDateTimeUtc); var edmModel = builder.GetEdmModel(); //// configure web API var config = new HttpConfiguration() { IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always }; config.MessageHandlers.Add(new ETagMessageHandler()); config.MapODataServiceRoute("SecurityService", "securityservice", edmModel); config.Services.Replace(typeof(IHttpControllerSelector), new ClientHttpControllerSelector(config, typeof(SecurityServiceHelper))); config.EnsureInitialized(); app.UseWebApi(config); }
public static void Configure(IAppBuilder app) { if (app == null) throw new ArgumentNullException("app"); IContainer container = IocConfiguration.BuildContainer(actorSystemName: "Wakka"); app.UseAutofacMiddleware(container); HttpConfiguration webApiConfiguration = new HttpConfiguration { // Only used when mapping attribute routes. DependencyResolver = new AutofacWebApiDependencyResolver(container) }; app.UseAutofacWebApi(webApiConfiguration); // Share OWIN lifetime scope. webApiConfiguration.MapHttpAttributeRoutes(); webApiConfiguration.EnsureInitialized(); app.UseWebApi(webApiConfiguration); // Explicitly start the actor system when the OWIN app is started. ActorSystem actorSystem = container.ResolveNamed<ActorSystem>("Wakka"); // Try to gracefully shut down the actor system when the host is shutting down. AppProperties appProperties = new AppProperties(app.Properties); appProperties.OnAppDisposing.Register(() => { actorSystem.Shutdown(); actorSystem.AwaitTermination( timeout: TimeSpan.FromSeconds(5) ); }); }
public ImagesApiRouteTest() { //// Arrange testConfig = new HttpConfiguration(); WebApiConfig.Register(testConfig); testConfig.EnsureInitialized(); }
public static void UpdateConfiguration(HttpConfiguration configuration) { var controllers = new[] { typeof(FilesController), typeof(MetadataController) }; TestAssemblyResolver resolver = new TestAssemblyResolver(new TypesInjectionAssembly(controllers)); configuration.Services.Replace(typeof(IAssembliesResolver), resolver); configuration.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always; TimeZoneInfo timeZoneInfo = TimeZoneInfo.FindSystemTimeZoneById("Pacific Standard Time"); // -8:00 configuration.SetTimeZoneInfo(timeZoneInfo); configuration.Routes.Clear(); HttpServer httpServer = configuration.GetHttpServer(); configuration.MapODataServiceRoute( routeName: "convention", routePrefix: "convention", model: DateTimeEdmModel.GetConventionModel()); configuration.MapODataServiceRoute( routeName: "explicit", routePrefix: "explicit", model: DateTimeEdmModel.GetExplicitModel(), batchHandler: new DefaultODataBatchHandler(httpServer)); configuration.EnsureInitialized(); }
public void Match_UsesODataDefaultRoutingConventions_IfControllerFound(string expectedControllerName, string entitySetName) { // Arrange const string routeName = "api"; var request = new HttpRequestMessage(HttpMethod.Get, "http://any/" + entitySetName); var routeCollection = new HttpRouteCollection { { routeName, new HttpRoute() } }; var config = new HttpConfiguration(routeCollection); request.SetConfiguration(config); var pathHandler = new DefaultODataPathHandler(); var model = GetEdmModel(); config.MapHttpAttributeRoutes(); var conventions = config.CreateODataDomainRoutingConventions<NorthwindDomainController>(model); var constraint = new DefaultODataPathRouteConstraint(pathHandler, model, routeName, conventions); config.EnsureInitialized(); var values = new Dictionary<string, object> { { ODataRouteConstants.ODataPath, entitySetName }, }; // Act var matched = constraint.Match(request, route: null, parameterName: null, values: values, routeDirection: HttpRouteDirection.UriResolution); // Assert Assert.True(matched); Assert.Equal(expectedControllerName, values[ODataRouteConstants.Controller]); }
public static void RegisterAndSetResolver(HttpConfiguration httpConfiguration) { httpConfiguration.MapHttpAttributeRoutes(); var containerBuilder = new ContainerBuilder(); containerBuilder.RegisterApiControllers(Assembly.GetExecutingAssembly()); // Per Design Patterns: Elements of Reusable Object-Oriented Software - an abstract factory is often used as a singleton. containerBuilder.Register(x => new NHibernateConfiguration().Configure().BuildSessionFactory()).SingleInstance(); //containerBuilder.Register(x => new NHibernateDaoFactory()).As<IDaoFactory>().SingleInstance(); //containerBuilder.RegisterType<StreamusManagerFactory>().As<IManagerFactory>().SingleInstance(); // TODO: Still not really sure why I need InstancePerApiRequest here. Figure it out! Maybe if I removed the need to pass params into ManagerFactory it'll be OK containerBuilder.RegisterType<NHibernateDaoFactory>().As<IDaoFactory>().InstancePerApiRequest(); containerBuilder.RegisterType<StreamusManagerFactory>().As<IManagerFactory>().InstancePerApiRequest(); // Everything else wants an instance of Session per HTTP request, so indicate that: containerBuilder.Register(x => x.Resolve<ISessionFactory>().OpenSession()).InstancePerApiRequest(); containerBuilder.Register(x => LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType)).InstancePerApiRequest(); ILifetimeScope container = containerBuilder.Build(); httpConfiguration.DependencyResolver = new AutofacWebApiDependencyResolver(container); httpConfiguration.EnsureInitialized(); }
private static void ConfigureWebApi(HttpConfiguration config) { _container.RegisterWebApiControllers(config, _assemblies); config.MapHttpAttributeRoutes(); config.DependencyResolver = new SimpleInjectorWebApiDependencyResolver(_container); config.EnsureInitialized(); }
public void Configuration(IAppBuilder app) { var config = new HttpConfiguration(); config.MapHttpAttributeRoutes(); app.UseWebApi(config); ODataModelBuilder builder = new ODataConventionModelBuilder(); var products = builder.EntitySet<Product>("Products"); products.EntityType.Ignore(p => p.BillOfMaterials); products.EntityType.Ignore(p => p.BillOfMaterials_); products.EntityType.Ignore(p => p.ProductCostHistories); products.EntityType.Ignore(p => p.ProductDocuments); products.EntityType.Ignore(p => p.ProductInventories); products.EntityType.Ignore(p => p.ProductListPriceHistories); products.EntityType.Ignore(p => p.ProductModel); products.EntityType.Ignore(p => p.ProductProductPhotos); products.EntityType.Ignore(p => p.ProductReviews); products.EntityType.Ignore(p => p.ProductSubcategory); products.EntityType.Ignore(p => p.ProductVendors); products.EntityType.Ignore(p => p.PurchaseOrderDetails); products.EntityType.Ignore(p => p.ShoppingCartItems); products.EntityType.Ignore(p => p.SpecialOfferProducts); products.EntityType.Ignore(p => p.TransactionHistories); products.EntityType.Ignore(p => p.UnitMeasure); products.EntityType.Ignore(p => p.UnitMeasure_); products.EntityType.Ignore(p => p.WorkOrders); config.MapODataServiceRoute( routeName: "ODataRoute", routePrefix: null, model: builder.GetEdmModel()); config.EnsureInitialized(); }
public static void Register(HttpConfiguration config) { // Web API configuration and services // Web API routes //config.MapHttpAttributeRoutes(); //config.Routes.MapHttpRoute( // name: "DefaultApi", // routeTemplate: "api/{controller}/{id}", // defaults: new { id = RouteParameter.Optional } //); config.EnableCors(); var appXmlType = config.Formatters.XmlFormatter.SupportedMediaTypes.FirstOrDefault(t => t.MediaType == "application/xml"); config.Formatters.XmlFormatter.SupportedMediaTypes.Remove(appXmlType); ODataConventionModelBuilder builder = new ODataConventionModelBuilder(); builder.Namespace = "Demos"; builder.ContainerName = "DefaultContainer"; builder.EntitySet<Person>("Peoples"); config.MapODataServiceRoute( routeName: "ODataRoute", routePrefix: "odata", model: builder.GetEdmModel()); // config.MapODataServiceRoute("odata", "odata", GetEdmModel(), new DefaultODataBatchHandler(GlobalConfiguration.DefaultServer)); config.EnsureInitialized(); }
public static void Configure(HttpConfiguration config) { config.EnsureInitialized(); var apiExplorer = config.Services.GetApiExplorer(); var table = new LinkTable(); foreach (var apiDescription in apiExplorer.ApiDescriptions) { var descriptor = apiDescription.ActionDescriptor as ReflectedHttpActionDescriptor; if (descriptor != null) { var linksFromAttributes = descriptor.MethodInfo.GetCustomAttributes(typeof (LinksFromAttribute), false).Cast<LinksFromAttribute>().ToArray(); if (linksFromAttributes.Length > 0) { foreach (var attribute in linksFromAttributes) { var linkBuilder = LinkBuilder.Create(attribute, apiDescription); if (linkBuilder != null) { table.Add(linkBuilder); } } } } } var json = config.Formatters.JsonFormatter; json.SerializerSettings.ContractResolver = new LinkyContractResolver(table, json.SerializerSettings.ContractResolver); }
public static void Register(HttpConfiguration config) { config.Formatters.Remove(config.Formatters.FormUrlEncodedFormatter); config.Formatters.Remove(config.Formatters.XmlFormatter); var exceptionHandler = new WikiDownWebApiExceptionHandler(); config.Services.Replace(typeof(IExceptionHandler), exceptionHandler); var formatting = (DevEnvironment.IsDebug) ? Formatting.Indented : Formatting.None; var contractResolver = new CamelCasePropertyNamesContractResolver(); var dateTimeConverter = new IsoDateTimeConverter { DateTimeFormat = "yyyy'-'MM'-'dd'T'HH':'mm':'ss.fff" }; var jsonSerializerSettings = config.Formatters.JsonFormatter.SerializerSettings; jsonSerializerSettings.Formatting = formatting; jsonSerializerSettings.ContractResolver = contractResolver; jsonSerializerSettings.Converters.Add(dateTimeConverter); config.IncludeErrorDetailPolicy = DevEnvironment.IsDebug ? IncludeErrorDetailPolicy.Always : IncludeErrorDetailPolicy.Default; config.MapHttpAttributeRoutes(); config.EnsureInitialized(); }
public static void Register(HttpConfiguration config) { // Add OData formatters (application/atom+xml) var odataFormatters = ODataMediaTypeFormatters.Create( new CustomSerializerProvider(provider => new NuGetEntityTypeSerializer(provider)), new DefaultODataDeserializerProvider()); // Disable json and atomsvc - if these are ever needed, please reorder them // so they are at the end of the collection. // This will save you a few hours of debugging. var filteredFormatters = odataFormatters .Where(f => !f.SupportedMediaTypes.Any(m => m.MediaType.Equals("application/atomsvc+xml", StringComparison.OrdinalIgnoreCase) || m.MediaType.StartsWith("application/json", StringComparison.OrdinalIgnoreCase))) .ToList(); // Disable indenting foreach (var mediaTypeFormatter in filteredFormatters) { mediaTypeFormatter.MessageWriterSettings.Indent = false; } // Register formatters as the one and only formatters. // If WebAPI is ever enabled, ensure to update this to have JSON/XML support. config.Formatters.Clear(); config.Formatters.InsertRange(0, filteredFormatters); // Register feeds NuGetODataV1FeedConfig.Register(config); NuGetODataV2CuratedFeedConfig.Register(config); NuGetODataV2FeedConfig.Register(config); config.EnsureInitialized(); }
public static void Register(HttpConfiguration config) { //// Registering Attribute based routing for WebApi 2 config.MapHttpAttributeRoutes(); //// Mapping Telerik Reporting REST service Telerik.Reporting.Services.WebApi.ReportsControllerConfiguration.RegisterRoutes(config); config.Routes.MapHttpRoute( name: "DefaultApi", routeTemplate: "api/{controller}/{action}/{id}", defaults: new { id = RouteParameter.Optional }); // if attribute route is not getting used then you can use convention route as below to get employee languages //config.Routes.MapHttpRoute( // name: "EmployeeLanguagesRoute", // routeTemplate: "api/{controller}/{id}/Languages", // defaults: new { id = 0, controller = "Employees", action = "GetLanguages" }); config.Formatters.JsonFormatter.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver(); config.Formatters.JsonFormatter.SerializerSettings.ReferenceLoopHandling = ReferenceLoopHandling.Ignore; // Remove default XML handler var matches = config.Formatters .Where(f => f.SupportedMediaTypes.Any(m => m.MediaType.ToString() == "application/xml" || m.MediaType.ToString() == "text/xml")) .ToList(); foreach (var match in matches) { config.Formatters.Remove(match); } config.EnsureInitialized(); }
public static HttpConfiguration ImportConfiguration(string assemblyPath) { FileInfo peInfo = new FileInfo(assemblyPath); assemblyPath = peInfo.FullName; var assembly = Assembly.LoadFrom(assemblyPath); string originalDirectory = Environment.CurrentDirectory; Environment.CurrentDirectory = Path.GetDirectoryName(assemblyPath); Type webApiConfigType = assembly.GetTypes().FirstOrDefault(t => t.Name == ConfigClassName); if (webApiConfigType == null) { throw new InvalidOperationException(string.Format("Cannot find the configuration class: '{0}' in {1}", ConfigClassName, assemblyPath)); } MethodInfo registerConfigMethod = webApiConfigType.GetMethod(ConfigurationMethodName, BindingFlags.Static | BindingFlags.Public); if (registerConfigMethod == null) { throw new InvalidOperationException(string.Format("Cannot find the static configuration method: '{0}()' in {1}", ConfigurationMethodName, ConfigClassName)); } // Action<HttpConfiguration> registerConfig = Delegate.CreateDelegate(typeof(Action<HttpConfiguration>), registerConfigMethod) as Action<HttpConfiguration>; HttpConfiguration config = new HttpConfiguration(); registerConfigMethod.Invoke(new object(),new object[]{ config}); // registerConfig(config); ImportHelpPageConfiguration(assembly, config); Environment.CurrentDirectory = originalDirectory; config.EnsureInitialized(); return config; }
private HttpConfiguration ConfigureWebApi() { var config = new HttpConfiguration(); // Attribute routing. config.MapHttpAttributeRoutes(); config.MapODataServiceRoute("odata","odata", GetEdmModel(), null); //config.MapODataServiceRoute("odata", null, GetEdmModel(), new DefaultODataBatchHandler(GlobalConfiguration.DefaultServer)); config.EnsureInitialized(); //All routing uses attributes to be explicit //config.Routes.MapHttpRoute( // "aalogAPIV1", // "api/aalog/V1/", // new { controller = "aaLog" }); //config.Routes.MapHttpRoute( // "DefaultApi", // "api/{controller}/{id}", // new { id = RouteParameter.Optional }); //var appXmlType = config.Formatters.XmlFormatter.SupportedMediaTypes.FirstOrDefault(t => t.MediaType == "application/xml"); //config.Formatters.XmlFormatter.SupportedMediaTypes.Remove(appXmlType); return config; }
public static void UpdateConfiguration(HttpConfiguration configuration) { var controllers = new[] { typeof(ForeignKeyCustomersController), typeof(ForeignKeyOrdersController), typeof(ForeignKeyCustomersNoCascadeController), typeof(ForeignKeyOrdersNoCascadeController), typeof(MetadataController) }; TestAssemblyResolver resolver = new TestAssemblyResolver(new TypesInjectionAssembly(controllers)); configuration.Services.Replace(typeof(IAssembliesResolver), resolver); configuration.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always; configuration.Routes.Clear(); configuration.GetHttpServer(); configuration.MapODataServiceRoute(routeName: "explicit", routePrefix: "explicit", model: ForeignKeyEdmModel.GetExplicitModel(foreignKey: true)); configuration.MapODataServiceRoute(routeName: "convention", routePrefix: "convention", model: ForeignKeyEdmModel.GetConventionModel()); configuration.MapODataServiceRoute(routeName: "noncascade", routePrefix: "noncascade", model: ForeignKeyEdmModel.GetExplicitModel(foreignKey: false)); configuration.EnsureInitialized(); }
private static HttpConfiguration GetNewHttpConfig() { HttpConfiguration config = new System.Web.Http.HttpConfiguration(); config.EnableDependencyInjection(); //1 config.EnsureInitialized(); //2 return(config); }
protected void Application_Start() { AreaRegistration.RegisterAllAreas(); GlobalConfiguration.Configure(WebApiConfig.Register); FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters); RouteConfig.RegisterRoutes(RouteTable.Routes); BundleConfig.RegisterBundles(BundleTable.Bundles); UnityConfig.RegisterComponents(); System.Web.Http.HttpConfiguration config = System.Web.Http.GlobalConfiguration.Configuration; config.EnsureInitialized(); }
public static void RegisterApi(System.Web.Http.HttpConfiguration config) { config.MapHttpAttributeRoutes(); // Adds support for the webapi 1 style methods, e.g. /api/Users/ config.Routes.MapHttpRoute( name: "DefaultApi", routeTemplate: "api/{controller}/{id}", defaults: new { id = RouteParameter.Optional } ); config.EnsureInitialized(); }
// Test Hook for inspecting the route table generated by MapHttpAttributeRoutes. // MapHttpAttributeRoutes doesn't return the route collection because it's an implementation detail // that attr routes even generate a meaningful route collection. // Public APIs can get similar functionality by querying the IHttpRoute for IEnumerable<IHttpRoute>. internal static HttpRouteCollection GetAttributeRoutes(this HttpConfiguration configuration) { configuration.EnsureInitialized(); HttpRouteCollection routes = configuration.Routes; foreach (IHttpRoute route in routes) { var attrRoute = route as RouteCollectionRoute; if (attrRoute != null) { return(attrRoute.SubRoutes); } } return(null); }
// Test Hook for inspecting the route table generated by MapHttpAttributeRoutes. // MapHttpAttributeRoutes doesn't return the route collection because it's an implementation detail // that attr routes even generate a meaningful route collection. // Public APIs can get similar functionality by querying the IHttpRoute for IReadOnlyCollection<IHttpRoute>. internal static IReadOnlyCollection <IHttpRoute> GetAttributeRoutes( this HttpConfiguration configuration ) { configuration.EnsureInitialized(); HttpRouteCollection routes = configuration.Routes; foreach (IHttpRoute route in routes) { var attrRoute = route as IReadOnlyCollection <IHttpRoute>; if (attrRoute != null) { return(attrRoute); } } return(null); }
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(); }