public bool IsLoginController(HttpRequestMessage request, string controller_name)
{
try
{
var config = request.GetConfiguration();
var routeData = config.Routes.GetRouteData(request);
var controllerContext = new HttpControllerContext(config, routeData, request);
request.Properties[HttpPropertyKeys.HttpRouteDataKey] = routeData;
controllerContext.RouteData = routeData;
// get controller type
var controllerDescriptor = new DefaultHttpControllerSelector(config).SelectController(request);
var name = controllerDescriptor.ControllerName;
if (name.ToLower() == controller_name.ToLower())
{
return(true);
}
}
catch (Exception)
{
return(false);
}
return(false);
}
public void RelativePath_IsCorrectForTypesFromUri(
string routeTemplate,
string expectedQueryString,
string methodName
)
{
// Arrange
HttpConfiguration config = new HttpConfiguration();
config.Routes.MapHttpRoute(
"Default",
routeTemplate,
new { controller = "ApiExplorerActionsWithParameters", action = methodName }
);
DefaultHttpControllerSelector controllerSelector =
ApiExplorerHelper.GetStrictControllerSelector(
config,
typeof(ApiExplorerActionsWithParametersController)
);
config.Services.Replace(typeof(IHttpControllerSelector), controllerSelector);
IApiExplorer explorer = config.Services.GetApiExplorer();
// Act
ApiDescription description = explorer.ApiDescriptions.FirstOrDefault(
desc => desc.ActionDescriptor.ActionName == methodName
);
// Assert
Assert.NotNull(description);
Assert.Equal(routeTemplate + expectedQueryString, description.RelativePath);
}
public void EnumParameters_ShowUpCorrectlyOnDescription()
{
HttpConfiguration config = new HttpConfiguration();
config.Routes.MapHttpRoute("Default", "{controller}");
DefaultHttpControllerSelector controllerSelector = ApiExplorerHelper.GetStrictControllerSelector(config, typeof(EnumParameterOverloadsController));
config.Services.Replace(typeof(IHttpControllerSelector), controllerSelector);
IApiExplorer explorer = config.Services.GetApiExplorer();
ApiDescription description = explorer.ApiDescriptions.FirstOrDefault(desc => desc.ActionDescriptor.ActionName == "GetWithEnumParameter");
Assert.NotNull(description);
Assert.Equal(1, description.ParameterDescriptions.Count);
Assert.Equal(ApiParameterSource.FromUri, description.ParameterDescriptions[0].Source);
Assert.Equal("EnumParameterOverloads?scope={scope}", description.RelativePath);
description = explorer.ApiDescriptions.FirstOrDefault(desc => desc.ActionDescriptor.ActionName == "GetWithTwoEnumParameters");
Assert.NotNull(description);
Assert.Equal(2, description.ParameterDescriptions.Count);
Assert.Equal(ApiParameterSource.FromUri, description.ParameterDescriptions[0].Source);
Assert.Equal(ApiParameterSource.FromUri, description.ParameterDescriptions[1].Source);
Assert.Equal("EnumParameterOverloads?level={level}&kind={kind}", description.RelativePath);
description = explorer.ApiDescriptions.FirstOrDefault(desc => desc.ActionDescriptor.ActionName == "GetWithNullableEnumParameter");
Assert.NotNull(description);
Assert.Equal(1, description.ParameterDescriptions.Count);
Assert.Equal(ApiParameterSource.FromUri, description.ParameterDescriptions[0].Source);
Assert.Equal("EnumParameterOverloads?level={level}", description.RelativePath);
}
public void DeclaredResponseType_AppearsOnApiDescription(
string actionName,
Type declaredType,
Type responseType,
int responseFormattersCount
)
{
HttpConfiguration config = new HttpConfiguration();
config.Routes.MapHttpRoute(
"Default",
"{controller}/{id}",
new { id = RouteParameter.Optional }
);
Type controllerToTest = typeof(ResponseTypeController);
DefaultHttpControllerSelector controllerSelector =
ApiExplorerHelper.GetStrictControllerSelector(config, controllerToTest);
config.Services.Replace(typeof(IHttpControllerSelector), controllerSelector);
Collection <ApiDescription> apis = config.Services.GetApiExplorer().ApiDescriptions;
ApiDescription expectedApi = apis.FirstOrDefault(
api =>
api.ActionDescriptor.ActionName == actionName &&
api.ResponseDescription.DeclaredType == declaredType &&
api.ResponseDescription.ResponseType == responseType
);
Assert.NotNull(expectedApi);
Assert.Equal(responseFormattersCount, expectedApi.SupportedResponseFormatters.Count);
}
public void SupportedResponseFormatters_ReturnsFormattersWithoutTracers_WithTracing()
{
// Arrange
HttpConfiguration config = new HttpConfiguration();
config.Routes.MapHttpRoute("Default", "{controller}/{id}", new { id = RouteParameter.Optional });
ItemFormatter customFormatter = new ItemFormatter();
config.Formatters.Add(customFormatter);
ITraceWriter testTraceWriter = new Mock <ITraceWriter>().Object;
config.Services.Replace(typeof(ITraceWriter), testTraceWriter);
config.Initializer.Invoke(config);
int expectedFormatterCount = config.Formatters.Count - 2;
DefaultHttpControllerSelector controllerSelector = ApiExplorerHelper.GetStrictControllerSelector(config, typeof(ItemController));
config.Services.Replace(typeof(IHttpControllerSelector), controllerSelector);
IApiExplorer explorer = config.Services.GetApiExplorer();
// Act
ApiDescription description = explorer.ApiDescriptions.FirstOrDefault(desc => desc.ActionDescriptor.ActionName == "PostItem");
Collection <MediaTypeFormatter> formatters = description.SupportedResponseFormatters;
// Assert
Assert.False(formatters.Any(f => f is IFormatterTracer), "Tracers are present");
Assert.Equal(expectedFormatterCount, formatters.Count);
}
public void CustomResponseFormatters_ShowUpOnDescription()
{
HttpConfiguration config = new HttpConfiguration();
config.Routes.MapHttpRoute(
"Default",
"{controller}/{id}",
new { id = RouteParameter.Optional }
);
ItemFormatter customFormatter = new ItemFormatter();
config.Formatters.Add(customFormatter);
DefaultHttpControllerSelector controllerSelector =
ApiExplorerHelper.GetStrictControllerSelector(config, typeof(ItemController));
config.Services.Replace(typeof(IHttpControllerSelector), controllerSelector);
IApiExplorer explorer = config.Services.GetApiExplorer();
ApiDescription description = explorer.ApiDescriptions.FirstOrDefault(
desc => desc.ActionDescriptor.ActionName == "PostItem"
);
Assert.True(
description.SupportedResponseFormatters.Any(
formatter => formatter == customFormatter
),
"Did not find the custom formatter on the SupportedResponseFormatters."
);
}
public void UnknownParameterSource_ShowUpCorrectlyOnDescription()
{
HttpConfiguration config = new HttpConfiguration();
config.Routes.MapHttpRoute(
"Default",
"{controller}/{action}/{id}",
new { id = RouteParameter.Optional }
);
DefaultHttpControllerSelector controllerSelector =
ApiExplorerHelper.GetStrictControllerSelector(
config,
typeof(ParameterSourceController)
);
config.Services.Replace(typeof(IHttpControllerSelector), controllerSelector);
IApiExplorer explorer = config.Services.GetApiExplorer();
ApiDescription description = explorer.ApiDescriptions.FirstOrDefault(
desc => desc.ActionDescriptor.ActionName == "GetFromHeaderAttribute"
);
Assert.NotNull(description);
Assert.True(
description.ParameterDescriptions.All(
param => param.Source == ApiParameterSource.Unknown
),
"The parameter source should be Unknown."
);
}
public void VerifyDefaultDocumentationMessage()
{
HttpConfiguration config = new HttpConfiguration();
config.Routes.MapHttpRoute(
"Default",
"{controller}/{id}",
new { id = RouteParameter.Optional }
);
ItemFormatter customFormatter = new ItemFormatter();
config.Formatters.Add(customFormatter);
DefaultHttpControllerSelector controllerSelector =
ApiExplorerHelper.GetStrictControllerSelector(config, typeof(ItemController));
config.Services.Replace(typeof(IHttpControllerSelector), controllerSelector);
IApiExplorer explorer = config.Services.GetApiExplorer();
foreach (ApiDescription description in explorer.ApiDescriptions)
{
Assert.Null(description.Documentation);
foreach (ApiParameterDescription param in description.ParameterDescriptions)
{
Assert.Null(param.Documentation);
}
}
}
public static RouteInfo RouteRequest(HttpConfiguration config, HttpRequestMessage request)
{
// create context
var controllerContext = new HttpControllerContext(config, Substitute.For <IHttpRouteData>(), request);
// 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
});
}
public void VerifyOnlyOneSetOfDescriptionIsGenerated_OnTwoMatchingRoutes()
{
Type controllerType = typeof(ItemController);
HttpConfiguration config = new HttpConfiguration();
IHttpRoute matchingRoute = config.Routes.MapHttpRoute("Item", "Item/{id}", new { id = RouteParameter.Optional, controller = "Item" });
config.Routes.MapHttpRoute("Default", "{controller}/{id}", new { id = RouteParameter.Optional });
DefaultHttpControllerSelector controllerSelector = ApiExplorerHelper.GetStrictControllerSelector(config, controllerType);
config.Services.Replace(typeof(IHttpControllerSelector), controllerSelector);
IApiExplorer explorer = config.Services.GetApiExplorer();
Collection <ApiDescription> descriptions = explorer.ApiDescriptions;
foreach (ApiDescription description in descriptions)
{
Assert.Same(matchingRoute, description.Route);
}
List <object> expectedResults = new List <object>
{
new { HttpMethod = HttpMethod.Get, RelativePath = "Item?name={name}&series={series}", HasRequestFormatters = false, HasResponseFormatters = true, NumberOfParameters = 2 },
new { HttpMethod = HttpMethod.Post, RelativePath = "Item", HasRequestFormatters = true, HasResponseFormatters = true, NumberOfParameters = 1 },
new { HttpMethod = HttpMethod.Put, RelativePath = "Item", HasRequestFormatters = true, HasResponseFormatters = true, NumberOfParameters = 1 },
new { HttpMethod = HttpMethod.Delete, RelativePath = "Item/{id}", HasRequestFormatters = false, HasResponseFormatters = false, NumberOfParameters = 1 }
};
ApiExplorerHelper.VerifyApiDescriptions(descriptions, expectedResults);
}
public void VerifyDescriptionIsGenerated_WhenRouteParameterIsNotInAction()
{
Type controllerType = typeof(ItemController);
HttpConfiguration config = new HttpConfiguration();
config.Routes.MapHttpRoute("Custom", "{majorVersion}/{minorVersion}/custom", new { controller = "Item" });
config.Routes.MapHttpRoute("Default", "{version}/{controller}/{id}", new { id = RouteParameter.Optional });
DefaultHttpControllerSelector controllerSelector = ApiExplorerHelper.GetStrictControllerSelector(config, controllerType);
config.Services.Replace(typeof(IHttpControllerSelector), controllerSelector);
IApiExplorer explorer = config.Services.GetApiExplorer();
Collection <ApiDescription> descriptions = explorer.ApiDescriptions;
List <object> expectedResults = new List <object>
{
new { HttpMethod = HttpMethod.Get, RelativePath = "{majorVersion}/{minorVersion}/custom?name={name}&series={series}", HasRequestFormatters = false, HasResponseFormatters = true, NumberOfParameters = 4 },
new { HttpMethod = HttpMethod.Post, RelativePath = "{majorVersion}/{minorVersion}/custom", HasRequestFormatters = true, HasResponseFormatters = true, NumberOfParameters = 3 },
new { HttpMethod = HttpMethod.Put, RelativePath = "{majorVersion}/{minorVersion}/custom", HasRequestFormatters = true, HasResponseFormatters = true, NumberOfParameters = 3 },
new { HttpMethod = HttpMethod.Delete, RelativePath = "{majorVersion}/{minorVersion}/custom?id={id}", HasRequestFormatters = false, HasResponseFormatters = false, NumberOfParameters = 3 },
new { HttpMethod = HttpMethod.Get, RelativePath = "{version}/Item?name={name}&series={series}", HasRequestFormatters = false, HasResponseFormatters = true, NumberOfParameters = 3 },
new { HttpMethod = HttpMethod.Post, RelativePath = "{version}/Item", HasRequestFormatters = true, HasResponseFormatters = true, NumberOfParameters = 2 },
new { HttpMethod = HttpMethod.Put, RelativePath = "{version}/Item", HasRequestFormatters = true, HasResponseFormatters = true, NumberOfParameters = 2 },
new { HttpMethod = HttpMethod.Delete, RelativePath = "{version}/Item/{id}", HasRequestFormatters = false, HasResponseFormatters = false, NumberOfParameters = 2 }
};
ApiExplorerHelper.VerifyApiDescriptions(descriptions, expectedResults);
}
/// <summary>
///
/// </summary>
/// <param name="request"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
protected override async Task <HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
// 在请求到达action之前 可处理一些事情，比如 身份校验，内容校验、日志记录
// handle for reques
request.Headers.Add("X-Custom-Header", "This is my custom header for request.");
string controller = new DefaultHttpControllerSelector(GlobalConfiguration.Configuration).SelectController(request).ControllerName;
string guid = controller + Guid.NewGuid();
if (request.Method == HttpMethod.Post)
{
string requestBody = await request.Content.ReadAsStringAsync();
Logger.Writer(guid, QueueStatus.Open, $"the body of request:\r\n{requestBody}");
}
var response = await base.SendAsync(request, cancellationToken);
response.Headers.Add("X-Custom-Header", "This is my custom header for response.");
// 在请求到达action之后，返回结果之前 可对结果进行处理
// handle for response
string responseText = await response.Content.ReadAsStringAsync();
Logger.Writer(guid, QueueStatus.Close, $"the result of response:\r\n{responseText}");
return(response);
}
public void VerifyDescriptionIsNotGeneratedForAmbiguousAction_OnDefaultRoutes()
{
Type controllerType = typeof(AmbiguousActionController);
HttpConfiguration config = new HttpConfiguration();
config.Routes.MapHttpRoute(
"Default",
"{controller}/{id}",
new { id = RouteParameter.Optional }
);
DefaultHttpControllerSelector controllerSelector =
ApiExplorerHelper.GetStrictControllerSelector(config, controllerType);
config.Services.Replace(typeof(IHttpControllerSelector), controllerSelector);
IApiExplorer explorer = config.Services.GetApiExplorer();
Collection <ApiDescription> descriptions = explorer.ApiDescriptions;
List <object> expectedResults = new List <object>
{
new
{
HttpMethod = HttpMethod.Post,
RelativePath = "AmbiguousAction/{id}",
HasRequestFormatters = false,
HasResponseFormatters = true,
NumberOfParameters = 1
}
};
ApiExplorerHelper.VerifyApiDescriptions(descriptions, expectedResults);
}
protected override Task <HttpResponseMessage> SendAsync(HttpRequestMessage request,
CancellationToken cancellationToken)
{
// Para obtener la API Key
IEnumerable <string> listaCabeceras;
var existeCabeceraApiKey = request.Headers.TryGetValues(API_KEY, out listaCabeceras);
if (existeCabeceraApiKey && listaCabeceras.Any())
{
// El descriptor aquí contendrá información sobre el controlador al que se enrutará la solicitud.
// Si es nulo (es decir, no se encontró el controlador), se lanzará una excepción
var config = GlobalConfiguration.Configuration;
var controllerSelector = new DefaultHttpControllerSelector(config);
var controller = controllerSelector.SelectController(request);
if (controller != null && ApiKeys.ContainsKey(controller.ControllerName))
{
// Recupera el Guid de la API para comprobar su autenticación
Guid apiKey = ApiKeys[controller.ControllerName];
if (listaCabeceras.First().Equals(apiKey.ToString()))
{
// Valida el acceso a la API
var principal = new GenericPrincipal(new GenericIdentity("Auth_" + controller.ControllerName), null);
AutorizarAccesoApi(principal);
}
}
}
return(base.SendAsync(request, cancellationToken));
}
public void VerifyCustomDocumentationProviderMessage()
{
HttpConfiguration config = new HttpConfiguration();
config.Routes.MapHttpRoute("Default", "{controller}/{id}", new { id = RouteParameter.Optional });
ItemFormatter customFormatter = new ItemFormatter();
config.Formatters.Add(customFormatter);
DefaultHttpControllerSelector controllerSelector = ApiExplorerHelper.GetStrictControllerSelector(config, typeof(DocumentationController));
config.Services.Replace(typeof(IHttpControllerSelector), controllerSelector);
AttributeDocumentationProvider documentationProvider = new AttributeDocumentationProvider();
config.Services.Replace(typeof(IDocumentationProvider), documentationProvider);
IApiExplorer explorer = config.Services.GetApiExplorer();
foreach (ApiDescription description in explorer.ApiDescriptions)
{
Assert.Equal(
String.Format("{0} action", description.ActionDescriptor.ActionName),
description.Documentation);
foreach (ApiParameterDescription param in description.ParameterDescriptions)
{
Assert.Equal(
String.Format("{0} parameter", param.Name),
param.Documentation);
}
}
}
public RouteTests()
{
this.routes = new HttpRouteCollection();
this.configuration = new HttpConfiguration(this.routes);
RouteConfig.RegisterRoutes(this.configuration);
this.configuration.EnsureInitialized();
this.controllerSelector = new DefaultHttpControllerSelector(this.configuration);
this.actionSelector = new ApiControllerActionSelector();
}
public void RegexConstraint_LimitsTheController(Type[] controllerTypes, List <object> expectedResults)
{
HttpConfiguration config = new HttpConfiguration();
config.Routes.MapHttpRoute("Default", "{controller}/{id}", new { id = RouteParameter.Optional }, new { controller = "It.*" }); // controllers that start with "It"
DefaultHttpControllerSelector controllerSelector = ApiExplorerHelper.GetStrictControllerSelector(config, controllerTypes);
config.Services.Replace(typeof(IHttpControllerSelector), controllerSelector);
IApiExplorer explorer = config.Services.GetApiExplorer();
ApiExplorerHelper.VerifyApiDescriptions(explorer.ApiDescriptions, expectedResults);
}
public void VerifyDescription_OnDefaultRoute(Type controllerType, List <object> expectedResults)
{
HttpConfiguration config = new HttpConfiguration();
config.Routes.MapHttpRoute("Default", "{controller}/{id}", new { id = RouteParameter.Optional });
DefaultHttpControllerSelector controllerSelector = ApiExplorerHelper.GetStrictControllerSelector(config, controllerType);
config.Services.Replace(typeof(IHttpControllerSelector), controllerSelector);
IApiExplorer explorer = config.Services.GetApiExplorer();
ApiExplorerHelper.VerifyApiDescriptions(explorer.ApiDescriptions, expectedResults);
}
public void InvalidControllerNameOnRoute_DoesNotThrow()
{
Type controllerType = typeof(OverloadsController);
HttpConfiguration config = new HttpConfiguration();
config.Routes.MapHttpRoute("Default", "mycontroller/{id}", new { controller = "ControllerThatDoesNotExist", id = RouteParameter.Optional });
DefaultHttpControllerSelector controllerSelector = ApiExplorerHelper.GetStrictControllerSelector(config, controllerType);
config.Services.Replace(typeof(IHttpControllerSelector), controllerSelector);
IApiExplorer explorer = config.Services.GetApiExplorer();
Assert.Empty(explorer.ApiDescriptions);
}
public void EmptyDescription_OnAttributeRoutedAction_UsingStandardRoute()
{
HttpConfiguration config = new HttpConfiguration();
config.Routes.MapHttpRoute("Default", "api/someAction/{id}", new { controller = "Attributed", action = "Get" });
DefaultHttpControllerSelector controllerSelector = ApiExplorerHelper.GetStrictControllerSelector(config, typeof(AttributedController));
config.Services.Replace(typeof(IHttpControllerSelector), controllerSelector);
config.EnsureInitialized();
IApiExplorer explorer = config.Services.GetApiExplorer();
Assert.Empty(explorer.ApiDescriptions);
}
public void VerifyDescription_OnAttributeRoutes(Type controllerType, List <object> expectedResults)
{
HttpConfiguration config = new HttpConfiguration();
config.MapHttpAttributeRoutes();
DefaultHttpControllerSelector controllerSelector = ApiExplorerHelper.GetStrictControllerSelector(config, controllerType);
config.Services.Replace(typeof(IHttpControllerSelector), controllerSelector);
config.EnsureInitialized();
IApiExplorer explorer = config.Services.GetApiExplorer();
ApiExplorerHelper.VerifyApiDescriptions(explorer.ApiDescriptions, expectedResults);
}
public RouteContext(HttpConfiguration config, HttpRequestMessage request)
{
var routeData = config.Routes.GetRouteData(request);
request.SetRouteData(routeData);
var controllerSelector = new DefaultHttpControllerSelector(config);
var descriptor = controllerSelector.SelectController(request);
ControllerType = descriptor.ControllerType;
var actionSelector = new ApiControllerActionSelector();
_actionMappings = actionSelector.GetActionMapping(descriptor).SelectMany(x => x).Where(x => x.SupportedHttpMethods.Contains(request.Method));
}
public RouteContext(HttpConfiguration config, HttpRequestMessage request)
{
var routeData = config.Routes.GetRouteData(request);
request.SetRouteData(routeData);
var controllerSelector = new DefaultHttpControllerSelector(config);
var descriptor = controllerSelector.SelectController(request);
ControllerType = descriptor.ControllerType;
var actionSelector = new ApiControllerActionSelector();
_actionMappings = actionSelector.GetActionMapping(descriptor)[request.Method.ToString()];
}
public void FromUriParameterSource_ShowUpCorrectlyOnDescription()
{
HttpConfiguration config = new HttpConfiguration();
config.Routes.MapHttpRoute(
"Default",
"{controller}/{action}/{id}",
new { id = RouteParameter.Optional }
);
DefaultHttpControllerSelector controllerSelector =
ApiExplorerHelper.GetStrictControllerSelector(
config,
typeof(ParameterSourceController)
);
config.Services.Replace(typeof(IHttpControllerSelector), controllerSelector);
IApiExplorer explorer = config.Services.GetApiExplorer();
ApiDescription description = explorer.ApiDescriptions.FirstOrDefault(
desc => desc.ActionDescriptor.ActionName == "GetCompleTypeFromUri"
);
Assert.NotNull(description);
Assert.True(
description.ParameterDescriptions.All(
param => param.Source == ApiParameterSource.FromUri
),
"All parameters should come from URI."
);
description = explorer.ApiDescriptions.FirstOrDefault(
desc => desc.ActionDescriptor.ActionName == "GetCustomFromUriAttribute"
);
Assert.NotNull(description);
Assert.True(
description.ParameterDescriptions.Any(
param => param.Source == ApiParameterSource.FromUri && param.Name == "value"
),
"The 'value' parameter should come from URI."
);
Assert.True(
description.ParameterDescriptions.Any(
param =>
param.Source == ApiParameterSource.FromBody && param.Name == "bodyValue"
),
"The 'bodyValue' parameter should come from body."
);
}
public void NoDescription_OnAttributeRoutedAction_UsingStandardControllerRoute()
{
HttpConfiguration config = new HttpConfiguration();
var route = config.Routes.MapHttpRoute("Default", "api/someController", new { controller = "DefaultRoute" });
config.MapHttpAttributeRoutes();
DefaultHttpControllerSelector controllerSelector = ApiExplorerHelper.GetStrictControllerSelector(config, typeof(DefaultRouteController));
config.Services.Replace(typeof(IHttpControllerSelector), controllerSelector);
config.EnsureInitialized();
IApiExplorer explorer = config.Services.GetApiExplorer();
Assert.True(explorer.ApiDescriptions.All(d => d.Route != route));
}
private HttpResponseMessage ProcessTokenCheck(HttpRequestMessage request)
{
var config = GlobalConfiguration.Configuration;
var controllerSelector = new DefaultHttpControllerSelector(config);
var descriptor = controllerSelector.SelectController(request);
if (System.Attribute.GetCustomAttributes(descriptor.ControllerType)
.FirstOrDefault(attr => attr.TypeId.ToString().Contains(RegistrationRequiredAttribute.Name)) != null)
{
IEnumerable <string> values;
if (!request.Headers.TryGetValues("token", out values) ||
values.Count() == 0 ||
string.IsNullOrEmpty(values.ToList()[0]))
{
return(ToolsBoxResponse.OK(new BasicResponseModel
{
Message = "Token required",
Status = HttpStatusCode.Forbidden
}));
}
var result = TokenProvider.CheckToken(values.ToList()[0]);
switch (result)
{
case TokenProvider.TokenStatus.WrongToken:
return(ToolsBoxResponse.OK(new BasicResponseModel
{
Message = "Wrong token",
Status = HttpStatusCode.Forbidden
}));
case TokenProvider.TokenStatus.Expired:
return(ToolsBoxResponse.OK(new BasicResponseModel
{
Message = "Token expired",
Status = HttpStatusCode.Forbidden
}));
}
}
return(null);
}
protected override Task <HttpResponseMessage> SendAsync(
HttpRequestMessage request, CancellationToken cancellationToken)
{
if (request.Method == HttpMethod.Options)
{
var apiExplorer = GlobalConfiguration.Configuration.Services.GetApiExplorer();
var config = request.GetConfiguration();
var routeData = config.Routes.GetRouteData(request);
var controllerContext = new HttpControllerContext(config, routeData, request);
request.Properties[HttpPropertyKeys.HttpRouteDataKey] = routeData;
controllerContext.RouteData = routeData;
// get controller type
var controllerDescriptor = new DefaultHttpControllerSelector(config).SelectController(request);
var controllerRequested = controllerDescriptor.ControllerName;
var supportedMethods = apiExplorer.ApiDescriptions
.Where(d =>
{
var controller = d.ActionDescriptor.ControllerDescriptor.ControllerName;
return(string.Equals(
controller, controllerRequested, StringComparison.OrdinalIgnoreCase));
})
.Select(d => d.HttpMethod.Method)
.Distinct();
if (!supportedMethods.Any())
{
return(Task.Factory.StartNew(
() => request.CreateResponse(HttpStatusCode.NotFound)));
}
return(Task.Factory.StartNew(() =>
{
var resp = new HttpResponseMessage(HttpStatusCode.OK);
return resp;
}));
}
return(base.SendAsync(request, cancellationToken));
}
public void ApiRegionByRegionCode()
{
// Arrange
var request = new HttpRequestMessage(HttpMethod.Post, "http://localhost/api/electionmonitoring/regions/ct");
var routeData = webApiConfig.Routes.GetRouteData(request);
request.Properties[HttpPropertyKeys.HttpRouteDataKey] = routeData;
// Act
var controllerContext = new HttpControllerContext(webApiConfig, routeData, request);
var controllerDescriptor = new DefaultHttpControllerSelector(webApiConfig).SelectController(request);
controllerContext.ControllerDescriptor = controllerDescriptor;
// Assert
Assert.AreEqual("electionmonitoring", controllerContext.RouteData.Values["controller"].ToString().ToLower(), "Controller should be ElectionMonitoring, but is " + controllerContext.RouteData.Values["controller"]);
Assert.AreEqual("regions", controllerContext.RouteData.Values["action"].ToString().ToLower(), "ActionName should be Races, but is " + controllerContext.RouteData.Values["action"]);
Assert.AreEqual("ct", controllerContext.RouteData.Values["regioncode"].ToString().ToLower(), "Region code should be ct, but is " + controllerContext.RouteData.Values["regioncode"]);
}
/// <summary>
/// Routes the request.
/// </summary>
/// <param name="config">The config.</param>
/// <param name="request">The request.</param>
/// <returns>Inbformation about the route.</returns>
public static RouteInfo RouteRequest(HttpConfiguration config, HttpRequestMessage request)
{
// create context
var controllerContext = new HttpControllerContext(config, new Mock <IHttpRouteData>().Object, request);
// get route data
var routeData = config.Routes.GetRouteData(request);
RemoveOptionalRoutingParameters(routeData.Values);
HttpActionDescriptor actionDescriptor = null;
HttpControllerDescriptor controllerDescriptor = null;
// Handle web api 2 attribute routes
if (routeData.Values.ContainsKey("MS_SubRoutes"))
{
var subroutes = (IEnumerable <IHttpRouteData>)routeData.Values["MS_SubRoutes"];
routeData = subroutes.First();
actionDescriptor = ((HttpActionDescriptor[])routeData.Route.DataTokens.First(token => token.Key == "actions").Value).First();
controllerDescriptor = actionDescriptor.ControllerDescriptor;
}
else
{
request.Properties[HttpPropertyKeys.HttpRouteDataKey] = routeData;
controllerContext.RouteData = routeData;
// get controller type
controllerDescriptor = new DefaultHttpControllerSelector(config).SelectController(request);
controllerContext.ControllerDescriptor = controllerDescriptor;
// get action name
actionDescriptor = new ApiControllerActionSelector().SelectAction(controllerContext);
}
return(new RouteInfo
{
Controller = controllerDescriptor.ControllerType,
Action = actionDescriptor.ActionName,
RouteData = routeData
});
}
public static void AssertAction <T>(this HttpConfiguration config, string expectedAction, HttpMethod method, string requestUri)
where T : ApiController
{
// Check controller
var request = new HttpRequestMessage(method, new Uri(BaseUri, requestUri));
IHttpRouteData routeData = config.Routes.GetRouteData(request);
request.Properties[HttpPropertyKeys.HttpRouteDataKey] = routeData;
HttpControllerDescriptor controller;
Type controllerType = null;
try
{
controller = new DefaultHttpControllerSelector(config).SelectController(request);
controllerType = controller.ControllerType;
}
catch (HttpResponseException)
{
controller = null;
}
Assert.AreEqual(typeof(T), controllerType);
// Check action
var context = new HttpControllerContext(config, routeData, request)
{
ControllerDescriptor = controller
};
string actionName;
try
{
actionName = new ApiControllerActionSelector().SelectAction(context).ActionName;
}
catch (HttpResponseException)
{
actionName = null;
}
Assert.AreEqual(expectedAction, actionName);
}
