public void InvokingConstructorWithHomeControllerShouldReturnDefaultActionAndParameter()
{
var actionDescriptor = new ActionDescriptor("/Home");
Assert.AreEqual("Index", actionDescriptor.ActionName);
Assert.AreEqual(string.Empty, actionDescriptor.Parameter);
}
public IActionResult InvokeAction(Controller controller, ActionDescriptor actionDescriptor)
{
/*
* Child processes that use such C run-time functions as printf() and fprintf() can behave poorly when redirected.
* The C run-time functions maintain separate IO buffers. When redirected, these buffers might not be flushed immediately after each IO call.
* As a result, the output to the redirection pipe of a printf() call or the input from a getch() call is not flushed immediately and delays, sometimes-infinite delays occur.
* This problem is avoided if the child process flushes the IO buffers after each call to a C run-time IO function.
* Only the child process can flush its C run-time IO buffers. A process can flush its C run-time IO buffers by calling the fflush() function.
*/
var methodWithIntParameter = controller.GetType()
.GetMethods()
.FirstOrDefault(x => x.Name.ToLower() == actionDescriptor.ActionName.ToLower() &&
x.GetParameters().Length == 1 &&
x.GetParameters()[0].ParameterType == typeof(string) &&
x.ReturnType == typeof(IActionResult));
if (methodWithIntParameter == null)
{
throw new HttpNotFoundException(
string.Format(
"Expected method with signature IActionResult {0}(string) in class {1}Controller",
actionDescriptor.ActionName,
actionDescriptor.ControllerName));
}
try
{
var actionResult = (IActionResult)
methodWithIntParameter.Invoke(controller, new object[] { actionDescriptor.Parameter });
return actionResult;
}
catch (TargetInvocationException ex)
{
throw ex.InnerException;
}
}
public void Accept_RejectsActionMatchWithMissingParameter()
{
// Arrange
var action = new ActionDescriptor();
action.Parameters = new List<ParameterDescriptor>()
{
new ParameterDescriptor()
{
BindingInfo = new BindingInfo()
{
BindingSource = (new FromUriAttribute()).BindingSource,
},
Name = "id",
ParameterType = typeof(int),
},
};
var constraint = new OverloadActionConstraint();
var context = new ActionConstraintContext();
context.Candidates = new List<ActionSelectorCandidate>()
{
new ActionSelectorCandidate(action, new [] { constraint }),
};
context.CurrentCandidate = context.Candidates[0];
context.RouteContext = CreateRouteContext();
// Act & Assert
Assert.False(constraint.Accept(context));
}
/// <summary>
/// Creates a new <see cref="ActionContext"/>.
/// </summary>
/// <param name="httpContext">The <see cref="Http.HttpContext"/> for the current request.</param>
/// <param name="routeData">The <see cref="AspNet.Routing.RouteData"/> for the current request.</param>
/// <param name="actionDescriptor">The <see cref="Abstractions.ActionDescriptor"/> for the selected action.</param>
/// <param name="modelState">The <see cref="ModelStateDictionary"/>.</param>
public ActionContext(
HttpContext httpContext,
RouteData routeData,
ActionDescriptor actionDescriptor,
ModelStateDictionary modelState)
{
if (httpContext == null)
{
throw new ArgumentNullException(nameof(httpContext));
}
if (routeData == null)
{
throw new ArgumentNullException(nameof(routeData));
}
if (actionDescriptor == null)
{
throw new ArgumentNullException(nameof(actionDescriptor));
}
if (modelState == null)
{
throw new ArgumentNullException(nameof(modelState));
}
HttpContext = httpContext;
RouteData = routeData;
ActionDescriptor = actionDescriptor;
ModelState = modelState;
}
/// <summary>
/// Creates a new <see cref="ActionContext"/>.
/// </summary>
/// <param name="httpContext">The <see cref="Http.HttpContext"/> for the current request.</param>
/// <param name="routeData">The <see cref="AspNet.Routing.RouteData"/> for the current request.</param>
/// <param name="actionDescriptor">The <see cref="Abstractions.ActionDescriptor"/> for the selected action.</param>
public ActionContext(
HttpContext httpContext,
RouteData routeData,
ActionDescriptor actionDescriptor)
: this(httpContext, routeData, actionDescriptor, new ModelStateDictionary())
{
}
public IActionResult InvokeAction(Controller controller, ActionDescriptor actionDescriptor)
{
var methodWithIntParameter =
controller.GetType()
.GetMethods()
.FirstOrDefault(
x =>
x.Name.ToLower() == actionDescriptor.ActionName.ToLower() && x.GetParameters().Length == 1
&& x.GetParameters()[0].ParameterType == typeof(string)
&& x.ReturnType == typeof(IActionResult));
if (methodWithIntParameter == null)
{
throw new HttpNotFoundException(
string.Format(
"Expected method with signature IActionResult {0}(string) in class {1}",
actionDescriptor.ActionName,
actionDescriptor.ControllerName));
}
try
{
var actionResult =
(IActionResult)methodWithIntParameter.Invoke(controller, new object[] { actionDescriptor.Parameter });
return actionResult;
}
catch (TargetInvocationException ex)
{
throw ex.InnerException;
}
}
public void InvokingConstructorWithNormalUriShouldReturnProperlyControllerActionAndParameter()
{
var actionDescriptor = new ActionDescriptor("/Api/ResponseMessage/someParam123");
Assert.AreEqual("Api", actionDescriptor.ControllerName);
Assert.AreEqual("ResponseMessage", actionDescriptor.ActionName);
Assert.AreEqual("someParam123", actionDescriptor.Parameter);
}
protected override FilterInfo GetFilters(ControllerContext controllerContext, ActionDescriptor actionDescriptor)
{
var rubyType = ((RubyController) controllerContext.Controller).RubyType;
var controllerFilters = (Hash) RubyEngine.CallMethod(rubyType, "action_filters");
var info = controllerFilters.ToFilterInfo("controller").MergedWith(actionDescriptor.GetFilters());
return info;
}
protected ActionContext(ControllerContext context, ActionDescriptor action)
{
Precondition.Require(context, () => Error.ArgumentNull("context"));
Precondition.Require(action, () => Error.ArgumentNull("action"));
_action = action;
_context = context;
}
public IEnumerable<Filter> GetFilters(ControllerContext context, ActionDescriptor action)
{
Precondition.Require(context, () => Error.ArgumentNull("context"));
Precondition.Require(action, () => Error.ArgumentNull("action"));
if (context.Controller != null)
yield return new Filter(context.Controller, FilterScope.First, Int32.MinValue);
}
protected override System.Collections.Generic.IEnumerable<FilterAttribute> GetControllerAttributes(ControllerContext controllerContext, ActionDescriptor actionDescriptor)
{
var attributes = base.GetControllerAttributes(controllerContext, actionDescriptor);
foreach (var attribute in attributes)
{
_container.BuildUp(attribute);
}
return attributes;
}
public AuthenticationContext(ControllerContext controllerContext, ActionDescriptor actionDescriptor)
: base(controllerContext)
{
if (actionDescriptor == null)
{
throw new ArgumentNullException("actionDescriptor");
}
_actionDescriptor = actionDescriptor;
}
public ReflectedParameterDescriptor(ParameterInfo parameter, ActionDescriptor action)
: base()
{
Precondition.Require(parameter, () => Error.ArgumentNull("parameter"));
Precondition.Require(action, () => Error.ArgumentNull("action"));
_parameter = parameter;
_action = action;
_binding = new ReflectedParameterBinding(parameter);
}
protected override IEnumerable<FilterAttribute> GetActionAttributes(ControllerContext controllerContext, ActionDescriptor actionDescriptor)
{
var attributes = base.GetActionAttributes(controllerContext, actionDescriptor);
foreach (var attribute in attributes)
{
_container.BuildUp(attribute.GetType(), attribute);
}
return attributes;
}
public void OnBeforeAction(ActionDescriptor actionDescriptor, HttpContext httpContext, RouteData routeData)
{
string name = this.GetNameFromRouteContext(routeData);
var telemetry = httpContext.RequestServices.GetService<RequestTelemetry>();
if (!string.IsNullOrEmpty(name) && telemetry != null && telemetry is RequestTelemetry)
{
name = httpContext.Request.Method + " " + name;
((RequestTelemetry)telemetry).Name = name;
}
}
public HarvestableResourceDescriptor(ItemDefinition itmDef, ActionDescriptor action, int quantity)
{
if (itmDef == null)
throw new ArgumentNullException("itmDef");
if (action == null)
throw new ArgumentNullException("action");
harvestedItem = itmDef;
performedAction = action;
quantityPerHarvest = quantity;
}
/// <summary>Initializes a new instance of the <see cref="AuthenticationContext"/> class.</summary>
/// <param name="controllerContext">The controller context.</param>
/// <param name="actionDescriptor">The action descriptor.</param>
/// <param name="principal">The current principal.</param>
public AuthenticationContext(ControllerContext controllerContext, ActionDescriptor actionDescriptor,
IPrincipal principal)
: base(controllerContext)
{
if (actionDescriptor == null)
{
throw new ArgumentNullException("actionDescriptor");
}
ActionDescriptor = actionDescriptor;
Principal = principal;
}
/// <summary>
/// Executes binding action to context
/// </summary>
/// <param name="action"> </param>
/// <param name="context"> </param>
public void Bind(ActionDescriptor action, IMvcContext context) {
lock (this) {
if (null == _binders) {
Setup(action.ActionType);
}
if (_binders != null) {
foreach (var binder in _binders) {
binder.Bind(action.Action, context);
}
}
}
}
public void GetApiDescription_IgnoresNonReflectedActionDescriptor()
{
// Arrange
var action = new ActionDescriptor();
action.SetProperty(new ApiDescriptionActionData());
// Act
var descriptions = GetApiDescriptions(action);
// Assert
Assert.Empty(descriptions);
}
protected override FilterInfo GetFilters(
ControllerContext controllerContext,
ActionDescriptor actionDescriptor)
{
var filterInfo =
base.GetFilters(controllerContext,
actionDescriptor);
filterInfo.ExceptionFilters.Add(this.filter);
return filterInfo;
}
public void ActionDescriptor_ActionModel_Returns_Correct_Type()
{
//Arrange
var genDescriptorMock = GetMockDescriptor(typeof(CodeGeneratorSample).GetTypeInfo());
var actionDescriptor = new ActionDescriptor(genDescriptorMock.Object,
typeof(CodeGeneratorSample).GetMethod("GenerateCode"));
//Act
var actionModel = actionDescriptor.ActionModel;
//Assert
Assert.Equal(typeof(CodeGeneratorModel), actionModel);
}
public ActionExecutedContext(ControllerContext controllerContext, ActionDescriptor actionDescriptor, bool canceled,
Exception exception)
: base(controllerContext)
{
if (actionDescriptor == null)
{
throw new ArgumentNullException("actionDescriptor");
}
ActionDescriptor = actionDescriptor;
Canceled = canceled;
Exception = exception;
}
public override bool IsValidForRequest(RouteContext routeContext, ActionDescriptor action)
{
if (routeContext.RouteData.Values.ContainsKey(Name))
return false;
if (routeContext.RouteData.DataTokens.ContainsKey(Name))
return false;
if (routeContext.HttpContext.Request.Query.ContainsKey(Name))
return false;
return true;
}
public void EmptyResult_ExecuteResult_IsANoOp()
{
// Arrange
var emptyResult = new EmptyResult();
var httpContext = new Mock<HttpContext>(MockBehavior.Strict);
var routeData = new RouteData();
var actionDescriptor = new ActionDescriptor();
var context = new ActionContext(httpContext.Object, routeData, actionDescriptor);
// Act & Assert (does not throw)
emptyResult.ExecuteResult(context);
}
public virtual IEnumerable<Filter> GetFilters(ControllerContext context, ActionDescriptor action)
{
Precondition.Require(context, () => Error.ArgumentNull("context"));
Precondition.Require(action, () => Error.ArgumentNull("action"));
ControllerBase controller = context.Controller;
if (controller == null)
return Enumerable.Empty<Filter>();
return GetControllerAttributes(context, action)
.Select(attr => new Filter(attr, FilterScope.Controller, null))
.Concat(GetActionAttributes(context, action)
.Select(attr => new Filter(attr, FilterScope.Action, null)))
.ToList();
}
public void ActionDescriptor_Parameters_Returns_Parameters_Writeable_And_Of_Supported_Type()
{
//Arrange
var genDescriptorMock = GetMockDescriptor(typeof(CodeGeneratorSample).GetTypeInfo());
var actionDescriptor = new ActionDescriptor(genDescriptorMock.Object,
typeof(CodeGeneratorSample).GetMethod("GenerateCode"));
//Act
var parameters = actionDescriptor.Parameters;
//Assert
var propertyNames = parameters.Select(pd => pd.Property.Name);
var expectedProperties = new[] { "BoolProperty", "StringProperty" }.ToList();
Assert.Equal(expectedProperties, propertyNames, StringComparer.Ordinal);
}
public AuthenticationChallengeContext(ControllerContext controllerContext, ActionDescriptor actionDescriptor,
ActionResult result)
: base(controllerContext)
{
if (actionDescriptor == null)
{
throw new ArgumentNullException("actionDescriptor");
}
if (result == null)
{
throw new ArgumentNullException("result");
}
_actionDescriptor = actionDescriptor;
_result = result;
}
public void HttpStatusCodeResult_ExecuteResultSetsResponseStatusCode()
{
// Arrange
var result = new HttpStatusCodeResult(StatusCodes.Status404NotFound);
var httpContext = GetHttpContext();
var routeData = new RouteData();
var actionDescriptor = new ActionDescriptor();
var context = new ActionContext(httpContext, routeData, actionDescriptor);
// Act
result.ExecuteResult(context);
// Assert
Assert.Equal(StatusCodes.Status404NotFound, httpContext.Response.StatusCode);
}
public void CreateController_ThrowsIfActionDescriptorIsNotControllerActionDescriptor()
{
// Arrange
var expected = "The action descriptor must be of type 'Microsoft.AspNet.Mvc.ControllerActionDescriptor'." +
Environment.NewLine + "Parameter name: actionContext";
var actionDescriptor = new ActionDescriptor();
var controllerFactory = new DefaultControllerFactory(Mock.Of<IControllerActivator>());
var httpContext = new DefaultHttpContext();
var actionContext = new ActionContext(httpContext,
new RouteData(),
actionDescriptor);
// Act and Assert
var ex = Assert.Throws<ArgumentException>(() =>
controllerFactory.CreateController(actionContext));
Assert.Equal(expected, ex.Message);
Assert.Equal("actionContext", ex.ParamName);
}
private object PerformDataBindedExecution(ControllerExecutionContext executionCtx, ActionDescriptor descriptor)
{
var args = new List<object>();
foreach (var param in descriptor.Parameters.Values)
{
if (!param.DemandsCustomDataBinding)
{
DoDefaultDataBind(param, args, executionCtx);
}
else
{
DoCustomDataBind(param, args, executionCtx);
}
}
return descriptor.Action(executionCtx.Controller, args.ToArray());
}
protected override ActionResult InvokeActionMethod(ControllerContext controllerContext, ActionDescriptor actionDescriptor, IDictionary <string, object> parameters)
{
var allFilters = FiltersStore(controllerContext);
var calledFilters = CallStore(controllerContext);
var action = GlimpseFilterCallMetadata.ControllerAction(actionDescriptor, controllerContext.IsChildAction);
allFilters.Add(action);
calledFilters.Add(action.Guid);
var invokeActionMethod = base.InvokeActionMethod(controllerContext, actionDescriptor, parameters);
return(invokeActionMethod);
}
protected override AuthorizationContext InvokeAuthorizationFilters(ControllerContext controllerContext, IList <IAuthorizationFilter> filters, ActionDescriptor actionDescriptor)
{
var invokeAuthorizationFilters = base.InvokeAuthorizationFilters(controllerContext, filters, actionDescriptor);
return(invokeAuthorizationFilters);
}
protected override ActionExecutedContext InvokeActionMethodWithFilters(ControllerContext controllerContext, IList <IActionFilter> filters, ActionDescriptor actionDescriptor, IDictionary <string, object> parameters)
{
var invokeActionMethodWithFilters = base.InvokeActionMethodWithFilters(controllerContext, filters,
actionDescriptor, parameters);
return(invokeActionMethodWithFilters);
}
protected override ActionResult InvokeActionMethod(ControllerContext controllerContext, ActionDescriptor actionDescriptor, IDictionary <string, object> parameters)
{
var uowParam = actionDescriptor.GetParameters().FirstOrDefault(x => x.ParameterType == typeof(IUnitOfWork));
if (uowParam != null)
{
var connectionKey = controllerContext.Controller.GetType().GetCustomAttribute <ConnectionKeyAttribute>();
if (connectionKey == null)
{
throw new ArgumentNullException("connectionKey");
}
using (var connection = SqlConnections.NewByKey(connectionKey.Value))
using (var uow = new UnitOfWork(connection))
{
parameters[uowParam.ParameterName] = uow;
var result = base.InvokeActionMethod(controllerContext, actionDescriptor, parameters);
uow.Commit();
return(result);
}
}
var cnnParam = actionDescriptor.GetParameters().FirstOrDefault(x => x.ParameterType == typeof(IDbConnection));
if (cnnParam != null)
{
var connectionKey = controllerContext.Controller.GetType().GetCustomAttribute <ConnectionKeyAttribute>();
if (connectionKey == null)
{
throw new ArgumentNullException("connectionKey");
}
using (var cnn = SqlConnections.NewByKey(connectionKey.Value))
{
parameters[cnnParam.ParameterName] = cnn;
return(base.InvokeActionMethod(controllerContext, actionDescriptor, parameters));
}
}
return(base.InvokeActionMethod(controllerContext, actionDescriptor, parameters));
}
protected override FilterInfo GetFilters(ControllerContext controllerContext, ActionDescriptor actionDescriptor)
{
var info = base.GetFilters(controllerContext, actionDescriptor);
if (!info.ActionFilters.Any(x => x is JsonFilter))
{
info.ActionFilters.Add(new JsonFilter());
}
return(info);
}
protected override ActionResult CreateActionResult(ControllerContext controllerContext, ActionDescriptor actionDescriptor, object actionReturnValue)
{
if (!(actionReturnValue is ActionResult))
{
controllerContext.Controller.ViewData.Model = actionReturnValue;
return(new PocoActionResult(ServiceLocator, actionReturnValue));
}
return(base.CreateActionResult(controllerContext, actionDescriptor, actionReturnValue));
}
public BeforeViewComponent(ActionDescriptor actionDescriptor, ViewComponentContext viewComponentContext, object viewComponent)
{
ActionDescriptor = actionDescriptor;
ViewComponentContext = viewComponentContext;
ViewComponent = viewComponent;
}
public IEnumerable <Filter> GetFilters(ControllerContext controllerContext, ActionDescriptor actionDescriptor)
{
return(registeredFilters
.Where(e => e.IsValid(controllerContext, actionDescriptor))
.Select(e => new Filter(e, e.Scope, e.Order)));
}
private void AddActionDataToBuilder(
EndpointBuilder builder,
HashSet <string> routeNames,
ActionDescriptor action,
string routeName,
RouteValueDictionary dataTokens,
bool suppressLinkGeneration,
bool suppressPathMatching,
IReadOnlyList <Action <EndpointBuilder> > conventions,
IReadOnlyList <Action <EndpointBuilder> > perRouteConventions)
{
// Add action metadata first so it has a low precedence
if (action.EndpointMetadata != null)
{
foreach (var d in action.EndpointMetadata)
{
builder.Metadata.Add(d);
}
}
builder.Metadata.Add(action);
// MVC guarantees that when two of it's endpoints have the same route name they are equivalent.
//
// The case for this looks like:
//
// [HttpGet]
// [HttpPost]
// [Route("/Foo", Name = "Foo")]
// public void DoStuff() { }
//
// However, Endpoint Routing requires Endpoint Names to be unique.
//
// We can use the route name as the endpoint name if it's not set. Note that there's no
// attribute for this today so it's unlikley. Using endpoint name on a
if (routeName != null &&
!suppressLinkGeneration &&
routeNames.Add(routeName) &&
builder.Metadata.OfType <IEndpointNameMetadata>().LastOrDefault()?.EndpointName == null)
{
builder.Metadata.Add(new EndpointNameMetadata(routeName));
}
if (dataTokens != null)
{
builder.Metadata.Add(new DataTokensMetadata(dataTokens));
}
builder.Metadata.Add(new RouteNameMetadata(routeName));
// Add filter descriptors to endpoint metadata
if (action.FilterDescriptors != null && action.FilterDescriptors.Count > 0)
{
foreach (var filter in action.FilterDescriptors.OrderBy(f => f, FilterDescriptorOrderComparer.Comparer).Select(f => f.Filter))
{
builder.Metadata.Add(filter);
}
}
if (action.ActionConstraints != null && action.ActionConstraints.Count > 0)
{
// We explicitly convert a few types of action constraints into MatcherPolicy+Metadata
// to better integrate with the DFA matcher.
//
// Other IActionConstraint data will trigger a back-compat path that can execute
// action constraints.
foreach (var actionConstraint in action.ActionConstraints)
{
if (actionConstraint is HttpMethodActionConstraint httpMethodActionConstraint &&
!builder.Metadata.OfType <HttpMethodMetadata>().Any())
{
builder.Metadata.Add(new HttpMethodMetadata(httpMethodActionConstraint.HttpMethods));
}
else if (actionConstraint is ConsumesAttribute consumesAttribute &&
!builder.Metadata.OfType <ConsumesMetadata>().Any())
{
builder.Metadata.Add(new ConsumesMetadata(consumesAttribute.ContentTypes.ToArray()));
}
/// <inheritdoc />
protected override IEnumerable <FilterAttribute> GetControllerAttributes(ControllerContext controllerContext, ActionDescriptor actionDescriptor)
{
var attributes = base.GetControllerAttributes(controllerContext, actionDescriptor).ToArray();
foreach (var filterAttribute in attributes)
{
this.dependencyResolver.BuildUp(filterAttribute);
}
return(attributes);
}
protected override ActionResult CreateActionResult(ControllerContext controllerContext, ActionDescriptor actionDescriptor, object actionReturnValue)
{
var actionResult = base.CreateActionResult(controllerContext, actionDescriptor, actionReturnValue);
return(actionResult);
}
public IEnumerable <Filter> GetFilters(ControllerContext controllerContext, ActionDescriptor actionDescriptor)
{
return(fluentMvcResolver.GetFilters(controllerContext, actionDescriptor, actionDescriptor.ControllerDescriptor));
}
public override IEnumerable <Filter> GetFilters(ControllerContext controllerContext, ActionDescriptor actionDescriptor)
{
var filters = base.GetFilters(controllerContext, actionDescriptor);
foreach (var filter in filters)
{
_container.BuildUp(filter.Instance);
yield return(filter);
}
}
public static MethodInfo GetMethodInfo(this ActionDescriptor actionDescriptor)
{
return(actionDescriptor.AsControllerActionDescriptor().MethodInfo);
}
protected override IDictionary <string, object> GetParameterValues(ControllerContext controllerContext, ActionDescriptor actionDescriptor)
{
var parameterValues = base.GetParameterValues(controllerContext, actionDescriptor);
return(parameterValues);
}
protected override ActionResult CreateActionResult(ControllerContext controllerContext, ActionDescriptor actionDescriptor, object actionReturnValue)
{
return((actionReturnValue as ActionResult) ?? new Result <object>(actionReturnValue));
}
protected override IEnumerable <FilterAttribute> GetActionAttributes(ControllerContext controllerContext, ActionDescriptor actionDescriptor)
{
var attributes = base.GetActionAttributes(controllerContext, actionDescriptor).ToList();
foreach (var attribute in attributes)
{
_container.BuildUp(attribute.GetType(), attribute);
}
return(attributes);
}
protected virtual bool IsRemoteService(ActionDescriptor actionDescriptor)
{
var remoteServiceAttr = ReflectionHelper.GetSingleAttributeOfMemberOrDeclaringTypeOrDefault <RemoteServiceAttribute>(actionDescriptor.GetMethodInfo());
return(remoteServiceAttr != null && remoteServiceAttr.IsEnabled);
}
public bool JoinsTo(ControllerContext controllerContext, ActionDescriptor actionDescriptor)
{
return(controllerContext.HttpContext.Request["outputType"] != null);
}
/// <summary>
/// Aggregates the filters from all of the filter providers into one collection.
/// </summary>
/// <returns>
/// The collection filters from all of the filter providers.
/// </returns>
/// <param name="controllerContext">The controller context.</param>
/// <param name="actionDescriptor">The action descriptor.</param>
public override IEnumerable <Filter> GetFilters(ControllerContext controllerContext, ActionDescriptor actionDescriptor)
{
var filters = base.GetFilters(controllerContext, actionDescriptor).ToArray();
foreach (var filter in filters)
{
serviceContainer.InjectProperties(filter.Instance);
}
return(filters);
}
public void AddEndpoints(
List <Endpoint> endpoints,
HashSet <string> routeNames,
ActionDescriptor action,
IReadOnlyList <ConventionalRouteEntry> routes,
IReadOnlyList <Action <EndpointBuilder> > conventions,
bool createInertEndpoints)
{
if (endpoints == null)
{
throw new ArgumentNullException(nameof(endpoints));
}
if (routeNames == null)
{
throw new ArgumentNullException(nameof(routeNames));
}
if (action == null)
{
throw new ArgumentNullException(nameof(action));
}
if (routes == null)
{
throw new ArgumentNullException(nameof(routes));
}
if (conventions == null)
{
throw new ArgumentNullException(nameof(conventions));
}
if (createInertEndpoints)
{
var builder = new InertEndpointBuilder()
{
DisplayName = action.DisplayName,
RequestDelegate = _requestDelegate,
};
AddActionDataToBuilder(
builder,
routeNames,
action,
routeName: null,
dataTokens: null,
suppressLinkGeneration: false,
suppressPathMatching: false,
conventions,
Array.Empty <Action <EndpointBuilder> >());
endpoints.Add(builder.Build());
}
if (action.AttributeRouteInfo == null)
{
// Check each of the conventional patterns to see if the action would be reachable.
// If the action and pattern are compatible then create an endpoint with action
// route values on the pattern.
foreach (var route in routes)
{
// A route is applicable if:
// 1. It has a parameter (or default value) for 'required' non-null route value
// 2. It does not have a parameter (or default value) for 'required' null route value
var updatedRoutePattern = _routePatternTransformer.SubstituteRequiredValues(route.Pattern, action.RouteValues);
if (updatedRoutePattern == null)
{
continue;
}
// We suppress link generation for each conventionally routed endpoint. We generate a single endpoint per-route
// to handle link generation.
var builder = new RouteEndpointBuilder(_requestDelegate, updatedRoutePattern, route.Order)
{
DisplayName = action.DisplayName,
};
AddActionDataToBuilder(
builder,
routeNames,
action,
route.RouteName,
route.DataTokens,
suppressLinkGeneration: true,
suppressPathMatching: false,
conventions,
route.Conventions);
endpoints.Add(builder.Build());
}
}
else
{
var attributeRoutePattern = RoutePatternFactory.Parse(action.AttributeRouteInfo.Template);
// Modify the route and required values to ensure required values can be successfully subsituted.
// Subsitituting required values into an attribute route pattern should always succeed.
var(resolvedRoutePattern, resolvedRouteValues) = ResolveDefaultsAndRequiredValues(action, attributeRoutePattern);
var updatedRoutePattern = _routePatternTransformer.SubstituteRequiredValues(resolvedRoutePattern, resolvedRouteValues);
if (updatedRoutePattern == null)
{
// This kind of thing can happen when a route pattern uses a *reserved* route value such as `action`.
// See: https://github.com/aspnet/AspNetCore/issues/14789
var formattedRouteKeys = string.Join(", ", resolvedRouteValues.Keys.Select(k => $"'{k}'"));
throw new InvalidOperationException(
$"Failed to update the route pattern '{resolvedRoutePattern.RawText}' with required route values. " +
$"This can occur when the route pattern contains parameters with reserved names such as: {formattedRouteKeys} " +
$"and also uses route constraints such as '{{action:int}}'. " +
$"To fix this error, choose a different parmaeter name.");
}
var builder = new RouteEndpointBuilder(_requestDelegate, updatedRoutePattern, action.AttributeRouteInfo.Order)
{
DisplayName = action.DisplayName,
};
AddActionDataToBuilder(
builder,
routeNames,
action,
action.AttributeRouteInfo.Name,
dataTokens: null,
action.AttributeRouteInfo.SuppressLinkGeneration,
action.AttributeRouteInfo.SuppressPathMatching,
conventions,
perRouteConventions: Array.Empty <Action <EndpointBuilder> >());
endpoints.Add(builder.Build());
}
}
/// <summary>
/// Performs the query composition after action is executed. It first tries to retrieve the IQueryable from the
/// returning response message. It then validates the query from uri based on the validation settings on
/// <see cref="EnableQueryAttribute"/>. It finally applies the query appropriately, and reset it back on
/// the response message.
/// </summary>
/// <param name="actionExecutedContext">The context related to this action, including the response message,
/// request message and HttpConfiguration etc.</param>
public override void OnActionExecuted(ActionExecutedContext actionExecutedContext)
{
if (actionExecutedContext == null)
{
throw Error.ArgumentNull("actionExecutedContext");
}
HttpRequest request = actionExecutedContext.HttpContext.Request;
if (request == null)
{
throw Error.Argument("actionExecutedContext", SRResources.ActionExecutedContextMustHaveRequest);
}
ActionDescriptor actionDescriptor = actionExecutedContext.ActionDescriptor;
if (actionDescriptor == null)
{
throw Error.Argument("actionExecutedContext", SRResources.ActionContextMustHaveDescriptor);
}
HttpResponse response = actionExecutedContext.HttpContext.Response;
// Check is the response is set and successful.
if (response != null && IsSuccessStatusCode(response.StatusCode) && actionExecutedContext.Result != null)
{
// actionExecutedContext.Result might also indicate a status code that has not yet
// been applied to the result; make sure it's also successful.
StatusCodeResult statusCodeResult = actionExecutedContext.Result as StatusCodeResult;
if (statusCodeResult == null || IsSuccessStatusCode(statusCodeResult.StatusCode))
{
ObjectResult responseContent = actionExecutedContext.Result as ObjectResult;
if (responseContent != null)
{
//throw Error.Argument("actionExecutedContext", SRResources.QueryingRequiresObjectContent,
// actionExecutedContext.Result.GetType().FullName);
// Get collection from SingleResult.
IQueryable singleResultCollection = null;
SingleResult singleResult = responseContent.Value as SingleResult;
if (singleResult != null)
{
// This could be a SingleResult, which has the property Queryable.
// But it could be a SingleResult() or SingleResult<T>. Sort by number of parameters
// on the property and get the one with the most parameters.
PropertyInfo propInfo = responseContent.Value.GetType().GetProperties()
.OrderBy(p => p.GetIndexParameters().Count())
.Where(p => p.Name.Equals("Queryable"))
.LastOrDefault();
singleResultCollection = propInfo.GetValue(singleResult) as IQueryable;
}
// Execution the action.
object queryResult = OnActionExecuted(
responseContent.Value,
singleResultCollection,
new WebApiActionDescriptor(actionDescriptor as ControllerActionDescriptor),
new WebApiRequestMessage(request),
(elementClrType) => GetModel(elementClrType, request, actionDescriptor),
(queryContext) => CreateAndValidateQueryOptions(request, queryContext),
(statusCode) => actionExecutedContext.Result = new StatusCodeResult((int)statusCode),
(statusCode, message, exception) => actionExecutedContext.Result = CreateBadRequestResult(message, exception));
if (queryResult != null)
{
responseContent.Value = queryResult;
}
}
}
}
}
private static (RoutePattern resolvedRoutePattern, IDictionary <string, string> resolvedRequiredValues) ResolveDefaultsAndRequiredValues(ActionDescriptor action, RoutePattern attributeRoutePattern)
{
RouteValueDictionary updatedDefaults = null;
IDictionary <string, string> resolvedRequiredValues = null;
foreach (var routeValue in action.RouteValues)
{
var parameter = attributeRoutePattern.GetParameter(routeValue.Key);
if (!RouteValueEqualityComparer.Default.Equals(routeValue.Value, string.Empty))
{
if (parameter == null)
{
// The attribute route has a required value with no matching parameter
// Add the required values without a parameter as a default
// e.g.
// Template: "Login/{action}"
// Required values: { controller = "Login", action = "Index" }
// Updated defaults: { controller = "Login" }
if (updatedDefaults == null)
{
updatedDefaults = new RouteValueDictionary(attributeRoutePattern.Defaults);
}
updatedDefaults[routeValue.Key] = routeValue.Value;
}
}
else
{
if (parameter != null)
{
// The attribute route has a null or empty required value with a matching parameter
// Remove the required value from the route
if (resolvedRequiredValues == null)
{
resolvedRequiredValues = new Dictionary <string, string>(action.RouteValues);
}
resolvedRequiredValues.Remove(parameter.Name);
}
}
}
if (updatedDefaults != null)
{
attributeRoutePattern = RoutePatternFactory.Parse(action.AttributeRouteInfo.Template, updatedDefaults, parameterPolicies: null);
}
return(attributeRoutePattern, resolvedRequiredValues ?? action.RouteValues);
}
protected override FilterInfo GetFilters(ControllerContext controllerContext, ActionDescriptor actionDescriptor)
{
var filters = base.GetFilters(controllerContext, actionDescriptor);
foreach (var filter in filters.AuthorizationFilters.Cast <object>()
.Concat(filters.ActionFilters.Cast <object>())
.Concat(filters.ExceptionFilters.Cast <object>())
.Concat(filters.ResultFilters.Cast <object>()))
{
var filterType = filter.GetType();
if (typeof(IRequiresRoutableRequestContext).IsAssignableFrom(filterType))
{
((IRequiresRoutableRequestContext)filter).RoutableRequestContext = RoutableRequestContext;
}
}
return(filters);
}
private static bool ValidationDisabled(ActionDescriptor actionDescriptor)
{
return(actionDescriptor.GetCustomAttributes(typeof(SkipAjaxValidation), false).Cast <SkipAjaxValidation>().Any());
}
public static ApiVersionModel GetApiVersion(this ActionDescriptor actionDescriptor)
{
return(actionDescriptor?.Properties
.Where(kvp => (Type)kvp.Key == typeof(ApiVersionModel))
.Select(kvp => kvp.Value as ApiVersionModel).FirstOrDefault());
}
private bool MustActionBeWrapped(ActionDescriptor descriptor)
{
return(null != descriptor.Parameters
.Select(param => param.ParameterType)
.FirstOrDefault(IsCommand));
}
protected override FilterInfo GetFilters(ControllerContext controllerContext, ActionDescriptor actionDescriptor)
{
var allFilters = FiltersStore(controllerContext);
FieldInfo dynField = typeof(ControllerActionInvoker).GetField("_getFiltersThunk", BindingFlags.NonPublic | BindingFlags.Instance);
var filters = dynField.GetValue(this) as Func <ControllerContext, ActionDescriptor, IEnumerable <Filter> >;
var filtersEnum = filters(controllerContext, actionDescriptor);
var filterInfo = base.GetFilters(controllerContext, actionDescriptor);
var isChild = controllerContext.IsChildAction;
var actionFilters = filterInfo.ActionFilters;
for (int i = 0; i < actionFilters.Count; i++)
{
if (!(actionFilters[i] is GlimpseActionFilter))
{
//Wrap it for call logging
var innerFilter = filtersEnum.Where(f => f.Instance == actionFilters[i]).SingleOrDefault();
var newFilter = new GlimpseActionFilter(actionFilters[i])
{
Filter = innerFilter,
OnActionExecutedGuid = Guid.NewGuid(),
OnActionExecutingGuid = Guid.NewGuid()
};
actionFilters[i] = newFilter;
//Store metadata for later analysis
allFilters.Add(new GlimpseFilterCallMetadata("Action", newFilter.OnActionExecutedGuid, "OnActionExecuted()", innerFilter, isChild));
allFilters.Add(new GlimpseFilterCallMetadata("Action", newFilter.OnActionExecutingGuid, "OnActionExecuting()", innerFilter, isChild));
}
}
var authorizationFilters = filterInfo.AuthorizationFilters;
for (int i = 0; i < authorizationFilters.Count; i++)
{
if (!(authorizationFilters[i] is GlimpseAuthorizationFilter))
{
var innerFilter = filtersEnum.Where(f => f.Instance == authorizationFilters[i]).SingleOrDefault();
var newFilter = new GlimpseAuthorizationFilter(authorizationFilters[i])
{
Filter = innerFilter,
Guid = Guid.NewGuid()
};
authorizationFilters[i] = newFilter;
allFilters.Add(new GlimpseFilterCallMetadata("Authorization", newFilter.Guid, "OnAuthorization()", innerFilter, isChild));
}
}
var exceptionFilters = filterInfo.ExceptionFilters;
for (int i = 0; i < exceptionFilters.Count; i++)
{
if (!(exceptionFilters[i] is GlimpseExceptionFilter))
{
var innerFilter = filtersEnum.Where(f => f.Instance == exceptionFilters[i]).SingleOrDefault();
var newFilter = new GlimpseExceptionFilter(exceptionFilters[i])
{
Filter = innerFilter,
Guid = Guid.NewGuid()
};
exceptionFilters[i] = newFilter;
allFilters.Add(new GlimpseFilterCallMetadata("Exception", newFilter.Guid, "OnException()", innerFilter, isChild));
}
}
var resultFilters = filterInfo.ResultFilters;
for (int i = 0; i < resultFilters.Count; i++)
{
if (!(resultFilters[i] is GlimpseResultFilter))
{
var innerFilter = filtersEnum.Where(f => f.Instance == resultFilters[i]).SingleOrDefault();
var newFilter = new GlimpseResultFilter(resultFilters[i])
{
Filter = innerFilter,
OnResultExecutedGuid = Guid.NewGuid(),
OnResultExecutingGuid = Guid.NewGuid()
};
resultFilters[i] = newFilter;
allFilters.Add(new GlimpseFilterCallMetadata("Result", newFilter.OnResultExecutedGuid, "OnResultExecuted()", innerFilter, isChild));
allFilters.Add(new GlimpseFilterCallMetadata("Result", newFilter.OnResultExecutingGuid, "OnResultExecuting()", innerFilter, isChild));
}
}
return(filterInfo);
}
public IEnumerable <Filter> GetFilters(ControllerContext controllerContext, ActionDescriptor actionDescriptor)
{
return(registeredFilters.Select(m => m.Invoke(controllerContext, actionDescriptor)).Where(m => m != null));
}
public static bool IsControllerAction(this ActionDescriptor actionDescriptor)
{
return(actionDescriptor is ControllerActionDescriptor);
}
