private static void SetupRouteConstraints(HttpConfiguration config) { var constraintResolver = new DefaultInlineConstraintResolver(); constraintResolver.ConstraintMap.Add("identifier", typeof(IdentifierRouteConstraint)); constraintResolver.ConstraintMap.Add("identifiers", typeof(IdentifiersRouteConstraint)); constraintResolver.ConstraintMap.Add("objectid", typeof(ObjectIdRouteConstraint)); constraintResolver.ConstraintMap.Add("objectids", typeof(ObjectIdsRouteConstraint)); constraintResolver.ConstraintMap.Add("token", typeof(TokenRouteConstraint)); constraintResolver.ConstraintMap.Add("tokens", typeof(TokensRouteConstraint)); config.MapHttpAttributeRoutes(constraintResolver); }
public static IAppBuilder UseWebServer(this IAppBuilder builder, HttpConfiguration config) { if (config == null) { throw new ArgumentNullException("config"); } var httpServer = new HttpServer(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 DelegatingHandler //config.MessageHandlers.Add(new MonitorLog.MonitorLogHandler()); // Web API routes var constraintResolver = new DefaultInlineConstraintResolver(); config.Routes.MapHttpBatchRoute( routeName: "batch", routeTemplate: "api/batch", batchHandler: new DefaultHttpBatchHandler(httpServer) ); config.MapHttpAttributeRoutes(constraintResolver); //config.MessageHandlers.Add(new CultureAppLangHandler()); config.Routes.MapHttpRoute( name: "DefaultApi", routeTemplate: "api/{controller}/{id}", defaults: new { id = RouteParameter.Optional } ); // Global unhandled exception logger config.Services.Add(typeof(IExceptionLogger), new CommonLoggingExceptionLogger()); // Remove XML formatter by default. var formatters = config.Formatters; formatters.Remove(formatters.XmlFormatter); // Set default Json formatting. var jsonSettings = formatters.JsonFormatter.SerializerSettings; jsonSettings.Formatting = Formatting.Indented; jsonSettings.NullValueHandling = NullValueHandling.Ignore; jsonSettings.ContractResolver = new CamelCasePropertyNamesContractResolver(); builder.UseWebApi(httpServer); return(builder); }
public static void Register(HttpConfiguration config) { // Web API configuration and services // Web API routes var cors = new EnableCorsAttribute("*", "*", "*"); config.EnableCors(cors); var constraintResolver = new DefaultInlineConstraintResolver() { ConstraintMap = { ["apiVersion"] = typeof(ApiVersionRouteConstraint) } }; //// Web API routes config.AddApiVersioning(options => { options.ReportApiVersions = true; options.AssumeDefaultVersionWhenUnspecified = true; // options.ApiVersionReader = new HeaderApiVersionReader("apiVersion"); options.ApiVersionReader = new UrlSegmentApiVersionReader(); // options.DefaultApiVersion = new Microsoft.Web.Http.ApiVersion(1, 0); options.ErrorResponses = new VersionErrorResponseProvider(); //options.Conventions.Controller<WritersControllerV2>() // .HasApiVersion(new ApiVersion(2, 0)); /*Spicify the versioning in single place*/ } ); config.MapHttpAttributeRoutes(constraintResolver); config.Routes.MapHttpRoute( name: "DefaultApi", routeTemplate: "api/v{apiversion}/{controller}/{id}", defaults: new { id = RouteParameter.Optional }, constraints: new { apiVersion = new ApiVersionRouteConstraint() } ); SwaggerConfig.Register(config); }
public static void Register(HttpConfiguration config) { config.AddApiVersioning(); var constraintResolver = new DefaultInlineConstraintResolver() { ConstraintMap = { ["apiVersion"] = typeof(ApiVersionRouteConstraint) } }; config.MapHttpAttributeRoutes(constraintResolver); var clientService = config.DependencyResolver.GetService(typeof(ICompanyClientsService)) as ICompanyClientsService; config.Filters.Add(new Security.ApiAuthorizationAttribute(clientService)); }
public static void Register(HttpConfiguration config) { var constraintResolver = new DefaultInlineConstraintResolver() { ConstraintMap = { ["apiVersion"] = typeof(ApiVersionRouteConstraint) } }; config.MapHttpAttributeRoutes(constraintResolver); config.AddApiVersioning(); }
public void ResolveConstraint_LengthRangeConstraint() { var constraint = new DefaultInlineConstraintResolver().ResolveConstraint( "length(5, 10)" ); LengthRouteConstraint lengthConstraint = Assert.IsType <LengthRouteConstraint>( constraint ); Assert.Equal(5, lengthConstraint.MinLength); Assert.Equal(10, lengthConstraint.MaxLength); }
/// <summary> /// map api version routes /// </summary> /// <param name="config"><see cref="HttpConfiguration"/>http server's config</param> public static void MapApiVersionRoutes(this HttpConfiguration config) { // we only need to change the default constraint resolver for services that want urls with versioning like: ~/v{version}/{controller} var constraintResolver = new DefaultInlineConstraintResolver() { ConstraintMap = { ["apiVersion"] = typeof(ApiVersionRouteConstraint) } }; config.MapHttpAttributeRoutes(constraintResolver); // reporting api versions will return the headers "api-supported-versions" and "api-deprecated-versions" config.AddApiVersioning(p => p.ReportApiVersions = true); }
public static void Register(HttpConfiguration config) { var constraintResolver = new DefaultInlineConstraintResolver() { ConstraintMap = { ["apiVersion"] = typeof(ApiVersionRouteConstraint) } }; config.AddApiVersioning(o => o.ReportApiVersions = true); config.MapHttpAttributeRoutes(constraintResolver); var corsAttr = new EnableCorsAttribute("*", "*", "*"); config.EnableCors(corsAttr); }
public static void Register(HttpConfiguration config) { var constraintsResolver = new DefaultInlineConstraintResolver(); constraintsResolver.ConstraintMap.Add("Email", typeof(EmailHttpRouteConstraint)); config.MapHttpAttributeRoutes(constraintsResolver); config.Routes.MapHttpRoute( name: "DefaultApi", routeTemplate: "api/{controller}/{id}", defaults: new { id = RouteParameter.Optional } ); }
public Metadata Generate() { var httpConfiguration = new HttpConfiguration(); var constraintResolver = new DefaultInlineConstraintResolver(); constraintResolver.ConstraintMap.Add("idorcurrent", typeof(IdOrCurrentConstraint)); constraintResolver.ConstraintMap.Add("deviceGuid", typeof(DeviceGuidConstraint)); httpConfiguration.MapHttpAttributeRoutes(constraintResolver); httpConfiguration.EnsureInitialized(); var apiExplorer = httpConfiguration.Services.GetApiExplorer(); var metadata = new Metadata { Resources = apiExplorer.ApiDescriptions .OrderBy(d => d.ActionDescriptor.ControllerDescriptor.ControllerName) .Select(d => new { Resource = GetResourceInfo(d), Method = d }) .Where(d => d.Resource != null) .GroupBy(d => d.Resource, d => d.Method) .Select(g => new { Resource = g.Key, Methods = g.GroupBy(m => GetMethodName((ReflectedHttpActionDescriptor)m.ActionDescriptor)).Select(m => m.First()).ToList(), }) .Select(cd => new MetadataResource { Name = cd.Resource.Name, Documentation = cd.Resource.Description, Properties = cd.Resource.Type == null ? null : _helper.GetTypeParameters(cd.Resource.Type), Methods = cd.Methods .Where(m => GetMethodName((ReflectedHttpActionDescriptor)m.ActionDescriptor) != null) .Select(m => new MetadataMethod { Name = GetMethodName((ReflectedHttpActionDescriptor)m.ActionDescriptor), Documentation = GetMethodDocumentation((ReflectedHttpActionDescriptor)m.ActionDescriptor), Verb = m.HttpMethod.Method, Uri = "/" + m.RelativePath, UriParameters = GetUrlParameters(m), Authorization = GetAuthorization(m.ActionDescriptor), RequestDocumentation = GetRequestDocumentation((ReflectedHttpActionDescriptor)m.ActionDescriptor), RequestParameters = GetRequestParameters((ReflectedHttpActionDescriptor)m.ActionDescriptor), ResponseDocumentation = GetResponseDocumentation((ReflectedHttpActionDescriptor)m.ActionDescriptor), ResponseParameters = GetResponseParameters((ReflectedHttpActionDescriptor)m.ActionDescriptor), }).ToArray(), }).ToArray(), }; return(metadata); }
public static void Register(HttpConfiguration config) { //config.EnableCors(new EnableCorsAttribute("*", headers: "*", methods: "*")); // Web API configuration and services var constraintResolver = new DefaultInlineConstraintResolver(); constraintResolver.ConstraintMap.Add("fullname", typeof(FullnameConstraint)); // Web API routes config.MapHttpAttributeRoutes(constraintResolver); Routing_Account(config); }
public virtual void Configure(IAppBuilder owinApp) { if (owinApp == null) { throw new ArgumentNullException(nameof(owinApp)); } _webApiConfig = new HttpConfiguration(); _webApiConfig.SuppressHostPrincipal(); _webApiConfig.IncludeErrorDetailPolicy = AppEnvironment.DebugMode ? IncludeErrorDetailPolicy.LocalOnly : IncludeErrorDetailPolicy.Never; _webApiConfig.DependencyResolver = WebApiDependencyResolver; _webApiConfig.Formatters.JsonFormatter.SerializerSettings.ContractResolver = DefaultJsonContentFormatter.SerializeSettings().ContractResolver; WebApiConfigurationCustomizers.ToList() .ForEach(webApiConfigurationCustomizer => { webApiConfigurationCustomizer.CustomizeWebApiConfiguration(_webApiConfig); }); _server = new HttpServer(_webApiConfig); DefaultInlineConstraintResolver constraintResolver = new DefaultInlineConstraintResolver() { ConstraintMap = { ["apiVersion"] = typeof(ApiVersionRouteConstraint) } }; _webApiConfig.AddApiVersioning(apiVerOptions => { apiVerOptions.ReportApiVersions = true; apiVerOptions.AssumeDefaultVersionWhenUnspecified = true; }); _webApiConfig.MapHttpAttributeRoutes(constraintResolver); if (_webApiConfig.Properties.TryGetValue("MultiVersionSwaggerConfiguration", out object actionObj)) { ((Action)actionObj).Invoke(); } _webApiConfig.Routes.MapHttpRoute(name: "default", routeTemplate: "{controller}/{action}", defaults: new { action = RouteParameter.Optional }); owinApp.UseAutofacWebApi(_webApiConfig); WebApiOwinPipelineInjector.UseWebApi(owinApp, _server, _webApiConfig); _webApiConfig.EnsureInitialized(); }
public static void RegisterRoutes(RouteCollection routes) { routes.IgnoreRoute("{resource}.axd/{*pathInfo}"); var constraintsResolver = new DefaultInlineConstraintResolver(); routes.MapMvcAttributeRoutes(constraintsResolver); routes.MapRoute( name: "Default", url: "{controller}/{action}/{id}", defaults: new { controller = "App", action = "Index", id = UrlParameter.Optional } ); }
protected BasicAcceptanceTest() { var constraintResolver = new DefaultInlineConstraintResolver() { ConstraintMap = { ["apiVersion"] = typeof(ApiVersionRouteConstraint) } }; FilteredControllerTypes.Add(typeof(ValuesController)); FilteredControllerTypes.Add(typeof(Values2Controller)); FilteredControllerTypes.Add(typeof(HelloWorldController)); Configuration.AddApiVersioning(options => options.ReportApiVersions = true); Configuration.MapHttpAttributeRoutes(constraintResolver); Configuration.EnsureInitialized(); }
private static decimal Compute(string template) { var options = new Mock <IOptions <RouteOptions> >(); options.SetupGet(o => o.Options).Returns(new RouteOptions()); var constraintResolver = new DefaultInlineConstraintResolver( Mock.Of <IServiceProvider>(), options.Object); var parsed = TemplateParser.Parse(template, constraintResolver); return(AttributeRoutePrecedence.Compute(parsed)); }
public static void Register(HttpConfiguration config) { var constraintsResolver = new DefaultInlineConstraintResolver(); constraintsResolver.ConstraintMap.Add("apiVersionConstraint", typeof(ApiVersionConstraint)); config.MapHttpAttributeRoutes(constraintsResolver); config.Services.Replace(typeof(IHttpControllerSelector), new NamespaceHttpControllerSelector(config)); //config.EnableSystemDiagnosticsTracing(); // replaced by custom writer config.Services.Replace(typeof(ITraceWriter), new SimpleTraceWriter(WebContainerManager.Get <ILogManager>())); config.Services.Add(typeof(IExceptionLogger), new SimpleExceptionLogger(WebContainerManager.Get <ILogManager>())); config.Services.Replace(typeof(IExceptionHandler), new GlobalExceptionHandler()); config.EnableCors(); }
public void ResolveConstraint_CustomConstraintThatDoesNotImplementouteConstraintInterfact_Throws() { var resolver = new DefaultInlineConstraintResolver(); resolver.ConstraintMap.Add("custom", typeof(string)); Assert.Throws <InvalidOperationException>( () => resolver.ResolveConstraint("custom"), #if ASPNETWEBAPI "The constraint type 'String' which is mapped to constraint key 'custom' must implement the IHttpRouteConstraint interface."); #else "The constraint type 'String' which is mapped to constraint key 'custom' must implement the IRouteConstraint interface."); #endif }
public static void Register(HttpConfiguration config) { config.EnableCors(); // Web API routes var versionConstraintResolver = new DefaultInlineConstraintResolver { ConstraintMap = { ["apiVersion"] = typeof(ApiVersionRouteConstraint) } }; config.MapHttpAttributeRoutes(versionConstraintResolver); config.Routes.MapHttpRoute(DefaultApi, "api/v{version:apiVersion}/{controller}/{id}", new { id = RouteParameter.Optional }); }
public static void Register(HttpConfiguration configuration) { configuration.Formatters.Remove(configuration.Formatters.XmlFormatter); configuration.Formatters.Add(new ProductCsvFormatter()); var resolver = new DefaultInlineConstraintResolver(); resolver.ConstraintMap.Add("nonzero", typeof(NonZeroConstraint)); configuration.MapHttpAttributeRoutes(resolver); configuration.MessageHandlers.Add(new AuthorizationHandler()); //on utilise plutôt les autorisations par l'attribut AuthorizeFilterAttribute dans le controleur }
public MonitoringTestExecutionForAttributedRoutedTests() { configuration = new HttpConfiguration(); var constraintResolver = new DefaultInlineConstraintResolver(); constraintResolver.ConstraintMap.Add("among", typeof(AmongConstraint)); configuration.MapHttpAttributeRoutes(constraintResolver); configuration.MapTestRoutes(); configuration.EnsureInitialized(); var server = new HttpServer(configuration); apiClient = new HttpClient(server); }
private IInlineConstraintResolver ConfigureApiVersion(HttpConfiguration configuration) { var constraintResolver = new DefaultInlineConstraintResolver() { ConstraintMap = { ["apiVersion"] = typeof(ApiVersionRouteConstraint) } }; configuration.AddApiVersioning(o => o.ReportApiVersions = true); return(constraintResolver); }
public static void Register(HttpConfiguration config) { // Web API configuration and services AutofacConfig.Register(); config.AddApiVersioning(cfg => { cfg.DefaultApiVersion = new ApiVersion(1, 1); cfg.AssumeDefaultVersionWhenUnspecified = true; cfg.ReportApiVersions = true; cfg.ApiVersionReader = new UrlSegmentApiVersionReader(); /* * cfg.ApiVersionReader = ApiVersionReader.Combine( * new HeaderApiVersionReader("X-Version"), * new QueryStringApiVersionReader("ver") * ); */ cfg.Conventions.Controller <TalksController>() .HasApiVersion(1, 0) .HasApiVersion(1, 1) .Action(m => m.Get(default(string), default(int), default(bool))) .MapToApiVersion(2, 0); }); config.Formatters.JsonFormatter.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver(); var constraintResolver = new DefaultInlineConstraintResolver() { ConstraintMap = { ["apiVersion"] = typeof(ApiVersionRouteConstraint) } }; // Web API routes config.MapHttpAttributeRoutes(constraintResolver); /* * config.Routes.MapHttpRoute( * name: "DefaultApi", * routeTemplate: "api/{controller}/{id}", * defaults: new { id = RouteParameter.Optional } * ); */ }
public static void RegisterRoutes(RouteCollection routes) { routes.IgnoreRoute("{resource}.axd/{*pathInfo}"); var constraintsResolver = new DefaultInlineConstraintResolver(); constraintsResolver.ConstraintMap.Add("Enum", typeof(EnumRouteConstraint)); routes.MapMvcAttributeRoutes(constraintsResolver); //routes.MapRoute( // name: "", // url: "docs/expression/{name}", // defaults: new { controller = "Docs", action = "Expression" } // ); //routes.MapRoute( // name: "", // url: "Classes", // defaults: new { controller = "Class", action = "Index" } // ); //routes.MapRoute( // name: "", // url: "Classes/{className}/{methodName}/{framework}", // defaults: new { controller = "Class", action = "ClassMethod", methodName = UrlParameter.Optional, framework = Frameworks.NotSet } // ); //routes.MapRoute( // name: "", // url: "Expressions", // defaults: new { controller = "Expression", action = "Index" } // ); //routes.MapRoute( // name: "", // url: "Expressions/{expressionName}", // defaults: new { controller = "Expression", action = "Expression" } // ); //routes.MapRoute( // name: "Default", // url: "{action}/{id}", // defaults: new { controller = "Home", action = "Index", id = UrlParameter.Optional } // ); }
public void Configuration(IAppBuilder builder) { // we only need to change the default constraint resolver for services that want urls with versioning like: ~/v{version}/{controller} var constraintResolver = new DefaultInlineConstraintResolver() { ConstraintMap = { ["apiVersion"] = typeof(ApiVersionRouteConstraint) } }; var configuration = new HttpConfiguration(); var httpServer = new HttpServer(configuration); // reporting api versions will return the headers "api-supported-versions" and "api-deprecated-versions" configuration.AddApiVersioning(options => options.ReportApiVersions = true); configuration.MapHttpAttributeRoutes(constraintResolver); builder.UseWebApi(httpServer); }
private static decimal Compute(string template) { DefaultInlineConstraintResolver resolver = new DefaultInlineConstraintResolver(); #if ASPNETWEBAPI HttpRouteValueDictionary defaults = new HttpRouteValueDictionary(); HttpRouteValueDictionary constraints = new HttpRouteValueDictionary(); #else RouteValueDictionary defaults = new RouteValueDictionary(); RouteValueDictionary constraints = new RouteValueDictionary(); #endif string standardRouteTemplate = InlineRouteTemplateParser.ParseRouteTemplate(template, defaults, constraints, new DefaultInlineConstraintResolver()); var parsedRoute = RouteParser.Parse(standardRouteTemplate); return RoutePrecedence.Compute(parsedRoute, constraints); }
// Ref: http://www.asp.net/web-api/overview/web-api-routing-and-actions/attribute-routing-in-web-api-2 public static void Register(HttpConfiguration config) { var resolver = new DefaultInlineConstraintResolver(); config.MapHttpAttributeRoutes(resolver); config.Formatters.JsonFormatter .SupportedMediaTypes.Add(new MediaTypeHeaderValue("text/html")); //config.MapHttpAttributeRoutes(); //config.Routes.MapHttpRoute( // name: "DefaultApi", // routeTemplate: "api/{controller}/{id}", // defaults: new {id = RouteParameter.Optional} // ); }
public static void Register(HttpConfiguration config) { // Web API Contraint var constraintResolver = new DefaultInlineConstraintResolver(); constraintResolver.ConstraintMap.Add("lastletter", typeof(LastLetter)); // istenilen kadar constraint eklenebilir //TODO: Constraint kullanımı *Route(api/{id:lastleter}) ':' ile istenilen kadar constraint eklenebilir contraints önüne eklenen '?' karakteri optional olabilri ve constraints default parametrede alabilir lastlatter=abc gibi constraints flase döner ise olursa 404 dönüyor config.MapHttpAttributeRoutes(constraintResolver); config.Routes.MapHttpRoute( name: "DefaultApi", routeTemplate: "api/{controller}/{action}/{id}", defaults: new { id = RouteParameter.Optional } ); }
public static void Register(HttpConfiguration config) { // Web API configuration and services var constraintResolver = new DefaultInlineConstraintResolver(); constraintResolver.ConstraintMap.Add("lastletter", typeof(LastLetter)); // Web API routes config.MapHttpAttributeRoutes(constraintResolver); config.Routes.MapHttpRoute( name: "DefaultApi", routeTemplate: "api/{controller}/{id}", defaults: new { id = RouteParameter.Optional } ); }
public static void RegisterRoutes(RouteCollection routes) { routes.IgnoreRoute("{resource}.axd/{*pathInfo}"); var constraintResolver = new DefaultInlineConstraintResolver(); constraintResolver.ConstraintMap.Add("enum", typeof(EnumConstraint)); routes.MapMvcAttributeRoutes(constraintResolver); routes.MapRoute( name: "Default", url: "{controller}/{action}", defaults: new { controller = "Home", action = "Index" } ); }
public static void Register(HttpConfiguration config) { // Web API configuration and services //Register the custom constraint in default resolver. var constraintProvider = new DefaultInlineConstraintResolver(); constraintProvider.ConstraintMap.Add("validateId", typeof(IdValueConstraint)); // Web API routes config.MapHttpAttributeRoutes(constraintProvider); // RouteTemplate config.Routes.MapHttpRoute( name: "ActionApi", routeTemplate: "api/{controller}/{action}/{id}", defaults: new { id = RouteParameter.Optional } ); config.Routes.MapHttpRoute( name: "DefaultApi", routeTemplate: "api/{controller}/{id}", //handler: new MyCustomMessageHandler(), //constraints: new { }, defaults: new { id = RouteParameter.Optional } ); config.Services.Replace(typeof(IHttpControllerSelector), new CustomControllerSelectionHandler(config)); //Formating and casing config.Formatters.JsonFormatter.SerializerSettings.Formatting = Newtonsoft.Json.Formatting.Indented; //Adding CamelCasing as a default serialization Setting. config.Formatters.JsonFormatter.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver(); //To Remove any existing formatter //config.Formatters.Remove(config.Formatters.JsonFormatter); //To Add custom Formatter config.Formatters.Add(new CustomJsonFormatter()); //To support any new media type. //config.Formatters.JsonFormatter.SupportedMediaTypes.Add(new System.Net.Http.Headers.MediaTypeHeaderValue("text/html")); EnableCorsAttribute enableCorsAttribute = new EnableCorsAttribute("*", "*", "*"); config.EnableCors(enableCorsAttribute); // config.MessageHandlers.Add(new AuthtenticationHandler()); }
private void ConfigureWebApi(IAppBuilder app, IResolutionRoot resolutionRoot) { var config = new HttpConfiguration(); var kernel = new ChildKernel(resolutionRoot); kernel.Rebind <HttpConfiguration>().ToConstant(config); kernel.Bind <DefaultModelValidatorProviders>().ToConstant(new DefaultModelValidatorProviders(config.Services.GetServices(typeof(ModelValidatorProvider)).Cast <ModelValidatorProvider>())); kernel.Bind <DefaultFilterProviders>().ToConstant(new DefaultFilterProviders(config.Services.GetServices(typeof(IFilterProvider)).Cast <IFilterProvider>())); var dependencyResolver = new NinjectDependencyResolver(kernel); config.DependencyResolver = dependencyResolver; config.Formatters.JsonFormatter.SerializerSettings.Converters.Add(new StringEnumConverter()); config.Formatters.JsonFormatter.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver(); config.Formatters.Remove(config.Formatters.XmlFormatter); config.EnableCors(new EnableCorsAttribute("http://localhost:8081", "*", "*", "Cookie") { SupportsCredentials = true }); var constraintResolver = new DefaultInlineConstraintResolver(); constraintResolver.ConstraintMap.Add("situation", typeof(SituationConstraint)); config.MapHttpAttributeRoutes(constraintResolver); config.Routes.MapHttpRoute("Default", "{controller}/{id}"); config.EnableSwagger(c => { var baseDirectory = AppDomain.CurrentDomain.BaseDirectory; var commentsFileName = Assembly.GetExecutingAssembly().GetName().Name + ".XML"; var commentsFile = Path.Combine(baseDirectory, "bin", commentsFileName); c.IncludeXmlComments(commentsFile); c.RootUrl(h => $"{h.RequestUri.Scheme}://{h.RequestUri.Host}:{h.RequestUri.Port}/api"); c.SingleApiVersion("v1", "Michael's Place SPA API."); }) .EnableSwaggerUi(); app.Map("/api", webApi => { webApi.UseWebApi(config); }); }
/// <summary> /// Registers routes for MVC. /// </summary> public static void RegisterMvcRoutes(RouteCollection routes) { routes.IgnoreRoute("{resource}.axd/{*pathInfo}"); DefaultInlineConstraintResolver constraintsResolver = new DefaultInlineConstraintResolver(); Dictionary<string, Type> foundConstraintTypes = GetConstraintTypes(); foreach (string name in foundConstraintTypes.Keys) constraintsResolver.ConstraintMap.Add(name, foundConstraintTypes[name]); routes.MapMvcAttributeRoutes(constraintsResolver); routes.MapRoute( name: "Default", url: "{controller}/{action}/{id}", defaults: new { controller = "Visitor", action = "Welcome", id = UrlParameter.Optional } ); }
public void ResolveConstraint_BoolConstraint() { var constraint = new DefaultInlineConstraintResolver().ResolveConstraint("bool"); Assert.IsType<BoolRouteConstraint>(constraint); }
public void ResolveConstraint_LongRangeConstraint() { var constraint = new DefaultInlineConstraintResolver().ResolveConstraint("long"); Assert.IsType<LongRouteConstraint>(constraint); }
public void ResolveConstraint_MaxLengthConstraint() { var constraint = new DefaultInlineConstraintResolver().ResolveConstraint("maxlength(10)"); Assert.IsType<MaxLengthRouteConstraint>(constraint); Assert.Equal(10, ((MaxLengthRouteConstraint)constraint).MaxLength); }
public void ResolveConstraint_GuidConstraint() { var constraint = new DefaultInlineConstraintResolver().ResolveConstraint("guid"); Assert.IsType<GuidRouteConstraint>(constraint); }
public void ResolveConstraint_IntConstraint() { var constraint = new DefaultInlineConstraintResolver().ResolveConstraint("int"); Assert.IsType<IntRouteConstraint>(constraint); }
public void ResolveConstraint_MinLengthConstraint() { var constraint = new DefaultInlineConstraintResolver().ResolveConstraint("minlength(3)"); Assert.IsType<MinLengthRouteConstraint>(constraint); Assert.Equal(3, ((MinLengthRouteConstraint)constraint).MinLength); }
public void ResolveConstraint_DoubleConstraint() { var constraint = new DefaultInlineConstraintResolver().ResolveConstraint("double"); Assert.IsType<DoubleRouteConstraint>(constraint); }
public void ResolveConstraint_RangeConstraint() { var constraint = new DefaultInlineConstraintResolver().ResolveConstraint("range(5, 10)"); Assert.IsType<RangeRouteConstraint>(constraint); RangeRouteConstraint rangeConstraint = (RangeRouteConstraint)constraint; Assert.Equal(5, rangeConstraint.Min); Assert.Equal(10, rangeConstraint.Max); }
public void ResolveConstraint_RegexConstraint() { var constraint = new DefaultInlineConstraintResolver().ResolveConstraint("regex(abc,defg)"); Assert.IsType<RegexRouteConstraint>(constraint); RegexRouteConstraint regexConstraint = (RegexRouteConstraint)constraint; Assert.Equal("abc,defg", regexConstraint.Pattern); }
public void ResolveConstraint_CustomConstraintThatDoesNotImplementouteConstraintInterfact_Throws() { var resolver = new DefaultInlineConstraintResolver(); resolver.ConstraintMap.Add("custom", typeof(string)); Assert.Throws<InvalidOperationException>( () => resolver.ResolveConstraint("custom"), #if ASPNETWEBAPI "The constraint type 'String' which is mapped to constraint key 'custom' must implement the IHttpRouteConstraint interface."); #else "The constraint type 'String' which is mapped to constraint key 'custom' must implement the IRouteConstraint interface."); #endif }
public void ResolveConstraint_SupportsCustomConstraints() { var resolver = new DefaultInlineConstraintResolver(); resolver.ConstraintMap.Add("custom", typeof(IntRouteConstraint)); var constraint = resolver.ResolveConstraint("custom"); Assert.IsType<IntRouteConstraint>(constraint); }
public void ResolveConstraint_AlphaConstraint() { var constraint = new DefaultInlineConstraintResolver().ResolveConstraint("alpha"); Assert.IsType<AlphaRouteConstraint>(constraint); }
public void ResolveConstraint_DateTimeConstraint() { var constraint = new DefaultInlineConstraintResolver().ResolveConstraint("datetime"); Assert.IsType<DateTimeRouteConstraint>(constraint); }
public void ResolveConstraint_DecimalConstraint() { var constraint = new DefaultInlineConstraintResolver().ResolveConstraint("decimal"); Assert.IsType<DecimalRouteConstraint>(constraint); }
public void ResolveConstraint_LengthRangeConstraint() { var constraint = new DefaultInlineConstraintResolver().ResolveConstraint("length(5, 10)"); Assert.IsType<LengthRouteConstraint>(constraint); LengthRouteConstraint lengthConstraint = (LengthRouteConstraint)constraint; Assert.Equal(5, lengthConstraint.MinLength); Assert.Equal(10, lengthConstraint.MaxLength); }
public void ResolveConstraint_LengthConstraint() { var constraint = new DefaultInlineConstraintResolver().ResolveConstraint("length(5)"); Assert.IsType<LengthRouteConstraint>(constraint); Assert.Equal(5, ((LengthRouteConstraint)constraint).Length); }