public void TestRoute(string url, string verb, Type type, string actionName)
{
//Arrange
url = url.Replace("{apiVersionNumber}", this.ApiVersionNumber);
url = Host + url;
//Act
HttpRequestMessage request = new HttpRequestMessage(new HttpMethod(verb), url);
IHttpControllerSelector controller = this.GetControllerSelector();
IHttpActionSelector action = this.GetActionSelector();
IHttpRouteData route = this.Config.Routes.GetRouteData(request);
request.Properties[HttpPropertyKeys.HttpRouteDataKey] = route;
request.Properties[HttpPropertyKeys.HttpConfigurationKey] = this.Config;
HttpControllerDescriptor controllerDescriptor = controller.SelectController(request);
HttpControllerContext context = new HttpControllerContext(this.Config, route, request)
{
ControllerDescriptor = controllerDescriptor
};
var actionDescriptor = action.SelectAction(context);
//Assert
Assert.NotNull(controllerDescriptor);
Assert.NotNull(actionDescriptor);
Assert.Equal(type, controllerDescriptor.ControllerType);
Assert.Equal(actionName, actionDescriptor.ActionName);
}
/// <summary>
/// Selects the action for the controller.
/// </summary>
/// <param name="controllerContext">The context of the controller.</param>
/// <returns>The action for the controller.</returns>
public HttpActionDescriptor SelectAction(HttpControllerContext controllerContext)
{
if (_innerSelector != null)
{
var result = _innerSelector.SelectAction(controllerContext);
return(result);
}
throw new NotImplementedException();
}
public IEnumerable <Tuple <string, FilterScope> > Get()
{
IHttpActionSelector actionSelector = this.Configuration.Services.GetActionSelector();
HttpActionDescriptor actionDescriptor = actionSelector.SelectAction(this.ControllerContext);
foreach (FilterInfo filterInfo in actionDescriptor.GetFilterPipeline())
{
yield return(new Tuple <string, FilterScope>(filterInfo.Instance.GetType().Name, filterInfo.Scope));
}
}
/// <summary>
/// Gets the action descriptor.
/// </summary>
/// <param name="a_controllerContext">
/// The controller context.
/// </param>
/// <returns>
/// The action descriptor for the controller context.
/// </returns>
private HttpActionDescriptor GetActionDescriptor(HttpControllerContext a_controllerContext)
{
try
{
return(m_actionSelector.SelectAction(a_controllerContext));
}
catch (InvalidOperationException)
{
return(null);
}
}
public HttpActionDescriptor SelectAction(HttpControllerContext controllerContext)
{
// Get HttpMethod from current context
HttpMethod httpMethod = controllerContext.Request.Method;
// Set route values for API
controllerContext.RouteData.Values.Add("action", httpMethod.Method);
// Invoke Action
return(defaultSelector.SelectAction(controllerContext));
}
public HttpActionDescriptor SelectAction(HttpControllerContext controllerContext)
{
if (controllerContext == null)
{
throw Error.ArgumentNull("controllerContext");
}
HttpRequestMessage request = controllerContext.Request;
ODataPath odataPath = request.ODataProperties().Path;
IEnumerable <IODataRoutingConvention> routingConventions = request.GetRoutingConventions();
IHttpRouteData routeData = controllerContext.RouteData;
if (odataPath == null || routingConventions == null || routeData.Values.ContainsKey(ODataRouteConstants.Action))
{
return(_innerSelector.SelectAction(controllerContext));
}
ILookup <string, HttpActionDescriptor> actionMap = _innerSelector.GetActionMapping(controllerContext.ControllerDescriptor);
foreach (IODataRoutingConvention routingConvention in routingConventions)
{
string actionName = routingConvention.SelectAction(
odataPath,
controllerContext,
actionMap);
if (actionName != null)
{
routeData.Values[ODataRouteConstants.Action] = actionName;
var action = _innerSelector.SelectAction(controllerContext);
if (ActionParametersMatchRequest(action, controllerContext))
{
return(action);
}
}
}
throw new HttpResponseException(CreateErrorResponse(request, HttpStatusCode.NotFound,
Error.Format(SRResources.NoMatchingResource, controllerContext.Request.RequestUri),
Error.Format(SRResources.NoRoutingHandlerToSelectAction, odataPath.PathTemplate)));
}
public override Task <HttpResponseMessage> ExecuteAsync(HttpControllerContext controllerContext, CancellationToken cancellationToken)
{
this.Initialize(controllerContext);
IHttpActionSelector actionSelector = this.Configuration.Services.GetActionSelector();
HttpControllerDescriptor controllerDescriptor = this.ControllerContext.ControllerDescriptor;
HttpActionDescriptor actionDescriptor = actionSelector.SelectAction(controllerContext);
HttpActionContext actionContext = new HttpActionContext(controllerContext, actionDescriptor);
actionDescriptor.ActionBinding.ExecuteBindingAsync(actionContext, cancellationToken).Wait();
return(this.Configuration.Services.GetActionInvoker().InvokeActionAsync(actionContext, cancellationToken));
}
public HttpActionDescriptor SelectAction(HttpControllerContext controllerContext)
{
try
{
return(_concreteSelector.SelectAction(controllerContext));
}
catch (HttpResponseException ex)
{
_clientCreator.GenerateRaygunWebApiClient().CurrentHttpRequest(controllerContext.Request).SendInBackground(ex);
throw;
}
}
public HttpActionDescriptor SelectAction(HttpControllerContext controllerContext)
{
var request = controllerContext.Request;
if (request.IsInspectRequest())
{
var simulate = new ActionSelectSimulator();
request.Properties[RequestHelper.ActionCache] = simulate.Simulate(controllerContext);
}
var selectedAction = _innerSelector.SelectAction(controllerContext);
return(selectedAction);
}
public HttpActionDescriptor SelectAction(HttpControllerContext controllerContext)
{
try
{
return(_concreteSelector.SelectAction(controllerContext));
}
catch (HttpResponseException ex)
{
_clientCreator.GenerateRaygunWebApiClient(controllerContext.Request).SendInBackground(ex, new List <string> {
RaygunWebApiClient.UnhandledExceptionTag
});
throw;
}
}
public override RequestAnalysisResult GetRequestAnalysis(RequestAnalysisContext analysisContext)
{
HttpRequestMessage request = analysisContext.RequestMessage;
HttpConfiguration httpConfiguration = request.GetConfiguration();
IHttpRouteData httpRouteData = httpConfiguration.Routes.GetRouteData(request);
request.SetRouteData(httpRouteData);
//IAssembliesResolver assembliesResolver= httpConfiguration.Services.GetAssembliesResolver();
//IHttpControllerTypeResolver controllerTypeResolver = httpConfiguration.Services.GetHttpControllerTypeResolver();
//ICollection<Type> controllerTypes= controllerTypeResolver.GetControllerTypes(assembliesResolver);
IHttpControllerSelector controllerSelector = httpConfiguration.Services.GetHttpControllerSelector();
HttpControllerDescriptor controllerDescriptor = controllerSelector.SelectController(request);
HttpControllerContext controllerContext = new HttpControllerContext(httpConfiguration, httpRouteData, request);
controllerContext.ControllerDescriptor = controllerDescriptor;
IHttpActionSelector actionSelector = httpConfiguration.Services.GetActionSelector();
HttpActionDescriptor actionDescriptor = actionSelector.SelectAction(controllerContext);
RequestAnalysisResult analysisResult = new RequestAnalysisResult();
analysisResult.Url = request.RequestUri.ToString();
analysisResult.SupportedHttpMethods = actionDescriptor.SupportedHttpMethods.Select(method => method.Method).ToArray();
analysisResult.Parameters = actionDescriptor.GetParameters().Select(parameter => parameter.ParameterName).ToArray();
analysisResult.ActionName = actionDescriptor.ActionName;
analysisResult.ControllerName = actionDescriptor.ControllerDescriptor.ControllerName;
analysisResult.Values = httpRouteData.Values;
analysisResult.DataTokens = httpRouteData.Route.DataTokens;
analysisResult.Mode = Mode;
string path = new DirectoryInfo(string.Format(@"{0}{1}", AppDomain.CurrentDomain.BaseDirectory, LookupPrefix)).FullName;
analysisResult.FilePath = LookupFilePath(path, analysisResult.ControllerName);
return(analysisResult);
}
HttpActionDescriptor IHttpActionSelector.SelectAction(HttpControllerContext controllerContext)
{
HttpActionDescriptor actionDescriptor = null;
_traceWriter.TraceBeginEnd(
controllerContext.Request,
TraceCategories.ActionCategory,
TraceLevel.Info,
_innerSelector.GetType().Name,
SelectActionMethodName,
beginTrace: null,
execute: () => { actionDescriptor = _innerSelector.SelectAction(controllerContext); },
endTrace: (tr) =>
{
tr.Message = Error.Format(
SRResources.TraceActionSelectedMessage,
FormattingUtilities.ActionDescriptorToString(actionDescriptor));
},
errorTrace: null);
// Intercept returned HttpActionDescriptor with a tracing version
return(actionDescriptor == null ? null : new HttpActionDescriptorTracer(controllerContext, actionDescriptor, _traceWriter));
}
public override HttpActionDescriptor SelectAction(HttpControllerContext controllerContext)
{
var dynController = controllerContext.Controller as DynamicController;
if (dynController != null)
{
//We want to use http verb only from inherited selection.
var tempData = controllerContext.RouteData;
controllerContext.RouteData = new HttpRouteData(controllerContext.RouteData.Route);
var reflectedCandidate = (ReflectedHttpActionDescriptor)base.SelectAction(controllerContext);
controllerContext.RouteData = tempData;
string actionName = null;
bool hasActionRouteKey = controllerContext.RouteData.Values.TryGetValue <string>("action", ref actionName);
var candidateActions = dynController.ControllerInfo.DynamicActions
.Where(candidateAction => candidateAction.Enabled && candidateAction.HttpVerbs.All.Contains(controllerContext.Request.Method.ToWebMethod()) &&
((!hasActionRouteKey && !candidateAction.EnforceActionName) ||
(StringComparer.OrdinalIgnoreCase.Compare(candidateAction.Name, actionName) == 0)))
.ToList();
if (candidateActions.Count > 1)
{
IDictionary <string, object> values = controllerContext.RouteData.Values;
var strRouteParams = new HashSet <string>(values.Keys, StringComparer.OrdinalIgnoreCase);
strRouteParams.Remove("controller");
if (hasActionRouteKey)
{
strRouteParams.Remove("action");
}
if (controllerContext.Request.RequestUri != null && !string.IsNullOrEmpty(controllerContext.Request.RequestUri.Query))
{
foreach (KeyValuePair <string, string> queryNameValuePair in controllerContext.Request.GetQueryNameValuePairs())
{
strRouteParams.Add(queryNameValuePair.Key);
}
}
foreach (DynamicAction objMethod in new List <DynamicAction>(candidateActions))
{
//removing actions with dynamic parameters not found in routeData
foreach (var pairActionDynamicParam in objMethod.ParametersDictionary)
{
if (!pairActionDynamicParam.Value.IsOptional)
{
if (!pairActionDynamicParam.Value.DynamicAttributes.Items.Any(objAttr => objAttr is FromBodyAttribute))
{
if (!strRouteParams.Contains(pairActionDynamicParam.Key))
{
candidateActions.Remove(objMethod);
}
}
}
}
if (candidateActions.Count > 1)
{
Object objDefaultValue = null;
foreach (string strRouteParam in strRouteParams)
{
if (!objMethod.ParametersDictionary.ContainsKey(strRouteParam) &&
(!controllerContext.RouteData.Route.Defaults.TryGetValue(strRouteParam, out objDefaultValue) ||
objDefaultValue != RouteParameter.Optional))
{
candidateActions.Remove(objMethod);
}
}
}
}
}
if (candidateActions.Count > 1)
{
candidateActions = candidateActions.GroupBy <DynamicAction, Int32>(method => method.Parameters.Count)
.OrderByDescending(g => g.Key)
.First()
.ToList();
}
string templatedMessage;
switch (candidateActions.Count)
{
case 0:
templatedMessage = DotNetNuke.Services.Localization.Localization.GetString("ActionNotFound.Message", PortalKeeperContext <RequestEvent> .SharedResourceFile);
throw new HttpResponseException(controllerContext.Request.CreateErrorResponse(HttpStatusCode.NotFound,
string.Format(templatedMessage, new object[3] {
controllerContext.Request.RequestUri != null ? controllerContext.Request.RequestUri.ToString() : "", controllerContext.ControllerDescriptor.ControllerName, actionName
})));
case 1:
var candidateDynamicMethod = candidateActions[0];
var toReturn = new DynamicHttpActionDescriptor(dynController.Service, dynController.ControllerInfo, candidateDynamicMethod, reflectedCandidate);
return(toReturn);
default:
templatedMessage = DotNetNuke.Services.Localization.Localization.GetString("AmbiguousAction.Message", PortalKeeperContext <RequestEvent> .SharedResourceFile);
throw new HttpResponseException(controllerContext.Request.CreateErrorResponse(HttpStatusCode.Ambiguous,
string.Format(templatedMessage, new object[3] {
controllerContext.Request.RequestUri != null ? controllerContext.Request.RequestUri.ToString() : "", controllerContext.ControllerDescriptor.ControllerName, actionName
})));
}
}
else
{
if (_originalActionSelector != null)
{
return(_originalActionSelector.SelectAction(controllerContext));
}
return(base.SelectAction(controllerContext));
}
}
public HttpActionDescriptor SelectAction(HttpControllerContext controllerContext)
{
return(httpActionSelector.SelectAction(controllerContext));
}
public HttpActionDescriptor SelectAction(HttpControllerContext controllerContext)
{
if (controllerContext == null)
{
throw new ArgumentNullException("controllerContext");
}
HttpRequestMessage request = controllerContext.Request;
ODataPath odataPath = request.ODataProperties().Path;
IEnumerable <IODataRoutingConvention> routingConventions = request.ODataProperties().RoutingConventions;
IHttpRouteData routeData = controllerContext.RouteData;
if (odataPath == null || routingConventions == null || routeData.Values.ContainsKey(ODataRouteConstants.Action))
{
return(_innerSelector.SelectAction(controllerContext));
}
ILookup <string, HttpActionDescriptor> actionMap = GetActionMapping(controllerContext.ControllerDescriptor);
foreach (IODataRoutingConvention routingConvention in routingConventions)
{
string actionName = routingConvention.SelectAction(odataPath, controllerContext, actionMap);
if (actionName != null)
{
routeData.Values[ODataRouteConstants.Action] = actionName;
IEnumerable <HttpActionDescriptor> candidateActions = actionMap[actionName];
int countMatchingActions = candidateActions.Count();
if (countMatchingActions == 1)
{
HttpActionDescriptor selectedCandidate = candidateActions.First();
return(selectedCandidate);
}
else if (countMatchingActions == 0)
{
return(null);
}
if (candidateActions.Any(candidateAction => ChangeSetEntityModelBinder.ActionHasChangeSetEntityParameter(candidateAction)))
{
IEnumerable <HttpActionDescriptor> orderedActions = candidateActions.OrderBy(DetermineActionOrder);
// TODO: IDEAL: Select the first action with all parameters present
// Since I can't figure out a good way to determine that, this implementation returns
// the changeSetEntity action iff the request URI has a ContentId reference;
// otherwise it returns the next available action.
foreach (var candidateAction in orderedActions)
{
if (ChangeSetEntityModelBinder.ActionHasChangeSetEntityParameter(candidateAction))
{
if (ContentIdHelper.RequestHasContentIdReference(controllerContext.Request))
{
return(candidateAction);
}
// else continue;
}
else
{
return(candidateAction);
}
}
}
else
{
// If there aren't any ChangeSet entity parameters in any of the candidate actions, just use the regular
// HttpActionSelector's implementation. It does a good job selecting the best match based on parameters, but it doesn't support
// using an expanded set of actions.
return(_innerSelector.SelectAction(controllerContext));
}
}
}
throw new HttpResponseException(request.CreateErrorResponse(HttpStatusCode.NotFound,
string.Format("No matching resource found for {0}", controllerContext.Request.RequestUri)));
}
