public async Task Invoke(HttpContext httpContext)
{
if (_logger.IsEnabled(LogLevel.Information))
{
_logger.LogInformation("Begin Routing Request");
}
var shellSettings = httpContext.RequestServices.GetService<ShellSettings>();
var routerTable = httpContext.RequestServices.GetService<IRunningShellRouterTable>();
var router = routerTable.GetOrAdd(
shellSettings.Name,
name => httpContext.RequestServices.GetService<IRouteBuilder>().Build()
);
var context = new RouteContext(httpContext);
context.RouteData.Routers.Add(router);
await router.RouteAsync(context);
if (context.Handler == null)
{
if (_logger.IsEnabled(LogLevel.Information))
{
_logger.LogInformation("Request did not match any routes.");
}
await _next.Invoke(httpContext);
}
if (_logger.IsEnabled(LogLevel.Information))
{
_logger.LogInformation("End Routing Request");
}
}
public override Boolean IsValidForRequest(RouteContext context, ActionDescriptor action)
{
if (context.HttpContext.Request.Headers == null)
return false;
return context.HttpContext.Request.Headers["X-Requested-With"] == "XMLHttpRequest";
}
public void IsValidForRequest_NullHeader_ReturnsFalse()
{
RouteContext context = new RouteContext(Substitute.For<HttpContext>());
context.HttpContext.Request.Headers.Returns(null as IHeaderDictionary);
Assert.False(new AjaxOnlyAttribute().IsValidForRequest(context, null));
}
public async virtual Task RouteAsync(RouteContext context)
{
// Perf: We want to avoid allocating a new RouteData for each route we need to process.
// We can do this by snapshotting the state at the beginning and then restoring it
// for each router we execute.
var snapshot = context.RouteData.PushState(null, values: null, dataTokens: null);
for (var i = 0; i < Count; i++)
{
var route = this[i];
context.RouteData.Routers.Add(route);
try
{
await route.RouteAsync(context);
if (context.Handler != null)
{
break;
}
}
finally
{
if (context.Handler == null)
{
snapshot.Restore();
}
}
}
}
public ActionDescriptor Select(RouteContext context)
{
if (context.HttpContext.ODataProperties().IsValidODataRequest)
{
return _convention.SelectAction(context);
}
return _selector.Select(context);
}
public void IsValidForRequest_Ajax(String header, Boolean isValid)
{
RouteContext context = new RouteContext(Substitute.For<HttpContext>());
context.HttpContext.Request.Headers["X-Requested-With"].Returns(new StringValues(header));
Boolean actual = new AjaxOnlyAttribute().IsValidForRequest(context, null);
Boolean expected = isValid;
Assert.Equal(expected, actual);
}
public override bool IsValidForRequest(RouteContext routeContext, ActionDescriptor action)
{
if(routeContext.HttpContext.Request.Method != "POST")
{
return false;
}
var value = routeContext.HttpContext.Request.Form[_submitButtonName];
return !string.IsNullOrEmpty(value);
}
public Task RouteAsync(RouteContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (Actions == null)
{
var message = Resources.FormatPropertyOfTypeCannotBeNull(
nameof(Actions),
nameof(MvcAttributeRouteHandler));
throw new InvalidOperationException(message);
}
var actionDescriptor = _actionSelector.SelectBestCandidate(context, Actions);
if (actionDescriptor == null)
{
_logger.NoActionsMatched();
return TaskCache.CompletedTask;
}
foreach (var kvp in actionDescriptor.RouteValues)
{
if (!string.IsNullOrEmpty(kvp.Value))
{
context.RouteData.Values[kvp.Key] = kvp.Value;
}
}
context.Handler = (c) =>
{
var routeData = c.GetRouteData();
var actionContext = new ActionContext(context.HttpContext, routeData, actionDescriptor);
if (_actionContextAccessor != null)
{
_actionContextAccessor.ActionContext = actionContext;
}
var invoker = _actionInvokerFactory.CreateInvoker(actionContext);
if (invoker == null)
{
throw new InvalidOperationException(
Resources.FormatActionInvokerFactory_CouldNotCreateInvoker(
actionDescriptor.DisplayName));
}
return invoker.InvokeAsync();
};
return TaskCache.CompletedTask;
}
public async Task RouteAsync(RouteContext context)
{
await Router.RouteAsync(context);
if (context.Handler == null)
context.Handler = (http) =>
{
http.Response.StatusCode = 404;
return Task.CompletedTask;
};
}
public void ActionNameAttribute_DifferentActionName_UsesActionNameFromActionNameAttribute(string verb, string actionName)
{
// Arrange
var routeContext = new RouteContext(GetHttpContext(verb));
routeContext.RouteData.Values.Add("controller", "ActionName");
routeContext.RouteData.Values.Add("action", actionName);
// Act
var result = InvokeActionSelector(routeContext);
// Assert
Assert.Equal(actionName, result.ActionName);
}
public void ActionNameAttribute_ActionGetsExposedViaActionName_UnreachableByConvention(string verb)
{
// Arrange
var routeContext = new RouteContext(GetHttpContext(verb));
routeContext.RouteData.Values.Add("controller", "ActionName");
routeContext.RouteData.Values.Add("action", "RPCMethodWithHttpGet");
// Act
var result = InvokeActionSelector(routeContext);
// Assert
Assert.Null(result);
}
protected override async Task OnRouteMatched(RouteContext context)
{
var siteSettings = await _siteService.GetSiteSettingsAsync();
foreach (var entry in siteSettings.HomeRoute)
{
context.RouteData.Values[entry.Key] = entry.Value;
}
_tokens = siteSettings.HomeRoute;
await base.OnRouteMatched(context);
}
public static RouteData ResolveRouteData(IRouter router, RouteContext routeContext)
{
var path = routeContext.HttpContext.Request?.Path;
if (path == null || !path.HasValue || path.Value == string.Empty)
{
return null;
}
AsyncHelper.RunSync(() => router.RouteAsync(routeContext));
var routeData = routeContext.RouteData;
routeContext.HttpContext.SetRouteData(routeData);
return routeData;
}
public override bool IsValidForRequest(RouteContext context, ActionDescriptor action) {
if (string.Equals(context.HttpContext.Request.Method, "GET", StringComparison.OrdinalIgnoreCase) ||
string.Equals(context.HttpContext.Request.Method, "HEAD", StringComparison.OrdinalIgnoreCase) ||
string.Equals(context.HttpContext.Request.Method, "DELETE", StringComparison.OrdinalIgnoreCase) ||
string.Equals(context.HttpContext.Request.Method, "TRACE", StringComparison.OrdinalIgnoreCase)) {
return false;
}
if (string.IsNullOrEmpty(context.HttpContext.Request.ContentType)) {
return false;
}
if (!context.HttpContext.Request.ContentType.StartsWith("application/x-www-form-urlencoded", StringComparison.OrdinalIgnoreCase)) {
return false;
}
return !string.IsNullOrEmpty(context.HttpContext.Request.Form[_name]);
}
public Task RouteAsync(RouteContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
var candidates = _actionSelector.SelectCandidates(context);
if (candidates == null || candidates.Count == 0)
{
_logger.NoActionsMatched();
return TaskCache.CompletedTask;
}
var actionDescriptor = _actionSelector.SelectBestCandidate(context, candidates);
if (actionDescriptor == null)
{
_logger.NoActionsMatched();
return TaskCache.CompletedTask;
}
context.Handler = (c) =>
{
var routeData = c.GetRouteData();
var actionContext = new ActionContext(context.HttpContext, routeData, actionDescriptor);
if (_actionContextAccessor != null)
{
_actionContextAccessor.ActionContext = actionContext;
}
var invoker = _actionInvokerFactory.CreateInvoker(actionContext);
if (invoker == null)
{
throw new InvalidOperationException(
Resources.FormatActionInvokerFactory_CouldNotCreateInvoker(
actionDescriptor.DisplayName));
}
return invoker.InvokeAsync();
};
return TaskCache.CompletedTask;
}
public Task RouteAsync(RouteContext context)
{
var requestPath = context.HttpContext.Request.Path.Value ?? string.Empty;
if (requestPath.StartsWith(_prefix, StringComparison.OrdinalIgnoreCase))
{
if (requestPath.Length > _prefix.Length)
{
var lastCharacter = requestPath[_prefix.Length];
if (lastCharacter != '/' && lastCharacter != '#' && lastCharacter != '?')
{
return Task.FromResult(0);
}
}
context.Handler = _target.GetRequestHandler(context.HttpContext, context.RouteData);
}
return Task.FromResult(0);
}
public override async Task RouteAsync(RouteContext context)
{
if (context.HttpContext.Request.Body != null
&& context.HttpContext.Request.ContentLength != null
&& context.HttpContext.Request.ContentLength > 0)
{
XDocument xDoc = XDocument.Load(context.HttpContext.Request.Body);
string methodName = xDoc.Document
.Element("methodCall")
.Element("methodName")
.Value;
var methodNameParts = methodName.Split('.');
context.RouteData.Values["controller"] = "MetaWeblog";
context.RouteData.Values["action"] = methodNameParts[1];
context.HttpContext.Items["Xml-Rpc-Document"] = xDoc;
}
await base.RouteAsync(context);
}
public ActionDescriptor SelectBestCandidate(RouteContext context, IReadOnlyList<ActionDescriptor> candidates)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (candidates == null)
{
throw new ArgumentNullException(nameof(candidates));
}
var matches = EvaluateActionConstraints(context, candidates);
var finalMatches = SelectBestActions(matches);
if (finalMatches == null || finalMatches.Count == 0)
{
return null;
}
else if (finalMatches.Count == 1)
{
var selectedAction = finalMatches[0];
return selectedAction;
}
else
{
var actionNames = string.Join(
Environment.NewLine,
finalMatches.Select(a => a.DisplayName));
_logger.AmbiguousActions(actionNames);
var message = Resources.FormatDefaultActionSelector_AmbiguousActions(
Environment.NewLine,
actionNames);
throw new AmbiguousActionException(message);
}
}
public async Task RouteAsync(RouteContext context)
{
if (IsValidRequest(context.HttpContext))
{
try
{
// Store the requested targetted action so that the OrchardMiddleware
// can continue with it once the tenant pipeline has been executed
context.HttpContext.Items["orchard.middleware.context"] = context;
context.HttpContext.Items["orchard.middleware.routes"] = _routes;
await _pipeline.Invoke(context.HttpContext);
}
catch (Exception ex)
{
var logger = context.HttpContext.RequestServices.GetService<ILogger<TenantRoute>>();
logger.LogError("Error occured serving tenant route", ex);
throw;
}
}
}
public async Task RouteAsync(RouteContext context)
{
var path = context.HttpContext.Request.Path.ToString().TrimStart('/').TrimEnd('/');
// root
if (path == string.Empty && _opts.RootViewName != null)
{
path = _opts.RootViewName;
}
if (!path.Contains(".")) // if path doesn't have an extension, we want to probe it for being a page
{
var filePath = Path.Combine(_hostingEnvironment.ContentRootPath, _opts.ViewsFolderName, path + ".cshtml");
if (!File.Exists(filePath))
{
context.HttpContext.Response.StatusCode = 404;
return;
}
var contents = _renderer.RenderViewToString(path);
await context.HttpContext.Response.WriteAsync(contents);
}
}
public async Task RouteAsync(RouteContext context)
{
var request = context.HttpContext.Request;
Uri uri;
PathString remaining;
if (!request.Path.StartsWithSegments(PathString.FromUriComponent("/" + RoutePrefix), out remaining))
{
// Fallback to other routes.
return;
}
uri = new Uri(remaining.ToString(), UriKind.Relative);
context.HttpContext.ODataProperties().Model = _model;
var parser = new ODataUriParser(_model, uri);
var path = parser.ParsePath();
context.HttpContext.ODataProperties().NewPath = path;
context.HttpContext.ODataProperties().Path =
context.HttpContext.ODataPathHandler().Parse(_model, "http://service-root/", remaining.ToString());
context.HttpContext.ODataProperties().IsValidODataRequest = true;
var ase = context.HttpContext.RequestServices.GetRequiredService<IActionSelector>();
await m.RouteAsync(context);
}
public async Task RouteAsync(RouteContext context)
{
// Abort and proceed to other routes in the route table if path contains api or ui
string[] segments = context.HttpContext.Request.Path.Value.Split(new[] { '/' });
if (segments.Any(segment => segment.Equals("api", StringComparison.OrdinalIgnoreCase) ||
segment.Equals("brics", StringComparison.OrdinalIgnoreCase)))
{
return;
}
var requestCulture = DetectRequestCulture(context.HttpContext);
IResolveResult result = await _routeResolver.Resolve(context, requestCulture);
if(result != null) {
context.RouteData.Values[ControllerKey] = result.Controller;
context.RouteData.Values[ActionKey] = result.Action;
context.HttpContext .Items[CurrentNodeKey] = result.TrieNode;
}
await _defaultHandler.RouteAsync(context);
}
public ODataRouteContext(RouteContext other)
: this(other.HttpContext)
{
//this.IsHandled = other.IsHandled;
this.RouteData = new RouteData(other.RouteData);
}
private RouteContext CreateRouteContext(
ActionDescriptor actionDescriptor = null,
IActionSelector actionSelector = null,
IActionInvokerFactory invokerFactory = null,
ILoggerFactory loggerFactory = null,
IOptions<MvcOptions> optionsAccessor = null,
object diagnosticListener = null)
{
if (actionDescriptor == null)
{
var mockAction = new Mock<ActionDescriptor>();
actionDescriptor = mockAction.Object;
}
if (actionSelector == null)
{
var mockActionSelector = new Mock<IActionSelector>();
mockActionSelector.Setup(a => a.Select(It.IsAny<RouteContext>()))
.Returns(actionDescriptor);
actionSelector = mockActionSelector.Object;
}
if (invokerFactory == null)
{
var mockInvoker = new Mock<IActionInvoker>();
mockInvoker.Setup(i => i.InvokeAsync())
.Returns(Task.FromResult(true));
var mockInvokerFactory = new Mock<IActionInvokerFactory>();
mockInvokerFactory.Setup(f => f.CreateInvoker(It.IsAny<ActionContext>()))
.Returns(mockInvoker.Object);
invokerFactory = mockInvokerFactory.Object;
}
if (loggerFactory == null)
{
loggerFactory = NullLoggerFactory.Instance;
}
if (optionsAccessor == null)
{
optionsAccessor = new TestOptionsManager<MvcOptions>();
}
var diagnosticSource = new DiagnosticListener("Microsoft.AspNetCore");
if (diagnosticListener != null)
{
diagnosticSource.SubscribeWithAdapter(diagnosticListener);
}
var routingFeature = new RoutingFeature();
var httpContext = new Mock<HttpContext>();
httpContext
.Setup(h => h.RequestServices.GetService(typeof(IActionContextAccessor)))
.Returns(new ActionContextAccessor());
httpContext
.Setup(h => h.RequestServices.GetService(typeof(IActionSelector)))
.Returns(actionSelector);
httpContext
.Setup(h => h.RequestServices.GetService(typeof(IActionInvokerFactory)))
.Returns(invokerFactory);
httpContext
.Setup(h => h.RequestServices.GetService(typeof(ILoggerFactory)))
.Returns(loggerFactory);
httpContext
.Setup(h => h.RequestServices.GetService(typeof(MvcMarkerService)))
.Returns(new MvcMarkerService());
httpContext
.Setup(h => h.RequestServices.GetService(typeof(IOptions<MvcOptions>)))
.Returns(optionsAccessor);
httpContext
.Setup(h => h.RequestServices.GetService(typeof(DiagnosticSource)))
.Returns(diagnosticSource);
httpContext
.Setup(h => h.Features[typeof(IRoutingFeature)])
.Returns(routingFeature);
var routeContext = new RouteContext(httpContext.Object);
routingFeature.RouteData = routeContext.RouteData;
return routeContext;
}
/// <inheritdoc />
protected override Task OnRouteMatched(RouteContext context)
{
context.RouteData.Routers.Add(_target);
return(_target.RouteAsync(context));
}
public Task RouteAsync(RouteContext context)
{
context.Handler = _isHandled ? (RequestDelegate)((c) => Task.FromResult(0)) : null;
return(Task.FromResult <object>(null));
}
public Task RouteAsync(RouteContext context)
{
context.Handler = (c) => Task.FromResult(0);
return Task.FromResult(false);
}
private static DefaultRouter CreateDefaultRouter(RouteContext context, RequestCulture culture, IVirtualPathResolver virtualPathResolver)
{
var result = new Mock<IResolveResult>(MockBehavior.Strict);
result.SetupGet(x => x.Controller).Returns("Home");
result.SetupGet(x => x.Action).Returns("Index");
var routeResolver = new Mock<IRouteResolver>(MockBehavior.Strict);
routeResolver.Setup(x => x.Resolve(context, culture))
.ReturnsAsync(result.Object);
return new DefaultRouter(
CreateTarget(),
routeResolver.Object,
virtualPathResolver,
new RequestCulture("en"));
}
public Task RouteAsync(RouteContext context)
{
throw new NotImplementedException();
}
public Task RouteAsync(RouteContext context)
{
context.Handler = _requestDelegate;
return(Task.CompletedTask);
}
public IReadOnlyList<ActionDescriptor> SelectCandidates(RouteContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
var tree = _decisionTreeProvider.DecisionTree;
return tree.Select(context.RouteData.Values);
}
private IReadOnlyList<ActionSelectorCandidate> EvaluateActionConstraintsCore(
RouteContext context,
IReadOnlyList<ActionSelectorCandidate> candidates,
int? startingOrder)
{
// Find the next group of constraints to process. This will be the lowest value of
// order that is higher than startingOrder.
int? order = null;
// Perf: Avoid allocations
for (var i = 0; i < candidates.Count; i++)
{
var candidate = candidates[i];
if (candidate.Constraints != null)
{
for (var j = 0; j < candidate.Constraints.Count; j++)
{
var constraint = candidate.Constraints[j];
if ((startingOrder == null || constraint.Order > startingOrder) &&
(order == null || constraint.Order < order))
{
order = constraint.Order;
}
}
}
}
// If we don't find a 'next' then there's nothing left to do.
if (order == null)
{
return candidates;
}
// Since we have a constraint to process, bisect the set of actions into those with and without a
// constraint for the 'current order'.
var actionsWithConstraint = new List<ActionSelectorCandidate>();
var actionsWithoutConstraint = new List<ActionSelectorCandidate>();
var constraintContext = new ActionConstraintContext();
constraintContext.Candidates = candidates;
constraintContext.RouteContext = context;
// Perf: Avoid allocations
for (var i = 0; i < candidates.Count; i++)
{
var candidate = candidates[i];
var isMatch = true;
var foundMatchingConstraint = false;
if (candidate.Constraints != null)
{
constraintContext.CurrentCandidate = candidate;
for (var j = 0; j < candidate.Constraints.Count; j++)
{
var constraint = candidate.Constraints[j];
if (constraint.Order == order)
{
foundMatchingConstraint = true;
if (!constraint.Accept(constraintContext))
{
isMatch = false;
_logger.ConstraintMismatch(
candidate.Action.DisplayName,
candidate.Action.Id,
constraint);
break;
}
}
}
}
if (isMatch && foundMatchingConstraint)
{
actionsWithConstraint.Add(candidate);
}
else if (isMatch)
{
actionsWithoutConstraint.Add(candidate);
}
}
// If we have matches with constraints, those are 'better' so try to keep processing those
if (actionsWithConstraint.Count > 0)
{
var matches = EvaluateActionConstraintsCore(context, actionsWithConstraint, order);
if (matches?.Count > 0)
{
return matches;
}
}
// If the set of matches with constraints can't work, then process the set without constraints.
if (actionsWithoutConstraint.Count == 0)
{
return null;
}
else
{
return EvaluateActionConstraintsCore(context, actionsWithoutConstraint, order);
}
}
private IReadOnlyList<ActionDescriptor> EvaluateActionConstraints(
RouteContext context,
IReadOnlyList<ActionDescriptor> actions)
{
var candidates = new List<ActionSelectorCandidate>();
// Perf: Avoid allocations
for (var i = 0; i < actions.Count; i++)
{
var action = actions[i];
var constraints = _actionConstraintCache.GetActionConstraints(context.HttpContext, action);
candidates.Add(new ActionSelectorCandidate(action, constraints));
}
var matches = EvaluateActionConstraintsCore(context, candidates, startingOrder: null);
List<ActionDescriptor> results = null;
if (matches != null)
{
results = new List<ActionDescriptor>(matches.Count);
// Perf: Avoid allocations
for (var i = 0; i < matches.Count; i++)
{
var candidate = matches[i];
results.Add(candidate.Action);
}
}
return results;
}
public Task RouteAsync(RouteContext context)
{
return(Task.CompletedTask);
}
protected abstract Task OnRouteMatched(RouteContext context);
internal AshxRouteData Filter(Microsoft.AspNetCore.Routing.RouteContext context)
{
//AshxRouteData _routeData = new AshxRouteData(requestContext);, System.Text.Json.JsonSerializerOptions jsonOptions
//context.
return(new AshxRouteData(context, Options.JsonOptions));
}
