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