[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);
        }
Esempio n. 2
0
        /// <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();
        }
Esempio n. 3
0
        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
            };
        }
Esempio n. 4
0
        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();
        }
Esempio n. 5
0
        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);
        }
Esempio n. 6
0
        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();
        }
Esempio n. 7
0
        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>());
        }
Esempio n. 8
0
        // 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();
        }
Esempio n. 10
0
        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();

        }
Esempio n. 11
0
        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();
		}
Esempio n. 13
0
        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();
        }
Esempio n. 14
0
        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();
        }
Esempio n. 15
0
        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);
        }
Esempio n. 16
0
        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();
 }
Esempio n. 18
0
        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]);
        }
Esempio n. 20
0
        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();
 }
Esempio n. 22
0
        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();
        }
Esempio n. 23
0
        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();
        }
Esempio n. 24
0
        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);
        }
Esempio n. 25
0
        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();
        }
Esempio n. 27
0
        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;
        }
Esempio n. 29
0
        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;
        }
Esempio n. 30
0
        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();
 }
Esempio n. 33
0
        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();
        }
Esempio n. 34
0
        // 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);
        }
Esempio n. 35
0
        // 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);
        }
Esempio n. 36
0
        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();
        }