Permettre à de multiples rôles de contrôleur d'accès à l'action

Droit maintenant, je décorer une méthode comme ceci pour permettre aux "membres" pour accéder à mon action de contrôleur

[Authorize(Roles="members")]

Comment puis-je permettre à plus d'un rôle? Par exemple, le code suivant ne fonctionne pas, mais il montre ce que je suis en train de faire (de permettre de "membres" et "admin" accès):

[Authorize(Roles="members", "admin")]

S'il vous plaît changer la accepté de répondre à cette question. La personne avec le actuellement accepté de répondre édité en indiquant qu'il s'était trompé.

InformationsquelleAutor codette | 2009-03-31

548

Une autre option est d'utiliser un seul autoriser le filtre que vous avez posté, mais retirer l'intérieur des citations.
```
[Authorize(Roles="members, admin")]
```
- Travaille dans MVC3 et MVC4 +1
- Travaille en MVC 5 trop. +1
- Travaux dans ASP.NET Core 1.0 MVC (6) et Microsoft.AspNet.L'identité de la v3.*
- Ce n'est pas grave si vous avez un contrôleur que vous avez besoin de l'autoriser. Si vous avez plus d'un, vous êtes à la duplication de ces constantes de chaîne (beurk). Je préfère de beaucoup la statique de la classe qui a le rôle de noms. Mon animal de compagnie, la haine est en double cordes... alors si mauvais.
- Pour la vie de moi je ne peux pas obtenir que cela fonctionne. C'est bien si je spécifier [Autoriser(Rôles = "Administrateur")], mais pas si je spécifie [Autoriser(Rôles = "Administrateur, PowerUser")]. Je suis en utilisant MVC v5.2.7
- Alors maintenant, je suis mise à l'essai d'un attribut personnalisé héritant de AuthorizeAttribute. C'est bien avec juste un Administrateur, il frappe mon point de rupture dans HandleUnauthorizedRequest très bien, mais si je indiquer l'Administrateur et PowerUser, il ne frappe pas le point de rupture à tous et l'accès est accordé à l'action. De quoi la?!?
- Jamais l'esprit. Je pense que c'est un des témoins question. Mon utilisateur semble être toujours connecté.
- bonne nouvelle que vous avez résolu votre problème. Maintenant, pensez à supprimer vos commentaires, merci
- Pourquoi? Il m'a fallu les âges à faire ce travail. Il peut être utile pour quelqu'un d'autre rencontre le même problème.
InformationsquelleAutor Jim Schmehil
115

Si vous souhaitez utiliser des rôles personnalisés, vous pouvez le faire:

