ASP.Net MVC comment faire pour déterminer si un utilisateur peut accéder à une URL?

Quel est le problème que vous essayez de résoudre? Il semble que vous pouvez être dirigé vers le bas un chemin vers une solution complexe qui pourraient utiliser une solution simple à la place.

Si un utilisateur n'a pas les permissions pour accéder à la page après la connexion, vous êtes désireux de non-connecté aux utilisateurs d'accéder à une page, tandis que les utilisateurs connectés aller à une autre page?

Si c'est le cas, je pourrais être tenté de créer un autre contrôleur pour de tels scénarios et de les rediriger vers ce contrôleur n'importe où l'utilisateur n'a pas accès. Ou si vous utilisez votre propre Contrôleur de base je mettrais la fonctionnalité.

Puis le contrôleur pourrait présenter la vue souhaitée. Par exemple, si un utilisateur tente d'accéder à une page, ils pourraient être redirigé vers une page d'erreur générique. Si l'utilisateur est connecté, ils pourraient être redirigé vers une non autorisé page.

Ceci est très similaire à Robert de réponse.

Voici un squelette de base d'un contrôleur de base.

public BaseController: Controller
{

... //Some code

    public ActionResult DisplayErrorPage()
    {
        //Assumes you have a User object with a IsLoggedIn property
        if (User.IsLoggedIn())    
            return View("NotAuthorized");

        //Redirect user to login page
        return RedirectToAction("Logon", "Account");
    }

}

Puis dans disons une AdminController (qui hérite de BaseController) action

public ActionResult HighlyRestrictedAction()
{
    //Assumes there is a User object with a HasAccess property
    if (User.HasAccess("HighlyRestrictedAction") == false)
        return DisplayErrorPage();

    //At this point the user is logged in and has permissions
    ...
}

OriginalL'auteur 37Stars

J'ai porté et piraté ce code à partir de la MvcSitemap:

public static class SecurityTrimmingExtensions 
{
///<summary>
///Returns true if a specific controller action exists and
///the user has the ability to access it.
///</summary>
///<param name="htmlHelper"></param>
///<param name="actionName"></param>
///<param name="controllerName"></param>
///<returns></returns>
public static bool HasActionPermission( this HtmlHelper htmlHelper, string actionName, string controllerName )
{
//if the controller name is empty the ASP.NET convention is:
//"we are linking to a different controller
ControllerBase controllerToLinkTo = string.IsNullOrEmpty(controllerName) 
? htmlHelper.ViewContext.Controller
: GetControllerByName(htmlHelper, controllerName);
var controllerContext = new ControllerContext(htmlHelper.ViewContext.RequestContext, controllerToLinkTo);
var controllerDescriptor = new ReflectedControllerDescriptor(controllerToLinkTo.GetType());
var actionDescriptor = controllerDescriptor.FindAction(controllerContext, actionName);
return ActionIsAuthorized(controllerContext, actionDescriptor);
}
private static bool ActionIsAuthorized(ControllerContext controllerContext, ActionDescriptor actionDescriptor)
{
if (actionDescriptor == null)
return false; //action does not exist so say yes - should we authorise this?!
AuthorizationContext authContext = new AuthorizationContext(controllerContext);
//run each auth filter until on fails
//performance could be improved by some caching
foreach (IAuthorizationFilter authFilter in actionDescriptor.GetFilters().AuthorizationFilters)
{
authFilter.OnAuthorization(authContext);
if (authContext.Result != null)
return false;
}
return true;
}
private static ControllerBase GetControllerByName(HtmlHelper helper, string controllerName)
{
//Instantiate the controller and call Execute
IControllerFactory factory = ControllerBuilder.Current.GetControllerFactory();
IController controller = factory.CreateController(helper.ViewContext.RequestContext, controllerName);
if (controller == null)
{
throw new InvalidOperationException(
String.Format(
CultureInfo.CurrentUICulture,
"Controller factory {0} controller {1} returned null",
factory.GetType(),
controllerName));
}
return (ControllerBase)controller;
}

On pourrait utiliser une mise en cache, mais pour mon cas c'était une optimisation prématurée.

OriginalL'auteur jfar

Dans mon application, j'ai créé un filtre personnalisé dérivé de AuthorizeAttribute, de sorte que tout accès non autorisé il suffit d'aller à AccessDenied page. Pour les liens, j'ai remplacer le Html.ActionLink avec un helper Html.SecureLink. Dans ce helper extension, j'ai vérifier rôles de l'utilisateur l'accès à controller/action contre la base de données. Si il/elle dispose de l'autorisation, le lien de retour sinon renvoyer le lien de texte avec remarques spéciales (peut-être l'image/coloration/js)

OriginalL'auteur Rocky Zairil

j'ai juste passé un certain temps à la mise en œuvre de @jfar de la solution (mise à jour pour les non-déconseillé GetFilters() de la version), et puis j'ai réalisé que je ne peux ignorer tout cela.

dans mon cas (et je suppose que la plupart des cas) j'ai un custom AuthorizationAttribute à mettre en œuvre l'autorisation qui à son tour appelle mon service d'autorisation pour effectuer le niveau d'accès determinenation.

Donc, à mon helper html pour générer des liens de menu, j'ai sauté à droite pour le service auth:

@Html.MenuItem(@Url, "icon-whatever", "TargetController", "TargetAction")
public static MvcHtmlString MenuItem(this HtmlHelper htmlHelper, UrlHelper url,string iconCss, string targetController, string targetAction)
{
var auth = IoC.Resolve<IClientAuthorizationService>().Authorize(targetController, targetAction);
if (auth == AccessLevel.None)
return MvcHtmlString.Create("");

*l'utilisateur est déterminé à l'intérieur de l'authentification des clients du service de

public string GetUser() {
return HttpContext.Current.User.Identity.Name;
}

*peut également ajouter un peu de comportement pour un accès en lecture seule. c'est agréable parce que mon service de demenagement se charge de la mise en cache, donc je n'ai pas à vous soucier de la performance.

OriginalL'auteur Sonic Soul