Autoriser plusieurs rôles d'accéder à l'action du contrôleur

Question

En ce moment, je décore une méthode comme celui-ci pour permettre à « membres » d'accéder à mon action du contrôleur

[Authorize(Roles="members")] 

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

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

Answer 1

Une autre option est d'utiliser un seul filtre authorize que vous avez publié, mais retirer les citations intérieures.

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

Answer 2

Si vous voulez 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, vous pouvez peut-être combinez-les (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)] 

Answer 3

Pour MVC4, en utilisant un Enum (UserRoles) avec mes rôles, j'utilise une coutume AuthorizeAttribute.

Sur mon action contrôlée, je fais:

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

Et j'utilise une coutume 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; 
     } 
    } 
} 

Cela fait partie de modifed FNHMVC par Fabricio Martínez Tamayo https://github.com/fabriciomrtnz/FNHMVC/

Answer 4

Une simplification possible serait de sous-classe AuthorizeAttribute:

public class RolesAttribute : AuthorizeAttribute 
{ 
    public RolesAttribute(params string[] roles) 
    { 
     Roles = String.Join(",", roles); 
    } 
} 

Utilisation:

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

sémantiquement il est le même que la réponse de Jim Schmehil.

Answer 5

Code mieux 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(); 
} 

Answer 6

Une autre solution claire, vous pouvez utiliser des constantes pour maintenir la convention et ajouter plusieurs attributs [Authorize].Check this out:

public static class RolesConvention 
{ 
    public const string Administrator = "Administrator"; 
    public const string Guest = "Guest"; 
} 

Ensuite, dans le contrôleur:

[Authorize(Roles = RolesConvention.Administrator)] 
[Authorize(Roles = RolesConvention.Guest)] 
[Produces("application/json")] 
[Route("api/[controller]")] 
public class MyController : Controller 

Answer 7

Si vous vous appliquer ces 2 rôles que vous pouvez souvent les envelopper trouvent dans leur propre Autorisez. C'est vraiment une extension de la réponse acceptée.

using System.Web.Mvc; 

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

Ensuite, appliquez votre nouvelle autorisation à l'action. Je pense que cela semble plus propre et se lit facilement.

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