CustomRoles classe:
```
public static class CustomRoles
{
    public const string Administrator = "Administrador";
    public const string User = "Usuario";
}
```
Utilisation
```
[Authorize(Roles = CustomRoles.Administrator +","+ CustomRoles.User)]
```
Si vous avez quelques rôles, peut-être vous pouvez combiner entre eux (pour plus de clarté) comme ceci:
```
public static class CustomRoles
{
     public const string Administrator = "Administrador";
     public const string User = "Usuario";
     public const string AdministratorOrUser = Administrator + "," + User;  
}
```
Utilisation
```
[Authorize(Roles = CustomRoles.AdministratorOrUser)]
```
- Ce serait une bonne réponse, si vous l'avez expliqué à des gens qui ne savent pas ce qui est derrière CustomRoles.
- ok, j'ai étendu ma réponse. C'est très simple. CustumRoles est une classe que j'ai créé qui contient certaines des constantes, qui correspond à ma demande rôles. Je l'ai fait pour plusieurs raisons: 1) Il permet l'utilisation d'intellisense pour éviter les fautes d'orthographe 2)Pour simplifier la maintenance. Si un changement de rôle, je dois mettre à jour un seul endroit dans mon application.
- Sinon, vous pouvez créer un enum avec un attribut Flags, par exemple, Convertir.ToString(CustomRoles.Administrateur | CustomRoles.De l'utilisateur); - ennuyeux, c'est que cela nécessite une conversion explicite
- Si vous avez 39 rôles ?
- Je pense que votre problème passe par la modélisation de permis, au-delà de ce qui peut être fait avec .net
InformationsquelleAutor Pablo Claus
74

Une possible simplification serait la sous-classe AuthorizeAttribute:
```
public class RolesAttribute : AuthorizeAttribute
{
    public RolesAttribute(params string[] roles)
    {
        Roles = String.Join(",", roles);
    }
}
```
Utilisation:
```
[Roles("members", "admin")]
```
Du point de vue sémantique, il est le même que Jim Schmehil de réponse.
- Cela n'a pas fonctionné pour moi, l'utilisateur connecté a été en mesure de contourner l'attribut même si l'utilisateur n'avez pas les rôles.
- Cette réponse, c'est mieux pour quand vous êtes à l'aide de constantes que vos valeurs: c'est à dire [Rôles(des Constantes.Admin,Constantes.Le propriétaire)]
- c'est la meilleure réponse
InformationsquelleAutor Mihkel Müür

Pour MVC4, à l'aide d'un Enum (UserRoles) avec mes rôles, je utiliser un AuthorizeAttribute.

Sur mon action commandée, je n':

[CustomAuthorize(UserRoles.Admin, UserRoles.User)]
public ActionResult ChangePassword()
{
    return View();
}

Et j'utilise un custom AuthorizeAttribute comme ça:

[AttributeUsage(AttributeTargets.Method | AttributeTargets.Class, Inherited = true, AllowMultiple = true)]
public class CustomAuthorize : AuthorizeAttribute
{
    private string[] UserProfilesRequired { get; set; }

    public CustomAuthorize(params object[] userProfilesRequired)
    {
        if (userProfilesRequired.Any(p => p.GetType().BaseType != typeof(Enum)))
            throw new ArgumentException("userProfilesRequired");

        this.UserProfilesRequired = userProfilesRequired.Select(p => Enum.GetName(p.GetType(), p)).ToArray();
    }

    public override void OnAuthorization(AuthorizationContext context)
    {
        bool authorized = false;

        foreach (var role in this.UserProfilesRequired)
            if (HttpContext.Current.User.IsInRole(role))
            {
                authorized = true;
                break;
            }

        if (!authorized)
        {
            var url = new UrlHelper(context.RequestContext);
            var logonUrl = url.Action("Http", "Error", new { Id = 401, Area = "" });
            context.Result = new RedirectResult(logonUrl);

            return;
        }
    }
}

C'est en partie modifiés FNHMVC par Fabricio Martínez Tamayo https://github.com/fabriciomrtnz/FNHMVC/

Votre OnAuthorization méthode demandera à l'utilisateur de disposer de tous la énuméré les rôles; était-ce intentionnel, ou vous manque une pause dans cette boucle?
J'ai vérifié que peu de choses près, il semble définitivement comme une pause était nécessaire dans cette boucle.
et @ madrush, j'apprécie votre position, il pouvait vraiment faire une pause à l'intérieur de la boucle. Je vais changer le code ci-dessus.
L'enum UserRoles est agréable. Avez-vous déclarer manuellement ou est-elle générée automatiquement, basée sur le contenu de la DB?
C'est à la main, mais je suppose qu'avec la Réflexion et la Dynamique de la classe générée automatiquement peut être fait
Primordial OnAuthorization est une mauvaise idée. Il y a un bout de code qui protège contre les pages mises en cache d'être servi dans l'original. Vérifiez la source.

InformationsquelleAutor Bernardo Loureiro

Si vous vous trouvez dans l'application de ces 2 rôles souvent, vous pouvez les envelopper dans leur propre Autoriser. C'est vraiment une extension de la accepté de répondre.

using System.Web.Mvc;

public class AuthorizeAdminOrMember : AuthorizeAttribute
{
    public AuthorizeAdminOrMember()
    {
        Roles = "members, admin";
    }
}

Et appliquez ensuite votre nouveau autoriser à l'Action. Je pense que cela ressemble plus propre et se lit facilement.

public class MyController : Controller
{
    [AuthorizeAdminOrMember]
    public ActionResult MyAction()
    {
        return null;
    }
}

InformationsquelleAutor GER

1

Autre solution, vous pouvez utiliser des constantes pour que la convention et d'ajouter de multiples [Autoriser] attributs. Check this out:
```
public static class RolesConvention
{
    public const string Administrator = "Administrator";
    public const string Guest = "Guest";
}
```
Puis dans le contrôleur:
```
[Authorize(Roles = RolesConvention.Administrator )]
[Authorize(Roles = RolesConvention.Guest)]
[Produces("application/json")]
[Route("api/[controller]")]
public class MyController : Controller
```
- Plusieurs Authorize attributs d'employer ET de sémantique et d'exiger que TOUTES les conditions soient remplies (c'est à dire l'utilisateur doit être à la fois l'Administrateur et Invité les rôles).
InformationsquelleAutor Renê R. Silva

Un code de meilleure qualité avec l'ajout d'une sous-classe AuthorizeRole.cs

    [AttributeUsage(AttributeTargets.Method | AttributeTargets.Class, Inherited = true, AllowMultiple = true)]
    class AuthorizeRoleAttribute : AuthorizeAttribute
    {
        public AuthorizeRoleAttribute(params Rolenames[] roles)
        {
            this.Roles = string.Join(",", roles.Select(r => Enum.GetName(r.GetType(), r)));
        }
        protected override void HandleUnauthorizedRequest(System.Web.Mvc.AuthorizationContext filterContext)
        {
            if (filterContext.HttpContext.Request.IsAuthenticated)
            {
                filterContext.Result = new RedirectToRouteResult(
                new RouteValueDictionary {
                  { "action", "Unauthorized" },
                  { "controller", "Home" },
                  { "area", "" }
                  }
              );
                //base.HandleUnauthorizedRequest(filterContext);
            }
            else
            {
                filterContext.Result = new RedirectToRouteResult(
                new RouteValueDictionary {
                  { "action", "Login" },
                  { "controller", "Account" },
                  { "area", "" },
                  { "returnUrl", HttpContext.Current.Request.Url }
                  }
              );
            }
        }
    }

Comment utiliser ce

[AuthorizeRole(Rolenames.Admin,Rolenames.Member)]

public ActionResult Index()
{
return View();
}

InformationsquelleAutor kinzzy goel

À L'Aide De AspNetCore 2.x, vous devez aller d'une manière un peu différente:

[AttributeUsage(AttributeTargets.Method | AttributeTargets.Class, Inherited = true, AllowMultiple = true)]
public class AuthorizeRoleAttribute : AuthorizeAttribute
{
    public AuthorizeRoleAttribute(params YourEnum[] roles)
    {
        Policy = string.Join(",", roles.Select(r => r.GetDescription()));
    }
}

simplement l'utiliser comme ceci:

[Authorize(YourEnum.Role1, YourEnum.Role2)]

InformationsquelleAutor Daniel DirtyNative Martin

Vous devez vous connecter pour publier un commentaire.