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);
}