Comment obtenir des annotations personnalisées attributs pour une action de contrôleur dans ASP.NET MVC 4?

Alors que je suis d'accord que la génération d'url en fonction des autorisations est probablement pas les meilleures pratiques, si vous voulez continuer, vous pouvez trouver les actes et de leurs attributs à l'aide de ces:

Récupérer "l'Action" méthodes:
Cela permet de récupérer une collection de méthode d'infos car il est possible d'avoir plusieurs classes de Contrôleur avec le même nom et plusieurs méthodes de même nom en particulier avec l'utilisation des zones. Si vous avez à vous soucier de cela, je vais laisser la désambiguïsation jusqu'à vous.

public static IEnumerable<MethodInfo> GetActions(string controller, string action)
{
    return Assembly.GetExecutingAssembly().GetTypes()
           .Where(t =>(t.Name == controller && typeof(Controller).IsAssignableFrom(t)))
           .SelectMany(
                type =>
                type.GetMethods(BindingFlags.Public | BindingFlags.Instance)
                    .Where(a => a.Name == action && a.ReturnType == typeof(ActionResult))
             );

}

Récupérer les Autorisations de MyAuthorizationAttributes:

public static MyAuthorizations GetMyAuthorizations(IEnumerable<MethodInfo> actions)
{
    var myAuthorization = new MyAuthorizations();
    foreach (var methodInfo in actions)
    {
        var authorizationAttributes =  methodInfo
                .GetCustomAttributes(typeof (MyAuthorizationAttribute), false)
                .Cast<MyAuthorizationAttribute>();
        foreach (var myAuthorizationAttribute in authorizationAttributes)
        {
            myAuthorization.Roles.Add(MyAuthorizationAttribute.Role);
            myAuthorization.Permissions.Add(MyAuthorizationAttribute.Permission);
        }
    }
    return myAuthorization;
}
public class MyAuthorizations
{
    public MyAuthorizations()
    {
        Roles = new List<string>();
        Permissions = new List<string>();
    }
    public List<string> Roles { get; set; }
    public List<string> Permissions { get; set; }
}

Enfin la AuthorizedAction extension: avertissement:Si vous n'avez plus d'un match pour une paire contrôleur/action ce que va donner la "autorisés" url si l'utilisateur est autorisé pour l'un d'eux...

public static string AuthorizedAction(this UrlHelper url, string controller, string action)
{
    var actions = GetActions(controller, action);
    var authorized = GetMyAuthorizations(actions);
    if(user.Roles.Any(userrole => authorized.Roles.Any(role => role == userrole)) ||
       user.Permissions.Any(userPermission => authorized.Permissions.Any(permission => permission == userPermission)))
    {
        return url.Action(controller,action)
    }
    return string.empty;
}

Une Remarque sur la Génération d'Url Basé sur les Autorisations:

J'ai de l'état c'est probablement pas de meilleure pratique en raison de beaucoup de petites choses. Chacun peut avoir son propre niveau de pertinence en fonction de votre situation.

• Donne l'impression de chercher à obtenir la sécurité par l'obscurité. Si je ne les montrent pas l'url, ils ne savent pas qu'il est là.
• Si vous êtes déjà de la vérification des autorisations à d'autres façons de contrôler le rendu de la page (comme il semble que vous faites en fonction de vos commentaires d'ailleurs) cette explicitement ne pas écrire l'url est inutile. Mieux à même pas appeler l'Url.Méthode d'Action.
• Si vous n'êtes pas déjà le contrôle de l'affichage de la page selon les autorisations de l'utilisateur, il suffit de retourner une chaîne vide pour les url laissera beaucoup de casse ou apparemment cassé contenu sur vos pages. Hey ce bouton ne fait rien quand j'appuie sur elle!
• Il peut faire les tests et le débogage plus compliqué: Est l'url ne s'affiche pas parce que les autorisations ne sont pas de droite, ou il y a un autre bug?
• Le comportement de la AuthorizedAction méthode semble incohérent. Renvoie une url, parfois, et une chaîne vide à d'autres moments.

De contrôler le Rendu de la Page Via l'Action attributs d'Autorisation:
Modifier la AuthorizedAction méthode à un boolean, puis utiliser le résultat pour contrôler le rendu de la page.

public static bool AuthorizedAction(this HtmlHelper helper, string controller, string action)
{
    var actions = GetActions(controller, action);
    var authorized = GetMyAuthorizations(actions);
    return user.Roles.Any(userrole => authorized.Roles.Any(role => role == userrole)) ||
       user.Permissions.Any(userPermission => authorized.Permissions.Any(permission => permission == userPermission))
}

Ensuite l'utiliser dans vos pages razor.

@if(Html.AuthorizedAction("User","Add")){
   <div id='add-user-section'>
        If you see this, you have permission to add a user.
        <form id='add-user-form' submit='@Url.Action("User","Add")'>
             etc
        </form>
   </div>
}
else {
  <some other content/>

}

OriginalL'auteur Mr.Mindor

Ma seule recommandation serait d'écrire une des extensions de méthodes sur IPrincipal à la place qui ressemblerait

public static bool HasRolesAndPermissions(this IPrincipal instance,
    string roles,
    string permissions,)
{
  if(user not authenticated)
    return false;

  if(user has any role of Roles)
    return true;

  if(user has any permission of Permissions)
    return true;

return false;
}

Puis votre code dans la vue/partiels est un peu plus lisible en termes de ce qu'est réellement en train de faire (ne pas faire n'importe quoi avec html, mais la validation d'un utilisateur), puis le code de la vue/partiels ressemble

@if (User.HasRolesAndPermissions(roles, permissions)) 
{ 
   @Html.ActionLink(..);
}

Chaque MVC Page a la propriété WebViewPage.L'utilisateur pour l'utilisateur actuel.

Le problème avec votre dessein solution (et le lien à la sécurité conscients lien), c'est que la création du lien, et de l'Autoriser sur les contrôleurs pourraient être différents (et le mélange des responsabilités dans ce type de mode à MON avis est une mauvaise pratique). Par extension IPrincipal une nouvelle autorisation serait:

protected override bool AuthorizeCore(HttpContextBase httpContext)
{
  return user.HasRolesAndPermissions(roles, permissions)
}

Maintenant Autoriser à la fois vos attributs et de points de Vue utiliser les mêmes rôles et les autorisations données logique.

OriginalL'auteur Erik Philips