public virtual ActionDescriptor FindAction(ControllerContext controllerContext,
ControllerDescriptor controllerDescriptor, string actionName)
{
// Todo we may want convention here.
//if (controllerContext.HttpContext.Request.HttpMethod != Verbs.Post)
//{
// return null;
//}
var controllerName = controllerContext.RouteData.Values["controller"].ToString().ToLowerInvariant();
var service = _Registry.GetService(controllerName);
if (service == null)
{
return null;
}
var commandAction = service.FindAction(actionName);
if (commandAction == null || !commandAction.IsCommand())
{
return null;
}
var commandDescriptor = _Locator.GetInstance<ReflectedCommand>();
commandDescriptor.SetActionName(actionName);
commandDescriptor.SetControllerDescriptor(controllerDescriptor);
commandDescriptor.SetAction(commandAction);
return commandDescriptor;
}
protected virtual InferredAction GetInferredAction(ControllerDescriptor controllerDescriptor, string actionName) {
return InferredActions.Current
.Where(inferred => inferred.Controller == controllerDescriptor.ControllerType)
.Where( inferred =>
string.Equals(inferred.ActionName, actionName, StringComparison.CurrentCultureIgnoreCase))
.FirstOrDefault();
}
/// <summary>
/// Конструктор, сохраняет нужные данные
/// </summary>
/// <param name="methodInfo">данные о вызываемом action'е</param>
/// <param name="actionName">имя action'а</param>
/// <param name="controllerDescriptor">дескриптор контроллера</param>
public TaskAsyncActionDescriptor(
MethodInfo methodInfo, string actionName, ControllerDescriptor controllerDescriptor)
{
_methodInfo = methodInfo;
_actionName = actionName;
_controllerDescriptor = controllerDescriptor;
}
protected override ActionDescriptor FindAction(
ControllerContext controllerContext,
ControllerDescriptor controllerDescriptor,
string actionName)
{
var action = base.FindAction(controllerContext, controllerDescriptor, actionName);
if (action != null)
{
return action;
}
if (typeof(CqrsController).IsAssignableFrom(controllerDescriptor.ControllerType))
{
//TODO: cache command types?
var messagesAssembly = Assembly.Load(new AssemblyName("ECom.Messages"));
var commandTypes = messagesAssembly.GetTypes()
.Where(t => typeof(ICommand).IsAssignableFrom(t))
.Select(t => new { Name = t.Name, Type = t });
var command = commandTypes.FirstOrDefault(c => c.Name.Equals(actionName, StringComparison.InvariantCultureIgnoreCase));
if (command != null)//we have a command action but the action itself is not declared
{
//fallback to cqrs controller generic command action
var actionInfo = controllerDescriptor.ControllerType.GetMethod("SubmitCommand").MakeGenericMethod(command.Type);
if (actionInfo != null)
{
return new ReflectedActionDescriptor(actionInfo, actionName, controllerDescriptor);
}
}
}
return null;
}
protected override ActionDescriptor FindAction(ControllerContext controllerContext, ControllerDescriptor controllerDescriptor, string actionName)
{
var method = controllerContext.HttpContext.Request.HttpMethod;
var actionDescriptor = controllerDescriptor.FindAction(controllerContext, method);
return actionDescriptor;
}
/// <summary>
/// Gets the action descriptor and caches it
/// </summary>
/// <param name="controllerContext"></param>
/// <param name="controllerDescriptor"></param>
/// <param name="actionName"></param>
/// <returns></returns>
protected ReflectedActionDescriptor GetActionDescriptor(ControllerContext controllerContext, ControllerDescriptor controllerDescriptor, string actionName)
{
var found = _descriptorCache.GetOrAdd(
controllerDescriptor.UniqueId,
s => new ReflectedActionDescriptor(
controllerContext.Controller.GetType().GetMethods()
.First(x => x.Name == actionName &&
x.GetCustomAttributes(typeof(NonActionAttribute), false).Any() == false),
actionName,
controllerDescriptor));
//check if the action name matches, it won't if the user has changed the action name in umbraco, if this occurs we need to refresh the cache
if (!found.ActionName.InvariantEquals(actionName))
{
var newDescriptor = new ReflectedActionDescriptor(
controllerContext.Controller.GetType().GetMethods()
.First(x => x.Name == actionName &&
x.GetCustomAttributes(typeof (NonActionAttribute), false).Any() == false),
actionName,
controllerDescriptor);
_descriptorCache.TryUpdate(controllerDescriptor.UniqueId, newDescriptor, found);
found = newDescriptor;
}
return found;
}
protected override ActionDescriptor FindAction(ControllerContext controllerContext, ControllerDescriptor controllerDescriptor, string actionName)
{
var ad = base.FindAction(controllerContext, controllerDescriptor, actionName);
//now we need to check if it exists, if not we need to return the Index by default
if (ad == null)
{
if (controllerContext.RouteData.DataTokens.ContainsKey("__virtualnodefinder__"))
{
var virtualNode = controllerContext.RouteData.DataTokens["__virtualnodefinder__"] as IPublishedContent;
if (virtualNode != null)
{
var action = controllerContext.RouteData.GetRequiredString("action");
var categoryUrl = virtualNode.GetPropertyValue<string>("categoriesUrlName");
if (action.InvariantEquals(categoryUrl))
{
return GetActionDescriptor(controllerContext, controllerDescriptor, "Categories");
}
var tagsUrl = virtualNode.GetPropertyValue<string>("tagsUrlName");
if (action.InvariantEquals(tagsUrl))
{
return GetActionDescriptor(controllerContext, controllerDescriptor, "Tags");
}
}
}
}
return ad;
}
internal ReflectedActionDescriptor(MethodInfo methodInfo, string actionName, ControllerDescriptor controllerDescriptor, bool validateMethod)
{
if (methodInfo == null)
{
throw new ArgumentNullException("methodInfo");
}
if (String.IsNullOrEmpty(actionName))
{
throw new ArgumentException(MvcResources.Common_NullOrEmpty, "actionName");
}
if (controllerDescriptor == null)
{
throw new ArgumentNullException("controllerDescriptor");
}
if (validateMethod)
{
string failedMessage = VerifyActionMethodIsCallable(methodInfo);
if (failedMessage != null)
{
throw new ArgumentException(failedMessage, "methodInfo");
}
}
MethodInfo = methodInfo;
_actionName = actionName;
_controllerDescriptor = controllerDescriptor;
}
public string GetControllerDetails(ControllerDescriptor controllerDescriptor, RequestContext requestContext)
{
var template = new ControllerDetails
{
Model = GetControllerModel(controllerDescriptor, requestContext)
};
return template.TransformText();
}
protected RegistrySelector(ActionDescriptor actionDescriptor, ControllerDescriptor controllerDescriptor, ControllerContext controllerContext)
{
ActionDescriptor = actionDescriptor;
ControllerDescriptor = controllerDescriptor;
ControllerContext = controllerContext;
if (ControllerContextIsValid()) RegisterControllerRequestData(ControllerContext.HttpContext.Request);
if (ControllerRouteDataIsValid()) RegisterControllerRouteData(ControllerContext.RouteData);
}
public virtual ILookup<string, ApiActionDescriptor> GetActionMapping(ControllerDescriptor controllerDescriptor)
{
if (controllerDescriptor == null)
{
throw Error.ArgumentNull("controllerDescriptor");
}
//return this.GetInternalSelector(controllerDescriptor).GetActionMapping();
throw new NotImplementedException();
}
protected override ActionDescriptor FindAction(ControllerContext controllerContext, ControllerDescriptor controllerDescriptor, string actionName) {
if (actionName == restActionToken) {
// cleanup the restActionToken we set earlier
controllerContext.RequestContext.RouteData.Values["action"] = null;
List<ActionDescriptor> matches = new List<ActionDescriptor>();
foreach (ActionDescriptor ad in controllerDescriptor.GetCanonicalActions()) {
object[] acceptVerbs = ad.GetCustomAttributes(typeof(AcceptVerbsAttribute), false);
if (acceptVerbs.Length > 0) {
foreach (object o in acceptVerbs) {
AcceptVerbsAttribute ava = o as AcceptVerbsAttribute;
if (ava != null) {
if (ava.Verbs.Contains(controllerContext.HttpContext.Request.GetHttpMethodOverride().ToUpperInvariant())) {
matches.Add(ad);
}
}
}
}
}
switch (matches.Count) {
case 0:
break;
case 1:
ActionDescriptor ad = matches[0];
actionName = ad.ActionName;
controllerContext.RequestContext.RouteData.Values["action"] = actionName;
return ad;
default:
StringBuilder matchesString = new StringBuilder(matches[0].ActionName);
for (int index = 1; index < matches.Count; index++) {
matchesString.Append(", ");
matchesString.Append(matches[index].ActionName);
}
return new ResourceErrorActionDescriptor(
controllerDescriptor,
HttpStatusCode.Conflict,
String.Format(
CultureInfo.CurrentCulture,
MvcResources.ResourceControllerFactory_ConflictingActions,
controllerDescriptor.ControllerName,
matchesString.ToString()
)
);
}
}
return base.FindAction(controllerContext, controllerDescriptor, actionName) ??
new ResourceErrorActionDescriptor(
controllerDescriptor,
HttpStatusCode.NotFound,
String.Format(
CultureInfo.CurrentCulture,
MvcResources.ResourceControllerFactory_NoActions,
controllerDescriptor.ControllerName
)
);
}
private static List <DirectRouteCandidate> GetDirectRouteCandidates(
ControllerContext controllerContext
)
{
Debug.Assert(controllerContext != null);
Debug.Assert(controllerContext.RouteData != null);
List <DirectRouteCandidate> candiates = new List <DirectRouteCandidate>();
RouteData routeData = controllerContext.RouteData;
foreach (var directRoute in routeData.GetDirectRouteMatches())
{
if (directRoute == null)
{
continue;
}
ControllerDescriptor controllerDescriptor =
directRoute.GetTargetControllerDescriptor();
if (controllerDescriptor == null)
{
throw new InvalidOperationException(
MvcResources.DirectRoute_MissingControllerDescriptor
);
}
ActionDescriptor[] actionDescriptors = directRoute.GetTargetActionDescriptors();
if (actionDescriptors == null || actionDescriptors.Length == 0)
{
throw new InvalidOperationException(
MvcResources.DirectRoute_MissingActionDescriptors
);
}
foreach (var actionDescriptor in actionDescriptors)
{
if (actionDescriptor != null)
{
candiates.Add(
new DirectRouteCandidate()
{
ActionDescriptor = actionDescriptor,
ActionNameSelectors = actionDescriptor.GetNameSelectors(),
ActionSelectors = actionDescriptor.GetSelectors(),
Order = directRoute.GetOrder(),
Precedence = directRoute.GetPrecedence(),
RouteData = directRoute,
}
);
}
}
}
return(candiates);
}
/// <summary>
/// Finds the action for the controller, if not it is inferred.
/// </summary>
/// <param name="controllerContext"></param>
/// <param name="controllerDescriptor"></param>
/// <param name="actionName"></param>
/// <returns></returns>
protected override ActionDescriptor FindAction(ControllerContext controllerContext,
ControllerDescriptor controllerDescriptor, string actionName)
{
var foundAction = base.FindAction(controllerContext, controllerDescriptor, actionName);
if (foundAction == null) {
InferredAction inferredAction = GetInferredAction(controllerDescriptor, actionName);
foundAction = new InferredActionDescriptor(actionName, controllerDescriptor, inferredAction);
}
return foundAction;
}
public void FixtureSetUp()
{
_baseControllerContext = new ControllerContext {Controller = new TestController()};
_baseMethodInfo = TestController.GetAction1MethodInfo<TestController>();
_actionName = _baseMethodInfo.Name;
_controllerDescriptor = new Mock<ControllerDescriptor>().Object;
_reflectedActionDescriptor = new ReflectedActionDescriptor(_baseMethodInfo, _actionName, _controllerDescriptor);
}
protected override ActionDescriptor FindAction(ControllerContext controllerContext, ControllerDescriptor controllerDescriptor, string actionName)
{
var result = base.FindAction(controllerContext, controllerDescriptor, actionName);
if (result == null)
{
return new NotFoundActionDescriptor();
}
return result;
}
public InstanceRegistration(IConstraint constraint, ActionDescriptor actionDescriptor, ControllerDescriptor controllerDescriptor, FilterScope scope1)
: base(actionDescriptor, controllerDescriptor, scope1)
{
if (constraint == null)
{
throw new ArgumentNullException("constraint", "Constraint instance can not be null.");
}
Constraint = constraint;
ConstraintType = Constraint.GetType();
}
protected virtual ControllerDescriptor GetControllerDescriptor(ControllerContext controllerContext)
{
// Frequently called, so ensure delegate is static
Type controllerType = controllerContext.Controller.GetType();
ControllerDescriptor controllerDescriptor = DescriptorCache.GetDescriptor(
controllerType: controllerType,
creator: (Type innerType) => new ReflectedControllerDescriptor(innerType),
state: controllerType);
return(controllerDescriptor);
}
/// <summary>
/// Select a member
/// </summary>
/// <param name="controllerContext"></param>
/// <param name="controllerDescriptor"></param>
/// <param name="actionName"></param>
/// <returns></returns>
protected override ActionDescriptor FindAction(ControllerContext controllerContext, ControllerDescriptor controllerDescriptor, string actionName)
{
// Get all members in the controller
var members = MvcApplication.Host.ScriptEngine.Operations.GetMemberNames(controllerContext.Controller);
string resolvedActionName = "";
// If memebrs match, return
if (members.Contains(actionName))
{
resolvedActionName = actionName;
}
else
{
// Search with ignore-case mode
foreach (var member in members)
{
if (member.ToLower() == actionName.ToLower())
{
resolvedActionName = member;
}
}
}
// If an action was found
if (!string.IsNullOrWhiteSpace(resolvedActionName))
{
// Search for all method of this type
var httpMethod = controllerContext.HttpContext.Request.HttpMethod; //GET POST DELETE PUT
var member = MvcApplication.Host.ScriptEngine.Operations.GetMember(controllerContext.Controller, resolvedActionName);
var methodInfo = member as IronPython.Runtime.Method;
var pythonFunction = methodInfo.__func__ as PythonFunction;
Decorator.ActionDecorator dec = null;
if (AspNetMvcAPI.Filter.actionDecorators.TryGetValue(pythonFunction, out dec))
{
if (string.IsNullOrWhiteSpace(dec.httpMethod) && httpMethod == "GET")
{
return new DynamicActionDescriptor(controllerContext, controllerDescriptor, resolvedActionName, pythonFunction);
}
else if (dec.httpMethod == httpMethod)
{
return new DynamicActionDescriptor(controllerContext, controllerDescriptor, resolvedActionName, pythonFunction);
}
}
else if (httpMethod == "GET")
{
return new DynamicActionDescriptor(controllerContext, controllerDescriptor, resolvedActionName, pythonFunction);
}
}
return null;
}
protected override ActionDescriptor FindAction(ControllerContext controllerContext, ControllerDescriptor controllerDescriptor, string actionName)
{
var customActionName =
_handlers
.Select(handler => handler.GetActionName(controllerContext))
.FirstOrDefault(x => x != null);
if (customActionName == null)
return base.FindAction(controllerContext, controllerDescriptor, actionName);
return base.FindAction(controllerContext, controllerDescriptor, customActionName)
?? base.FindAction(controllerContext, controllerDescriptor, actionName); //this would be a lot nicer if FindAction just returned null if the input is null or empty
}
public ReflectedActionDescriptor(
MethodInfo methodInfo,
string actionName,
ControllerDescriptor controllerDescriptor
)
: this(
methodInfo,
actionName,
controllerDescriptor,
true /* validateMethod */
)
{
}
protected override ActionDescriptor FindAction(ControllerContext controllerContext, ControllerDescriptor controllerDescriptor, string actionName)
{
var urlType = GetUrlType(controllerContext);
var httpMethod = GetHttpMethod(controllerContext);
var methodInfo = GetMethodInfo(controllerContext.Controller.GetType(), urlType, httpMethod);
if (methodInfo == null) return null;
// Fix up the "action" name to be the Url type name (minus the "Url" suffix).
// This makes for decent View names e.g. AuthorUrl => controller=Book, action=Author => /Views/Book/Author.aspx
controllerContext.RouteData.Values["action"] = urlType.Name.Substring(0, urlType.Name.Length - 3);
return new ReflectedActionDescriptor(methodInfo, httpMethod, controllerDescriptor);
}
public MethodInfo FindActionMethod(ControllerContext controllerContext, string actionName)
{
if (controllerContext == null)
{
throw Error.ArgumentNull("controllerContext");
}
RouteData routeData = controllerContext.RouteData;
if (routeData != null)
{
MethodInfo target = routeData.GetTargetActionMethod();
if (target != null)
{
// short circuit the selection process if we matched a direct route that already supplies the method.
return(target);
}
}
// If this controller has a Route attribute, then its actions can't be reached by standard routes.
if (_hasRouteAttributeOnController)
{
if (routeData == null)
{
return(null);
}
ControllerDescriptor descriptor = routeData.GetTargetControllerDescriptor();
if (descriptor == null)
{
// Missing descriptor. It's a standard route. Can't reach actions.
return(null);
}
}
List <MethodInfo> finalMethods = FindActionMethods(controllerContext, actionName);
switch (finalMethods.Count)
{
case 0:
return(null);
case 1:
return(finalMethods[0]);
default:
throw CreateAmbiguousActionMatchException(finalMethods, actionName);
}
}
protected override ActionDescriptor FindAction(ControllerContext controllerContext, ControllerDescriptor controllerDescriptor, string actionName)
{
var action = base.FindAction(controllerContext, controllerDescriptor, actionName);
if (action == null)
{
var citkaAction = Bootstrapper.ResolveCommonAction(actionName, MvcApplication.Container);
if (citkaAction != null)
{
citkaAction.SetActionName(actionName);
citkaAction.SetControllerDescriptor(controllerDescriptor);
action = citkaAction;
}
}
return action;
}
internal ReflectedDelegatePatternActionDescriptor(MethodInfo actionMethod, string actionName, ControllerDescriptor controllerDescriptor, bool validateMethod) {
if (validateMethod) {
ValidateActionMethod(actionMethod);
}
if (String.IsNullOrEmpty(actionName)) {
throw new ArgumentException(MvcResources.Common_NullOrEmpty, "actionName");
}
if (controllerDescriptor == null) {
throw new ArgumentNullException("controllerDescriptor");
}
ActionMethod = actionMethod;
_actionName = actionName;
_controllerDescriptor = controllerDescriptor;
}
/// <summary>
/// Ensures that if an action for the Template name is not explicitly defined by a user, that the 'Index' action will execute
/// </summary>
/// <param name="controllerContext"></param>
/// <param name="controllerDescriptor"></param>
/// <param name="actionName"></param>
/// <returns></returns>
protected override ActionDescriptor FindAction(ControllerContext controllerContext, ControllerDescriptor controllerDescriptor, string actionName)
{
var ad = base.FindAction(controllerContext, controllerDescriptor, actionName);
//now we need to check if it exists, if not we need to return the Index by default
if (ad == null)
{
//check if the controller is an instance of RenderMvcController
if (controllerContext.Controller is RenderMvcController)
{
return new ReflectedActionDescriptor(controllerContext.Controller.GetType().GetMethod("Index"), "Index", controllerDescriptor);
}
}
return ad;
}
private static object GetControllerModel(ControllerDescriptor controllerDescriptor, RequestContext requestContext)
{
return new
{
ControllerName = controllerDescriptor.ControllerName,
ControllerType = new
{
Name = controllerDescriptor.ControllerType.Name,
Namespace = controllerDescriptor.ControllerType.Namespace,
Attributes = GetAttributesModel(controllerDescriptor.GetCustomAttributes(inherit: true))
},
Actions = from action in controllerDescriptor.GetCanonicalActions()
let reflectedAction = action as ReflectedActionDescriptor
select new
{
Name = action.ActionName,
Id = GetActionId(action),
Verbs = GetVerbs(action),
Path = GetSamplePath(requestContext, action),
MethodInfo = (reflectedAction != null ? reflectedAction.MethodInfo : null),
ReturnType = (reflectedAction != null ? reflectedAction.MethodInfo.ReturnType : null),
Parameters = from parameter in action.GetParameters()
select new
{
Name = parameter.ParameterName,
Type = parameter.ParameterType,
IsComplexType = IsComplexType(parameter.ParameterType),
DefaultValue = parameter.DefaultValue ?? ""
},
Attributes = GetAttributesModel(action.GetCustomAttributes(inherit: true))
},
InputModels = GetInputModels(controllerDescriptor),
GlobalFilters = from filter in GlobalFilters.Filters
let filterInstance = filter.Instance
let filterType = filterInstance.GetType()
select new
{
Name = filterType.Name,
Namespace = filterType.Namespace,
Properties = from property in filterType.GetProperties()
select new
{
Name = property.Name,
Value = property.GetValue(filterInstance, null)
}
}
};
}
internal static ReflectedActionDescriptor TryCreateDescriptor(
MethodInfo methodInfo,
string name,
ControllerDescriptor controllerDescriptor
)
{
ReflectedActionDescriptor descriptor = new ReflectedActionDescriptor(
methodInfo,
name,
controllerDescriptor,
false /* validateMethod */
);
string failedMessage = VerifyActionMethodIsCallable(methodInfo);
return((failedMessage == null) ? descriptor : null);
}
public static string GetPrefixFrom(this ControllerDescriptor controllerDescriptor)
{
// this only happens once per controller type, for the lifetime of the application,
// so we do not need to cache the results
object[] routePrefixAttributes = controllerDescriptor.GetCustomAttributes(typeof(RoutePrefixAttribute), inherit: false);
if (routePrefixAttributes.Length > 0)
{
RoutePrefixAttribute routePrefixAttribute = routePrefixAttributes[0] as RoutePrefixAttribute;
if (routePrefixAttribute != null)
{
return(routePrefixAttribute.Prefix);
}
}
return(null);
}
public IReadOnlyList<RouteEntry> GetDirectRoutes(ControllerDescriptor controllerDescriptor, IReadOnlyList<ActionDescriptor> actionDescriptors, IInlineConstraintResolver constraintResolver)
{
// Get routes from default provider
var defaultProvider = new DefaultDirectRouteProvider();
var routes = defaultProvider.GetDirectRoutes(controllerDescriptor, actionDescriptors, constraintResolver);
// Create new constraint to accept only supported url prefixes
var lc = new LocaleConstraint();
// Add locale parameter and constraint to every route
foreach (var item in routes) {
item.Route.Url = "{locale}/" + item.Route.Url;
item.Route.Constraints.Add("locale", lc);
}
return routes;
}
internal ReflectedEventPatternActionDescriptor(MethodInfo setupMethod, MethodInfo completionMethod, string actionName, ControllerDescriptor controllerDescriptor, bool validateMethods) {
if (validateMethods) {
ValidateMethods(setupMethod, completionMethod);
}
if (String.IsNullOrEmpty(actionName)) {
throw new ArgumentException(MvcResources.Common_NullOrEmpty, "actionName");
}
if (controllerDescriptor == null) {
throw new ArgumentNullException("controllerDescriptor");
}
SetupMethod = setupMethod;
CompletionMethod = completionMethod;
_actionName = actionName;
_controllerDescriptor = controllerDescriptor;
}
protected virtual ActionDescriptor FindAction(
ControllerContext controllerContext,
ControllerDescriptor controllerDescriptor,
string actionName
)
{
Contract.Assert(controllerContext != null);
Contract.Assert(controllerContext.RouteData != null);
Contract.Assert(controllerDescriptor != null);
if (controllerContext.RouteData.HasDirectRouteMatch())
{
List <DirectRouteCandidate> candidates = GetDirectRouteCandidates(controllerContext);
DirectRouteCandidate bestCandidate = DirectRouteCandidate.SelectBestCandidate(
candidates,
controllerContext
);
if (bestCandidate == null)
{
return(null);
}
else
{
// We need to stash the RouteData of the matched route into the context, so it can be
// used for binding.
controllerContext.RouteData = bestCandidate.RouteData;
controllerContext.RequestContext.RouteData = bestCandidate.RouteData;
// We need to remove any optional parameters that haven't gotten a value (See MvcHandler)
bestCandidate.RouteData.Values.RemoveFromDictionary(
(entry) => entry.Value == UrlParameter.Optional
);
return(bestCandidate.ActionDescriptor);
}
}
else
{
ActionDescriptor actionDescriptor = controllerDescriptor.FindAction(
controllerContext,
actionName
);
return(actionDescriptor);
}
}
internal ReflectedAsyncPatternActionDescriptor(MethodInfo beginMethod, MethodInfo endMethod, string actionName, ControllerDescriptor controllerDescriptor, bool validateMethods) {
if (validateMethods) {
ValidateBeginMethod(beginMethod);
ValidateEndMethod(endMethod);
}
if (String.IsNullOrEmpty(actionName)) {
throw new ArgumentException(MvcResources.Common_NullOrEmpty, "actionName");
}
if (controllerDescriptor == null) {
throw new ArgumentNullException("controllerDescriptor");
}
BeginMethod = beginMethod;
EndMethod = endMethod;
_actionName = actionName;
_controllerDescriptor = controllerDescriptor;
}
/// <summary>
/// Overriding FindAction to determine is a generic parameter exists, then use custom ActionDescriptor
/// </summary>
/// <param name="controllerContext"></param>
/// <param name="controllerDescriptor"></param>
/// <param name="actionName"></param>
/// <returns></returns>
protected override ActionDescriptor FindAction(ControllerContext controllerContext, ControllerDescriptor controllerDescriptor, string actionName)
{
ActionDescriptor actionDescriptor = null;
MethodInfo mi = controllerContext.Controller.GetType().GetMethods().SingleOrDefault(x => x.Name.ToLower() == actionName.ToLower());
if(mi != null)
{
if(mi.ContainsGenericParameters)
{
actionDescriptor = new MyActionDescriptor(mi, actionName, controllerDescriptor);
}
}
if(actionDescriptor == null)
{
actionDescriptor = base.FindAction(controllerContext, controllerDescriptor, actionName);
}
return actionDescriptor;
}
protected override ActionDescriptor FindAction(ControllerContext controllerContext, ControllerDescriptor controllerDescriptor, string actionName)
{
var ad = base.FindAction(controllerContext, controllerDescriptor, actionName);
if (ad == null)
{
if (controllerContext.Controller is RenderMvcController)
{
return new ReflectedActionDescriptor(
controllerContext.Controller.GetType().GetMethods().First(x =>
x.Name == "Index" &&
!x.GetCustomAttributes(typeof(NonActionAttribute), false).Any()),
"Index",
controllerDescriptor
);
}
}
return ad;
}
public static string GetAreaName(this ControllerDescriptor controllerDescriptor, RouteAreaAttribute area)
{
if (area == null)
{
return(null);
}
if (area.AreaName != null)
{
return(area.AreaName);
}
if (controllerDescriptor.ControllerType.Namespace != null)
{
return(controllerDescriptor.ControllerType.Namespace.Split('.').Last());
}
throw Error.InvalidOperation(MvcResources.AttributeRouting_CouldNotInferAreaNameFromMissingNamespace, controllerDescriptor.ControllerName);
}
public MyActionDescriptor( MethodInfo mi, string actionName, ControllerDescriptor controllerDescriptor )
{
if( mi == null )
{
throw new ArgumentNullException( "methodInfo" );
}
if( string.IsNullOrEmpty( actionName ) )
{
throw new ArgumentNullException( "actionName" );
}
if( controllerDescriptor == null )
{
throw new ArgumentNullException( "controllerDescriptor" );
}
this._actionName = actionName;
this._mi = mi;
this._controllerDescriptor = controllerDescriptor;
}
/// <summary>
/// Finds the action for the controller, if not it is inferred.
/// </summary>
/// <param name="controllerContext"></param>
/// <param name="controllerDescriptor"></param>
/// <param name="actionName"></param>
/// <returns></returns>
protected override ActionDescriptor FindAction(ControllerContext controllerContext,
ControllerDescriptor controllerDescriptor, string actionName)
{
ActionDescriptor foundAction;
try {
// Find the base action
foundAction = base.FindAction(controllerContext, controllerDescriptor, actionName);
} catch {
//HACK: Had to add this piece to support ASP.NET MVC on Mono
foundAction = null;
}
if (foundAction == null) {
foundAction = new InferredActionDescriptor(actionName, controllerDescriptor);
}
return foundAction;
}
protected virtual ActionDescriptor FindAction(ControllerContext controllerContext, ControllerDescriptor controllerDescriptor, string actionName)
{
ActionDescriptor actionDescriptor = controllerDescriptor.FindAction(controllerContext, actionName);
return(actionDescriptor);
}
protected internal virtual Type GetControllerType(RequestContext requestContext, string controllerName)
{
if (String.IsNullOrEmpty(controllerName))
{
throw new ArgumentException(MvcResources.Common_NullOrEmpty, "controllerName");
}
RouteData routeData = requestContext.RouteData;
if (requestContext != null && routeData != null)
{
// short circuit controller resolution if a direct route was matched.
MethodInfo target = routeData.GetTargetActionMethod();
if (target != null)
{
return(target.DeclaringType);
}
ControllerDescriptor controllerDescriptor = routeData.GetTargetControllerDescriptor();
if (controllerDescriptor != null)
{
return(controllerDescriptor.ControllerType);
}
}
// first search in the current route's namespace collection
object routeNamespacesObj;
Type match;
if (requestContext != null && routeData.DataTokens.TryGetValue(RouteDataTokenKeys.Namespaces, out routeNamespacesObj))
{
IEnumerable <string> routeNamespaces = routeNamespacesObj as IEnumerable <string>;
if (routeNamespaces != null && routeNamespaces.Any())
{
HashSet <string> namespaceHash = new HashSet <string>(routeNamespaces, StringComparer.OrdinalIgnoreCase);
match = GetControllerTypeWithinNamespaces(routeData.Route, controllerName, namespaceHash);
// the UseNamespaceFallback key might not exist, in which case its value is implicitly "true"
if (match != null || false.Equals(routeData.DataTokens[RouteDataTokenKeys.UseNamespaceFallback]))
{
// got a match or the route requested we stop looking
return(match);
}
}
}
// then search in the application's default namespace collection
if (ControllerBuilder.DefaultNamespaces.Count > 0)
{
HashSet <string> namespaceDefaults = new HashSet <string>(ControllerBuilder.DefaultNamespaces, StringComparer.OrdinalIgnoreCase);
match = GetControllerTypeWithinNamespaces(routeData.Route, controllerName, namespaceDefaults);
if (match != null)
{
return(match);
}
}
// if all else fails, search every namespace
return(GetControllerTypeWithinNamespaces(routeData.Route, controllerName, null /* namespaces */));
}
public virtual bool InvokeAction(ControllerContext controllerContext, string actionName)
{
if (controllerContext == null)
{
throw new ArgumentNullException("controllerContext");
}
if (String.IsNullOrEmpty(actionName))
{
throw new ArgumentException(MvcResources.Common_NullOrEmpty, "actionName");
}
ControllerDescriptor controllerDescriptor = GetControllerDescriptor(controllerContext);
ActionDescriptor actionDescriptor = FindAction(controllerContext, controllerDescriptor, actionName);
if (actionDescriptor != null)
{
FilterInfo filterInfo = GetFilters(controllerContext, actionDescriptor);
try
{
AuthenticationContext authenticationContext = InvokeAuthenticationFilters(controllerContext, filterInfo.AuthenticationFilters, actionDescriptor);
if (authenticationContext.Result != null)
{
// An authentication filter signaled that we should short-circuit the request. Let all
// authentication filters contribute to an action result (to combine authentication
// challenges). Then, run this action result.
AuthenticationChallengeContext challengeContext =
InvokeAuthenticationFiltersChallenge(controllerContext, filterInfo.AuthenticationFilters,
actionDescriptor, authenticationContext.Result);
InvokeActionResult(controllerContext, challengeContext.Result ?? authenticationContext.Result);
}
else
{
IPrincipal principal = authenticationContext.Principal;
if (principal != null)
{
Thread.CurrentPrincipal = principal;
HttpContext.Current.User = principal;
}
AuthorizationContext authorizationContext = InvokeAuthorizationFilters(controllerContext, filterInfo.AuthorizationFilters, actionDescriptor);
if (authorizationContext.Result != null)
{
// An authorization filter signaled that we should short-circuit the request. Let all
// authentication filters contribute to an action result (to combine authentication
// challenges). Then, run this action result.
AuthenticationChallengeContext challengeContext =
InvokeAuthenticationFiltersChallenge(controllerContext,
filterInfo.AuthenticationFilters, actionDescriptor, authorizationContext.Result);
InvokeActionResult(controllerContext, challengeContext.Result ??
authorizationContext.Result);
}
else
{
if (controllerContext.Controller.ValidateRequest)
{
ValidateRequest(controllerContext);
}
IDictionary <string, object> parameters = GetParameterValues(controllerContext, actionDescriptor);
ActionExecutedContext postActionContext = InvokeActionMethodWithFilters(controllerContext, filterInfo.ActionFilters, actionDescriptor, parameters);
// The action succeeded. Let all authentication filters contribute to an action result (to
// combine authentication challenges; some authentication filters need to do negotiation
// even on a successful result). Then, run this action result.
AuthenticationChallengeContext challengeContext =
InvokeAuthenticationFiltersChallenge(controllerContext,
filterInfo.AuthenticationFilters, actionDescriptor, postActionContext.Result);
InvokeActionResultWithFilters(controllerContext, filterInfo.ResultFilters,
challengeContext.Result ?? postActionContext.Result);
}
}
}
catch (ThreadAbortException)
{
// This type of exception occurs as a result of Response.Redirect(), but we special-case so that
// the filters don't see this as an error.
throw;
}
catch (Exception ex)
{
// something blew up, so execute the exception filters
ExceptionContext exceptionContext = InvokeExceptionFilters(controllerContext, filterInfo.ExceptionFilters, ex);
if (!exceptionContext.ExceptionHandled)
{
throw;
}
InvokeActionResult(controllerContext, exceptionContext.Result);
}
return(true);
}
// notify controller that no method matched
return(false);
}
public virtual bool InvokeAction(ControllerContext controllerContext, string actionName)
{
if (controllerContext == null)
{
throw new ArgumentNullException("controllerContext");
}
if (String.IsNullOrEmpty(actionName))
{
throw new ArgumentException(MvcResources.Common_NullOrEmpty, "actionName");
}
ControllerDescriptor controllerDescriptor = GetControllerDescriptor(controllerContext);
ActionDescriptor actionDescriptor = FindAction(controllerContext, controllerDescriptor, actionName);
if (actionDescriptor != null)
{
FilterInfo filterInfo = GetFilters(controllerContext, actionDescriptor);
try
{
AuthorizationContext authContext = InvokeAuthorizationFilters(controllerContext, filterInfo.AuthorizationFilters, actionDescriptor);
if (authContext.Result != null)
{
// the auth filter signaled that we should let it short-circuit the request
InvokeActionResult(controllerContext, authContext.Result);
}
else
{
if (controllerContext.Controller.ValidateRequest)
{
ValidateRequest(controllerContext);
}
IDictionary <string, object> parameters = GetParameterValues(controllerContext, actionDescriptor);
ActionExecutedContext postActionContext = InvokeActionMethodWithFilters(controllerContext, filterInfo.ActionFilters, actionDescriptor, parameters);
InvokeActionResultWithFilters(controllerContext, filterInfo.ResultFilters, postActionContext.Result);
}
}
catch (ThreadAbortException)
{
// This type of exception occurs as a result of Response.Redirect(), but we special-case so that
// the filters don't see this as an error.
throw;
}
catch (Exception ex)
{
// something blew up, so execute the exception filters
ExceptionContext exceptionContext = InvokeExceptionFilters(controllerContext, filterInfo.ExceptionFilters, ex);
if (!exceptionContext.ExceptionHandled)
{
throw;
}
InvokeActionResult(controllerContext, exceptionContext.Result);
}
return(true);
}
// notify controller that no method matched
return(false);
}
public static IEnumerable <IRouteInfoProvider> GetDirectRoutes(this ControllerDescriptor controller)
{
return(controller.GetCustomAttributes(inherit: false).OfType <IRouteInfoProvider>());
}
public override void OnAuthorization(AuthorizationContext filterContext)
{
/* var _context = _filterContext.HttpContext;
*
* //redirect if not authenticated
* if (!_context.Request.IsAuthenticated || (!string.IsNullOrWhiteSpace(SessionId) && _context.Session[SessionId] == null))
* {
* //use the current url for the redirect
* if (_context.Request.Url != null)
* {
* string _redirectOnSuccess = _context.Server.UrlEncode(_context.Request.Url.ToString());
* //send them off to the login page
* string _redirectUrl = string.Format("?ReturnUrl={0}", _redirectOnSuccess);
* string _loginUrl = System.Configuration.ConfigurationManager.AppSettings["LoginUrl"];
* _loginUrl = (!string.IsNullOrWhiteSpace(_loginUrl) ? _loginUrl : FormsAuthentication.LoginUrl) + _redirectUrl;
*
* _context.Response.Redirect(_loginUrl, true);
* }
* }*/
if (filterContext == null)
{
throw new ArgumentNullException("filterContext");
}
if (OutputCacheAttribute.IsChildActionCacheActive(filterContext))
{
throw new InvalidOperationException("Authorize Attribute Cannot Use Within Child Action Cache");
}
ActionDescriptor actionDescriptor = filterContext.ActionDescriptor;
bool flag1 = true;
Type attributeType1 = typeof(AllowAnonymousAttribute);
int num1 = flag1 ? 1 : 0;
int num2;
if (!actionDescriptor.IsDefined(attributeType1, num1 != 0))
{
ControllerDescriptor controllerDescriptor = filterContext.ActionDescriptor.ControllerDescriptor;
bool flag2 = true;
Type attributeType2 = typeof(AllowAnonymousAttribute);
int num3 = flag2 ? 1 : 0;
num2 = controllerDescriptor.IsDefined(attributeType2, num3 != 0) ? 1 : 0;
}
else
{
num2 = 1;
}
if (num2 != 0)
{
return;
}
/* if (AuthorizeCore(filterContext.HttpContext))
* {
* HttpCachePolicyBase cache = filterContext.HttpContext.Response.Cache;
* cache.SetProxyMaxAge(new TimeSpan(0L));
* throw new NotImplementedException();
* }
* HandleUnauthorizedRequest(filterContext);*/
var _context = filterContext.HttpContext;
if (!_context.Request.IsAuthenticated || (!string.IsNullOrWhiteSpace(SessionId) && _context.Session[SessionId] == null))
{
//use the current url for the redirect
if (_context.Request.Url != null)
{
string _redirectOnSuccess = _context.Server.UrlEncode(_context.Request.Url.ToString());
//send them off to the login page
string _redirectUrl = string.Format("?ReturnUrl={0}", _redirectOnSuccess);
string _loginUrl = System.Configuration.ConfigurationManager.AppSettings["LoginUrl"];
_loginUrl = (!string.IsNullOrWhiteSpace(_loginUrl) ? _loginUrl : FormsAuthentication.LoginUrl) + _redirectUrl;
_context.Response.Redirect(_loginUrl, true);
}
}
}
