public static void Register(HttpConfiguration config)
{
// attribute routing
var constraintResolver = new DefaultInlineConstraintResolver();
constraintResolver.ConstraintMap.Add("idorcurrent", typeof(IdOrCurrentConstraint));
constraintResolver.ConstraintMap.Add("deviceGuid", typeof(DeviceGuidConstraint));
config.MapHttpAttributeRoutes(constraintResolver);
// use JSON by default
var xmlMediaTypes = config.Formatters.XmlFormatter.SupportedMediaTypes;
xmlMediaTypes.Remove(xmlMediaTypes.FirstOrDefault(t => t.MediaType == "application/xml"));
// set proper JSON formatting
var jsonFormatter = config.Formatters.JsonFormatter;
jsonFormatter.SerializerSettings.Converters.Add(new IsoDateTimeConverter { DateTimeFormat = "yyyy-MM-ddTHH:mm:ss.ffffff" });
// message handlers
var kernel = (IKernel)config.DependencyResolver.GetService(typeof(IKernel));
config.MessageHandlers.Add(kernel.Get<XHttpMethodDelegatingHandler>());
// action selector which handles options method
config.Services.Replace(typeof(IHttpActionSelector), kernel.Get<ActionSelector>());
// global filters
config.Filters.Add(kernel.Get<HandleExceptionAttribute>());
config.Filters.Add(kernel.Get<AuthenticationFilter>());
config.Filters.Add(kernel.Get<AllowCrossDomainOrigin>());
}
private static void ConfigRouting(HttpConfiguration config)
{
var constraintsResolver = new DefaultInlineConstraintResolver();
constraintsResolver.ConstraintMap.Add("apiVersionConstraint", typeof (ApiVersionConstraint));
config.MapHttpAttributeRoutes(constraintsResolver);
config.Services.Replace(typeof (IHttpControllerSelector), new NamespaceHttpControllerSelector(config));
}
public static void Register(HttpConfiguration config)
{
// Web API configuration and services
// Configure Web API to use only bearer token authentication.
config.SuppressDefaultHostAuthentication();
config.Filters.Add(new HostAuthenticationFilter(OAuthDefaults.AuthenticationType));
config.Filters.Add(new NotImplExceptionFilterAttribute());
config.Filters.Add(new ValidateModelAttribute());
// Web API routes
var constraintResolver = new DefaultInlineConstraintResolver();
constraintResolver.ConstraintMap.Add("nonezero", typeof(NoneZeroConstraint));
config.MapHttpAttributeRoutes(constraintResolver);
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
config.Formatters.Add(new ProductCsvFormatter());
config.EnableQuerySupport();
//var provider = new SimpleModelBinderProvider(typeof(Product), new ProductModelBinder());
//config.Services.Insert(typeof(ModelBinderProvider), 0, provider);
DtoMapperConfig.CreateMaps();
}
public static void Register(HttpConfiguration config)
{
// Web API configuration and services
var constraintsResolver = new DefaultInlineConstraintResolver();
constraintsResolver.ConstraintMap.Add("apiVersionConstraint", typeof(ApiVersionConstraint));
config.MapHttpAttributeRoutes(constraintsResolver);
config.Services.Replace(typeof(IHttpControllerSelector),new NamespaceHttpControllerSelector(config));
//config.EnableSystemDiagnosticsTracing();
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());
// Web API routes
//config.MapHttpAttributeRoutes();
//config.Routes.MapHttpRoute(
// name: "DefaultApi",
// routeTemplate: "api/{controller}/{id}",
// defaults: new { id = RouteParameter.Optional }
//);
}
private static decimal GetPrecedence(string attributeRouteTemplate)
{
DefaultInlineConstraintResolver resolver = new DefaultInlineConstraintResolver();
HttpRouteValueDictionary defaults = new HttpRouteValueDictionary();
HttpRouteValueDictionary constraints = new HttpRouteValueDictionary();
string standardRouteTemplate = InlineRouteTemplateParser.ParseRouteTemplate(attributeRouteTemplate,
defaults, constraints, new DefaultInlineConstraintResolver());
HttpParsedRoute parsedRoute = HttpRouteParser.Parse(standardRouteTemplate);
return parsedRoute.GetPrecedence(constraints);
}
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);
}
public static void Register(HttpConfiguration config)
{
config.EnableSystemDiagnosticsTracing();
//config.Services.Replace(typeof(ITraceWriter),new SimpleTraceWriter());
var constraintsResolver = new DefaultInlineConstraintResolver();
constraintsResolver.ConstraintMap.Add("apiVersionConstraint",
typeof(ApiVersionConstraint));
config.MapHttpAttributeRoutes(constraintsResolver);
config.Services.Replace(typeof(IHttpControllerSelector),
new NamespaceHttpControllerSelector(config));
}
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)
{
// Web API configuration and services
// Web API routes
DefaultInlineConstraintResolver constraintResolver = new DefaultInlineConstraintResolver();
constraintResolver.ConstraintMap.Add("culture", typeof(CultureRouteConstraint));
config.MapHttpAttributeRoutes(constraintResolver);
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
}
public static void Register(HttpConfiguration config)
{
//config.EnableSystemDiagnosticsTracing(); // replaced by custom writer
var constraintsResolver = new DefaultInlineConstraintResolver();
constraintsResolver.ConstraintMap.Add("apiVersionConstraint", typeof
(ApiVersionConstraint));
config.MapHttpAttributeRoutes(constraintsResolver);
config.Services.Replace(typeof(IHttpControllerSelector),
new NamespaceHttpControllerSelector(config));
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());
}
public static void Register(HttpConfiguration config)
{
// Web API configuration and services
// Register the SegmentPrefixConstraint for matching an exact segment prefix.
DefaultInlineConstraintResolver constraintResolver = new DefaultInlineConstraintResolver();
constraintResolver.ConstraintMap.Add("SegmentPrefix", typeof(SegmentPrefixConstraint));
// Web API routes
config.MapHttpAttributeRoutes(constraintResolver);
config.Routes.MapHttpRoute(
name: "UriPathExtensionApi",
routeTemplate: "api/{controller}.{ext}/{id}",
defaults: new { id = RouteParameter.Optional }
);
config.Routes.MapHttpRoute(
name: "ServicePathApi3",
routeTemplate: "api/{object1}/{id1}/{object2}/{id2}/{object3}/{id3}/{controller}"
);
config.Routes.MapHttpRoute(
name: "ServicePathApi2",
routeTemplate: "api/{object1}/{id1}/{object2}/{id2}/{controller}"
);
config.Routes.MapHttpRoute(
name: "ServicePathApi1",
routeTemplate: "api/{object1}/{id1}/{controller}"
);
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
config.MessageHandlers.Add(new MethodOverrideHandler());
config.Services.Replace(typeof(IHttpControllerTypeResolver), new ServiceProviderHttpControllerTypeResolver());
FieldInfo suffix = typeof(DefaultHttpControllerSelector).GetField("ControllerSuffix", BindingFlags.Static | BindingFlags.Public);
if (suffix != null) suffix.SetValue(null, "Provider");
// Replace the default controller selector with a custom one which recognises matrix parameters.
config.Services.Replace(typeof(IHttpControllerSelector), new ServiceProviderHttpControllerSelector(config));
}
public static void Register(HttpConfiguration config)
{
// Web API configuration and services
// Register the SegmentPrefixConstraint for matching an exact segment prefix.
DefaultInlineConstraintResolver constraintResolver = new DefaultInlineConstraintResolver();
constraintResolver.ConstraintMap.Add("SegmentPrefix", typeof(SegmentPrefixConstraint));
// Web API routes
config.MapHttpAttributeRoutes(constraintResolver);
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
}
/// <summary>
/// Registers routes for Web API.
/// </summary>
public static void RegisterApiRoutes(HttpConfiguration config)
{
webApiRoute.DefaultInlineConstraintResolver constraintsResolver = new webApiRoute.DefaultInlineConstraintResolver();
Dictionary<string, Type> foundConstraintTypes = GetConstraintTypes();
foreach (string name in foundConstraintTypes.Keys)
constraintsResolver.ConstraintMap.Add(name, foundConstraintTypes[name]);
config.MapHttpAttributeRoutes(constraintsResolver);
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
}
private static HttpResponseMessage ReqestTestsHtml(string testUiScript = null)
{
configuration = new HttpConfiguration();
var constraintResolver = new DefaultInlineConstraintResolver();
constraintResolver.ConstraintMap.Add("among", typeof(AmongConstraint));
configuration.MapHttpAttributeRoutes(constraintResolver);
configuration.MapTestRoutes(testUiScriptUrl: testUiScript);
configuration.EnsureInitialized();
var server = new HttpServer(configuration);
apiClient = new HttpClient(server);
var request = new HttpRequestMessage(HttpMethod.Get, "http://blammo.com/tests/");
request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("text/html"));
var response = apiClient.SendAsync(request).Result;
return response;
}
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));
var constraintsResolver = new DefaultInlineConstraintResolver();
constraintsResolver.ConstraintMap.Add("apiVersionConstraint", typeof(ApiVersionConstraint));
config.MapHttpAttributeRoutes(constraintsResolver);
config.Services.Replace(typeof(IHttpControllerSelector), new NamespaceHttpControllerSelector(config));
config.EnableSystemDiagnosticsTracing();
config.Services.Add(typeof(IExceptionLogger), new SimpleExceptionLogger(WebContainerManager.Get<ILogManager>()));
config.Services.Replace(typeof(ITraceWriter), new SimpleTraceWriter(WebContainerManager.Get<ILogManager>()));
config.Services.Replace(typeof (IExceptionHandler), new GlobalExceptionHandler());
}
internal static void Register(HttpConfiguration config)
{
// IOC container
var container = new UnityContainer();
config.DependencyResolver = new UnityResolver(container);
// IOC resolution
Resolver resolver = new Resolver();
resolver.RegisterTypes(container);
// Logger
var logger = container.Resolve<ILoggingComponent>();
logger.LogInfo(MethodBase.GetCurrentMethod(), "Web Api configuration started.");
//var cors = new EnableCorsAttribute("localhost:50937,localhost:80", "*", "*");
var cors = new EnableCorsAttribute("*", "*", "*");
config.EnableCors(cors);
// Ignore any authentication which happens before the Web API pipeline (by ISS or OWIN). This restricts the API to only authenticate using bearer tokens.
config.SuppressDefaultHostAuthentication();
// Enable authentication using bearer tokens
config.Filters.Add(new HostAuthenticationFilter(OAuthDefaults.AuthenticationType));
// Custom route constraints
var constraintResolver = new DefaultInlineConstraintResolver();
constraintResolver.ConstraintMap.Add("deviceState", typeof(DeviceStateRouteConstraint));
constraintResolver.ConstraintMap.Add("companyId", typeof(CompanyIdRouteConstraint));
constraintResolver.ConstraintMap.Add("macAddress", typeof(MacAddressRouteConstraint));
// API attribute routing
config.MapHttpAttributeRoutes(constraintResolver);
// API action filters
config.Filters.Add(new LogAttribute("PortalApi", 200));
config.Filters.Add(new ValidateModelStateAttribute());
config.Filters.Add(new GlobalExceptionFilterAttribute(logger));
// API formatters
config.Formatters.JsonFormatter.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
config.Formatters.JsonFormatter.SerializerSettings.Converters.Add(new StringEnumConverter());
logger.LogInfo(MethodBase.GetCurrentMethod(), "Web Api configuration complete.");
}
private static void ConfigureRouting(HttpConfiguration config)
{
config.Routes.MapHttpRoute(
name: "legacyRoute",
routeTemplate: "TeamTaskService.asmx",
defaults: null,
constraints: null,
handler: new LegacyAuthenticationMessageHandler(WebContainerManager.Get<ILogManager>())
{
InnerHandler = new LegacyMessageHandler {InnerHandler = new HttpControllerDispatcher(config)}
});
var constraintsResolver = new DefaultInlineConstraintResolver();
constraintsResolver.ConstraintMap.Add("apiVersionConstraint", typeof (ApiVersionConstraint));
config.MapHttpAttributeRoutes(constraintsResolver);
config.Services.Replace(typeof (IHttpControllerSelector),
new NamespaceHttpControllerSelector(config));
}
public static void Register(HttpConfiguration config)
{
var constraintResolver = new DefaultInlineConstraintResolver();
constraintResolver.ConstraintMap.Add("apiVersionConstraint", typeof(ApiVersionConstraint));
config.EnableCors();
config.MapHttpAttributeRoutes(constraintResolver);
// Register custom implementations with the framework
config.Services.Replace(
typeof(IHttpControllerSelector),
new NamespaceHttpControllerSelector(config));
config.Services.Replace(
typeof(ITraceWriter),
new SimpleTraceWriter(WebContainerManager.Get<ILogManager>()));
config.Services.Replace(
typeof(IExceptionLogger),
new SimpleExceptionLogger(WebContainerManager.Get<ILogManager>()));
config.Services.Replace(
typeof(IExceptionHandler),
new GlobalExceptionHandler());
}
public void Configuration(IAppBuilder appBuilder)
{
var config = new HttpConfiguration();
var constraintResolver = new DefaultInlineConstraintResolver();
constraintResolver.ConstraintMap.Add("email", typeof(EmailRouteConstraint));
config.MapHttpAttributeRoutes(constraintResolver);
config.Routes.MapHttpRoute(
name: "Email",
routeTemplate: "{controller}/email/{text}",
constraints: new { text = new EmailRouteConstraint() },
defaults: null
);
config.Routes.MapHttpRoute(
name: "Alpha",
routeTemplate: "{controller}/alpha/{text}",
constraints: new { text = new AlphaRouteConstraint() },
defaults: null
);
appBuilder.UseWebApi(config);
}
public void ResolveConstraint_DecimalConstraint()
{
IHttpRouteConstraint constraint = new DefaultInlineConstraintResolver().ResolveConstraint("decimal");
Assert.IsType <DecimalHttpRouteConstraint>(constraint);
}
public void ResolveConstraint_DateTimeConstraint()
{
IHttpRouteConstraint constraint = new DefaultInlineConstraintResolver().ResolveConstraint("datetime");
Assert.IsType <DateTimeHttpRouteConstraint>(constraint);
}
public void ResolveConstraint_GuidConstraint()
{
IHttpRouteConstraint constraint = new DefaultInlineConstraintResolver().ResolveConstraint("guid");
Assert.IsType <GuidHttpRouteConstraint>(constraint);
}
public void ResolveConstraint_DoubleConstraint()
{
IHttpRouteConstraint constraint = new DefaultInlineConstraintResolver().ResolveConstraint("double");
Assert.IsType <DoubleHttpRouteConstraint>(constraint);
}
public static void BuildWithContainer(IAppBuilder app, Container container, bool registerExceptionlessClient = true) {
if (container == null)
throw new ArgumentNullException("container");
// if enabled, auto upgrade the database
if (Settings.Current.ShouldAutoUpgradeDatabase) {
var url = new MongoUrl(Settings.Current.MongoConnectionString);
string databaseName = url.DatabaseName;
if (Settings.Current.AppendMachineNameToDatabase)
databaseName += String.Concat("-", Environment.MachineName.ToLower());
MongoMigrationChecker.EnsureLatest(Settings.Current.MongoConnectionString, databaseName);
}
Config = new HttpConfiguration();
Config.DependencyResolver = new SimpleInjectorWebApiDependencyResolver(container);
Config.Formatters.Remove(Config.Formatters.XmlFormatter);
Config.Formatters.JsonFormatter.SerializerSettings.Formatting = Formatting.Indented;
Config.Formatters.JsonFormatter.SerializerSettings.ContractResolver = new LowerCaseUnderscorePropertyNamesContractResolver();
var constraintResolver = new DefaultInlineConstraintResolver();
constraintResolver.ConstraintMap.Add("objectid", typeof(ObjectIdRouteConstraint));
constraintResolver.ConstraintMap.Add("objectids", typeof(ObjectIdsRouteConstraint));
Config.MapHttpAttributeRoutes(constraintResolver);
//config.EnableSystemDiagnosticsTracing();
container.RegisterSingle<JsonSerializer>(JsonSerializer.Create(new JsonSerializerSettings { ContractResolver = new SignalRContractResolver() }));
container.RegisterWebApiFilterProvider(Config);
try {
container.Verify();
} catch (Exception ex) {
var tempEx = ex;
while (!(tempEx is ReflectionTypeLoadException)) {
if (tempEx.InnerException == null)
break;
tempEx = tempEx.InnerException;
}
var typeLoadException = tempEx as ReflectionTypeLoadException;
if (typeLoadException != null) {
foreach (var loaderEx in typeLoadException.LoaderExceptions)
Debug.WriteLine(loaderEx.Message);
}
Debug.WriteLine(ex.Message);
throw;
}
Config.MessageHandlers.Add(container.GetInstance<XHttpMethodOverrideDelegatingHandler>());
Config.MessageHandlers.Add(container.GetInstance<EncodingDelegatingHandler>());
Config.MessageHandlers.Add(container.GetInstance<AuthTokenMessageHandler>());
// Throttle api calls to X every 15 minutes by IP address.
Config.MessageHandlers.Add(container.GetInstance<ThrottlingHandler>());
// Reject event posts in orgs over their max event limits.
Config.MessageHandlers.Add(container.GetInstance<OverageHandler>());
app.UseCors(CorsOptions.AllowAll);
app.CreatePerContext<Lazy<User>>("User", ctx => new Lazy<User>(() => {
if (ctx.Request.User == null || ctx.Request.User.Identity == null || !ctx.Request.User.Identity.IsAuthenticated)
return null;
string userId = ctx.Request.User.GetUserId();
if (String.IsNullOrEmpty(userId))
return null;
var userRepository = container.GetInstance<IUserRepository>();
return userRepository.GetById(userId, true);
}));
app.CreatePerContext<Lazy<Project>>("DefaultProject", ctx => new Lazy<Project>(() => {
if (ctx.Request.User == null || ctx.Request.User.Identity == null || !ctx.Request.User.Identity.IsAuthenticated)
return null;
string projectId = ctx.Request.User.GetDefaultProjectId();
var projectRepository = container.GetInstance<IProjectRepository>();
if (String.IsNullOrEmpty(projectId))
return projectRepository.GetByOrganizationIds(ctx.Request.User.GetOrganizationIds(), useCache: true).FirstOrDefault();
return projectRepository.GetById(projectId, true);
}));
if (registerExceptionlessClient) {
ExceptionlessClient.Default.RegisterWebApi(Config);
Config.Services.Add(typeof(IExceptionLogger), new ExceptionlessExceptionLogger());
}
app.UseWebApi(Config);
app.MapSignalR("/api/v2/push", new HubConfiguration { Resolver = new SimpleInjectorSignalRDependencyResolver(container) });
PhysicalFileSystem fileSystem = null;
var root = AppDomain.CurrentDomain.BaseDirectory;
if (Directory.Exists(Path.Combine(root, "./Content")))
fileSystem = new PhysicalFileSystem(Path.Combine(root, "./Content"));
if (Directory.Exists(Path.Combine(root, "./bin/Content")))
fileSystem = new PhysicalFileSystem(Path.Combine(root, "./bin/Content"));
if (fileSystem != null)
app.UseFileServer(new FileServerOptions { FileSystem = fileSystem });
Mapper.Configuration.ConstructServicesUsing(container.GetInstance);
// TODO: Figure out what data we want to create when the db is empty in production mode.
if (Settings.Current.WebsiteMode == WebsiteMode.Dev)
EnsureSampleData(container);
var context = new OwinContext(app.Properties);
var token = context.Get<CancellationToken>("host.OnAppDisposing");
if (Settings.Current.EnableJobsModule) {
Run.InBackground(t => container.GetInstance<ProcessEventPostsJob>().Run(token), token);
Run.InBackground(t => container.GetInstance<ProcessEventUserDescriptionsJob>().Run(token), token);
Run.InBackground(t => container.GetInstance<ProcessMailMessageJob>().Run(token), token);
Run.InBackground(t => container.GetInstance<DailyNotificationJob>().Run(token), token);
Run.InBackground(t => container.GetInstance<EnforceRetentionLimitsJob>().Run(token), token);
Run.InBackground(t => container.GetInstance<RemoveStaleAccountsJob>().Run(token), token);
}
}
public void ResolveConstraint_IntConstraint()
{
IHttpRouteConstraint constraint = new DefaultInlineConstraintResolver().ResolveConstraint("int");
Assert.IsType <IntHttpRouteConstraint>(constraint);
}
private static void SetupRouteConstraints(HttpConfiguration config) {
var constraintResolver = new DefaultInlineConstraintResolver();
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 HttpRouteFactory(string prefix = "api")
{
var constraintResolver = new DefaultInlineConstraintResolver();
List<HttpActionDescriptor> actionDescriptors = new List<HttpActionDescriptor>();
_routeFactoryContext = new DirectRouteFactoryContext(prefix, actionDescriptors, constraintResolver, false);
}
protected virtual HttpConfiguration ConfigureWebApi()
{
var config = new HttpConfiguration();
config.Formatters.Clear();
config.Formatters.Add(JsonFormat.Formatter);
config.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.LocalOnly;
config.Filters.Add(new ApiExceptionFilter());
ConfigureRoutes(config.Routes);
// Use Attribute routing
var resolver = new DefaultInlineConstraintResolver();
ConfigureAttributeRouting(resolver);
config.MapHttpAttributeRoutes(resolver);
#if DEBUG
config.Services.Replace(
typeof(IHttpActionInvoker),
new DebugActionInvoker(config.Services.GetActionInvoker()));
config.Services.Replace(
typeof(IHttpActionSelector),
new DebugActionSelector(config.Services.GetActionSelector()));
config.Services.Replace(
typeof(IHttpControllerSelector),
new DebugControllerSelector(config.Services.GetHttpControllerSelector()));
#endif
return config;
}
public void ResolveConstraint_DecimalConstraint()
{
IHttpRouteConstraint constraint = new DefaultInlineConstraintResolver().ResolveConstraint("decimal");
Assert.IsType<DecimalHttpRouteConstraint>(constraint);
}
public void ResolveConstraint_DoubleConstraint()
{
IHttpRouteConstraint constraint = new DefaultInlineConstraintResolver().ResolveConstraint("double");
Assert.IsType<DoubleHttpRouteConstraint>(constraint);
}
public void ResolveConstraint_GuidConstraint()
{
IHttpRouteConstraint constraint = new DefaultInlineConstraintResolver().ResolveConstraint("guid");
Assert.IsType<GuidHttpRouteConstraint>(constraint);
}
public void ResolveConstraint_IntConstraint()
{
IHttpRouteConstraint constraint = new DefaultInlineConstraintResolver().ResolveConstraint("int");
Assert.IsType<IntHttpRouteConstraint>(constraint);
}
protected override void ConfigureAttributeRouting(DefaultInlineConstraintResolver resolver)
{
base.ConfigureAttributeRouting(resolver);
resolver.ConstraintMap.Add("invocationListCriteria", typeof(EnumConstraint<InvocationListCriteria>));
}
protected virtual void ConfigureAttributeRouting(DefaultInlineConstraintResolver resolver)
{
}
public void ResolveConstraint_BoolConstraint()
{
IHttpRouteConstraint constraint = new DefaultInlineConstraintResolver().ResolveConstraint("bool");
Assert.IsType <BoolHttpRouteConstraint>(constraint);
}
public void ResolveConstraint_LongRangeConstraint()
{
IHttpRouteConstraint constraint = new DefaultInlineConstraintResolver().ResolveConstraint("long");
Assert.IsType <LongHttpRouteConstraint>(constraint);
}
public void ResolveConstraint_AlphaConstraint()
{
IHttpRouteConstraint constraint = new DefaultInlineConstraintResolver().ResolveConstraint("alpha");
Assert.IsType <AlphaHttpRouteConstraint>(constraint);
}
public void ResolveConstraint_LengthConstraint()
{
IHttpRouteConstraint constraint = new DefaultInlineConstraintResolver().ResolveConstraint("length(5)");
Assert.IsType<LengthHttpRouteConstraint>(constraint);
Assert.Equal(5, ((LengthHttpRouteConstraint)constraint).Length);
}
