Comment étendre AuthorizeAttribute et vérifier les rôles de l'utilisateur

Je suis en train de rédiger mon propre attribut personnalisé pour ma méthode d'action appelé MyAuthorizeAttribute, je suis toujours occupé à écrire le code, voici mon partiel de code:

[AttributeUsage(AttributeTargets.Method, AllowMultiple = false)]
public class  MyAuthorizeAttribute : AuthorizeAttribute
{
   public new Role Roles;

   public override void OnAuthorization(AuthorizationContext filterContext)
   {
      base.OnAuthorization(filterContext);

      if (Roles != 0)  //Did it this way to see what the value of Roles was
         return;

      //Here I am going to get a list of user roles
      //I'm doing my own database calls

      filterContext.Result = new HttpUnauthorizedResult();
   }
}

Ici, c'est mon Rôle enum:

public enum Role
{
   Administrator = 1,
   SuperAdministrator = 2
}

Ma méthode d'action:

[MyAuthorize(Roles = Role.Administrator|Role.SuperAdministrator)]
public ActionResult Create()
{
   return View();
}

La raison pourquoi je n'ai pas utiliser de Rôles = "Administrateur,Super -" a été parce que les rôles sont codées en dur. Je ne veux pas avoir un 100 places à changer si le rôle du changement de nom.

Donné ma méthode, quand il arrive à s' (Rôles != 0) alors les Rôles de la valeur totale est de 3, comment pourrais-je vérifier pour voir si ces 2 rôles est dans la liste des rôles d'utilisateur pour un utilisateur spécifique?

Suis-je la faire corriger ici? Si non, comment ferais-je autrement mettre en œuvre? Il n'a pas à être de cette façon que je l'ai fait dans.

Est votre problème résolu par l'une des deux réponses ci-dessous? Si oui, veuillez accepter la réponse. Il va aider les autres qui a le même problème, comme moi.

OriginalL'auteur Brendan Vogt | 2011-02-25

Ne serait-il pas mieux si MyAuthorizeAttribute accepté une IList ( ou similaire)
De cette façon, il est à la fois typesafe, mais vous n'avez pas à utiliser les indicateurs de bits.
Les indicateurs de bits sont parfaits si vous souhaitez enregistrer le reult, mais c'est dans l'autre sens.

Modifier (avec des exemples):

Attribute:

[AttributeUsage(AttributeTargets.Method, AllowMultiple = false)]
public class MyAuthorizeAttribute : AuthorizeAttribute
{
    public Role[] RoleList { get; set; }


    protected override bool AuthorizeCore(HttpContextBase httpContext)
    {
        if (httpContext == null)
        {
            throw new ArgumentNullException("httpContext");
        }
        IPrincipal user = httpContext.User;
        if (!user.Identity.IsAuthenticated)
        {
            return false;
        }
        //Only role access is implemented here
        /*if ((this._usersSplit.Length > 0) && !this._usersSplit.Contains<string>(user.Identity.Name, StringComparer.OrdinalIgnoreCase))
        {
            return false;
        }*/
        if ((RoleList.Length > 0) && !RoleList.Select(p=>p.ToString()).Any<string>(new Func<string, bool>(user.IsInRole)))
        {
            return false;
        }
        return true;
    }

}

Contrôleur:

[MyAuthorize(RoleList = new []{Role.Administrator , Role.SuperAdministrator} )]
    public ActionResult Create()
    {
        return View();
    }

Pourriez-vous fournir des exemples de code de ce que tu veux dire?
Exemples ajouté.

OriginalL'auteur Tomas

Si je comprends bien, votre problème ici n'est pas à hériter de la AuthorizeAttribute, mais plutôt de comparer les valeurs de l'enum. Vous voulez probablement un type enum que vous pouvez utiliser comme un indicateur de bit - si oui, jetez un oeil à la section sur l'Énumération des Types dans le guide de Programmation C# surtout la deuxième partie, "l'Énumération des Types d'indicateurs de Bits".

De clarifier un peu:

Au lieu de simplement vérifier Roles!=0, vous pouvez maintenant faire quelque chose comme ceci:

public override void OnAuthorization(AuthorizationContext filterContext)
{
    base.OnAuthorization(filterContext);

    //Here you get an enum indicating the roles this user is in. The method
    //converts the db information to a Role enum before it is returned.
    //If the user is not authenticated, the flag should not be set, i.e. equal 0.
    Role userRole = GetUserRolesFromDatabase();

    //Bitwise comparison of the two role collections.
    if (Roles & userRole > 0)
    {
        //The user is in at least one of the roles in Roles. Return normally.
        return;
    }

    //If we haven't returned yet, the user doesn't have the required privileges.
    new HttpUnauthorizedResult(); 
}

De rendre la comparaison plus facile, vous pouvez utiliser les éléments suivants de la méthode d'extension sur votre enum:

public static class RolesExtensions
{
    public static bool HasAnyOf(this Roles r1, Roles roles)
    {
        return (r1 & roles) > 0;
    }
}

Oui les Rôles que j'attribue, je veux vérifier si l'utilisateur est dans les rôles. Il n'a pas à être de cette façon, c'est juste moi, il pourrait y avoir de meilleures façons de mise en œuvre de cette.
Je ne comprends pas comment cela va m'aider?
Veuillez voir ma mise à jour.

OriginalL'auteur Tomas Aschan

Vous devez vous connecter pour publier un commentaire.