private static void AddActionConstraints(
ReflectedActionDescriptor actionDescriptor,
ReflectedActionModel action,
ReflectedControllerModel controller)
{
var httpMethods = action.HttpMethods;
if (httpMethods != null && httpMethods.Count > 0)
{
actionDescriptor.MethodConstraints = new List <HttpMethodConstraint>()
{
new HttpMethodConstraint(httpMethods)
};
}
actionDescriptor.RouteConstraints.Add(new RouteDataActionConstraint(
"controller",
controller.ControllerName));
if (action.IsActionNameMatchRequired)
{
actionDescriptor.RouteConstraints.Add(new RouteDataActionConstraint(
"action",
action.ActionName));
}
else
{
actionDescriptor.RouteConstraints.Add(new RouteDataActionConstraint(
"action",
RouteKeyHandling.DenyKey));
}
}
public void ReflectedActionModel_PopulatesFilters()
{
// Arrange
var actionMethod = typeof(BlogController).GetMethod("Edit");
// Act
var model = new ReflectedActionModel(actionMethod);
// Assert
Assert.Single(model.Filters);
Assert.IsType <MyFilterAttribute>(model.Filters[0]);
}
public void ReflectedActionModel_PopulatesFilters()
{
// Arrange
var actionMethod = typeof(BlogController).GetMethod("Edit");
// Act
var model = new ReflectedActionModel(actionMethod);
// Assert
Assert.Single(model.Filters);
Assert.IsType<MyFilterAttribute>(model.Filters[0]);
}
private static ReflectedActionDescriptor CreateActionDescriptor(
ReflectedActionModel action,
ReflectedAttributeRouteModel controllerAttributeRoute,
ControllerDescriptor controllerDescriptor)
{
var parameterDescriptors = new List <ParameterDescriptor>();
foreach (var parameter in action.Parameters)
{
var isFromBody = parameter.Attributes.OfType <FromBodyAttribute>().Any();
var paramDescriptor = new ParameterDescriptor()
{
Name = parameter.ParameterName,
IsOptional = parameter.IsOptional
};
if (isFromBody)
{
paramDescriptor.BodyParameterInfo = new BodyParameterInfo(
parameter.ParameterInfo.ParameterType);
}
else
{
paramDescriptor.ParameterBindingInfo = new ParameterBindingInfo(
parameter.ParameterName,
parameter.ParameterInfo.ParameterType);
}
parameterDescriptors.Add(paramDescriptor);
}
var attributeRouteInfo = CreateAttributeRouteInfo(
action.AttributeRouteModel,
controllerAttributeRoute);
var actionDescriptor = new ReflectedActionDescriptor()
{
Name = action.ActionName,
ControllerDescriptor = controllerDescriptor,
MethodInfo = action.ActionMethod,
Parameters = parameterDescriptors,
RouteConstraints = new List <RouteDataActionConstraint>(),
AttributeRouteInfo = attributeRouteInfo
};
actionDescriptor.DisplayName = string.Format(
"{0}.{1}",
action.ActionMethod.DeclaringType.FullName,
action.ActionMethod.Name);
return(actionDescriptor);
}
public void ReflectedActionModel_PopulatesAttributes()
{
// Arrange
var actionMethod = typeof(BlogController).GetMethod("Edit");
// Act
var model = new ReflectedActionModel(actionMethod);
// Assert
Assert.Equal(2, model.Attributes.Count);
Assert.Single(model.Attributes, a => a is MyFilterAttribute);
Assert.Single(model.Attributes, a => a is MyOtherAttribute);
}
public void ReflectedActionModel_PopulatesAttributes()
{
// Arrange
var actionMethod = typeof(BlogController).GetMethod("Edit");
// Act
var model = new ReflectedActionModel(actionMethod);
// Assert
Assert.Equal(2, model.Attributes.Count);
Assert.Single(model.Attributes, a => a is MyFilterAttribute);
Assert.Single(model.Attributes, a => a is MyOtherAttribute);
}
public ReflectedApplicationModel BuildModel()
{
var applicationModel = new ReflectedApplicationModel();
applicationModel.Filters.AddRange(_globalFilters);
var assemblies = _controllerAssemblyProvider.CandidateAssemblies;
var types = assemblies.SelectMany(a => a.DefinedTypes);
var controllerTypes = types.Where(_conventions.IsController);
foreach (var controllerType in controllerTypes)
{
var controllerModel = new ReflectedControllerModel(controllerType);
applicationModel.Controllers.Add(controllerModel);
foreach (var methodInfo in controllerType.AsType().GetMethods())
{
var actionInfos = _conventions.GetActions(methodInfo, controllerType);
if (actionInfos == null)
{
continue;
}
foreach (var actionInfo in actionInfos)
{
var actionModel = new ReflectedActionModel(methodInfo);
actionModel.ActionName = actionInfo.ActionName;
actionModel.IsActionNameMatchRequired = actionInfo.RequireActionNameMatch;
actionModel.HttpMethods.AddRange(actionInfo.HttpMethods ?? Enumerable.Empty <string>());
if (actionInfo.AttributeRoute != null)
{
actionModel.AttributeRouteModel = new ReflectedAttributeRouteModel(
actionInfo.AttributeRoute);
}
foreach (var parameter in methodInfo.GetParameters())
{
actionModel.Parameters.Add(new ReflectedParameterModel(parameter));
}
controllerModel.Actions.Add(actionModel);
}
}
}
return(applicationModel);
}
private static void ValidateActionHttpMethodProviders(
ReflectedActionModel reflectedAction,
IDictionary <ReflectedActionModel, IEnumerable <string> > invalidHttpMethodActions)
{
var invalidHttpMethodProviderAttributes = reflectedAction.Attributes
.Where(attr => attr is IActionHttpMethodProvider &&
!(attr is IRouteTemplateProvider))
.Select(attr => attr.GetType().FullName);
if (invalidHttpMethodProviderAttributes.Any())
{
invalidHttpMethodActions.Add(
reflectedAction,
invalidHttpMethodProviderAttributes);
}
}
public void AddToMethodInfo(ReflectedActionModel action,
IList <ReflectedActionDescriptor> actionDescriptors)
{
IDictionary <ReflectedActionModel, IList <ReflectedActionDescriptor> > actionsForMethod = null;
if (TryGetValue(action.ActionMethod, out actionsForMethod))
{
actionsForMethod.Add(action, actionDescriptors);
}
else
{
var reflectedActionMap =
new Dictionary <ReflectedActionModel, IList <ReflectedActionDescriptor> >();
reflectedActionMap.Add(action, actionDescriptors);
Add(action.ActionMethod, reflectedActionMap);
}
}
private static IList <ReflectedActionDescriptor> CreateActionDescriptors(
ReflectedActionModel action,
ReflectedControllerModel controller,
ControllerDescriptor controllerDescriptor)
{
var actionDescriptors = new List <ReflectedActionDescriptor>();
// We check the action to see if the template allows combination behavior
// (It doesn't start with / or ~/) so that in the case where we have multiple
// [Route] attributes on the controller we don't end up creating multiple
// attribute identical attribute routes.
if (controller.AttributeRoutes != null &&
controller.AttributeRoutes.Count > 0 &&
(action.AttributeRouteModel == null ||
!action.AttributeRouteModel.IsAbsoluteTemplate))
{
foreach (var controllerAttributeRoute in controller.AttributeRoutes)
{
var actionDescriptor = CreateActionDescriptor(
action,
controllerAttributeRoute,
controllerDescriptor);
actionDescriptors.Add(actionDescriptor);
}
}
else
{
actionDescriptors.Add(CreateActionDescriptor(
action,
controllerAttributeRoute: null,
controllerDescriptor: controllerDescriptor));
}
return(actionDescriptors);
}
