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