Permitir múltiples roles para acceder a la acción del controlador

Question

Ahora mismo decorar un método como este para permitir que los "miembros" para acceder a mi acción del controlador

[Authorize(Roles="members")] 

¿Cómo puedo permitir más de una función? Por ejemplo, el siguiente no funciona pero muestra lo que estoy tratando de hacer (permitir que los "miembros" y el acceso "admin"):

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

Answer 1

Otra opción es utilizar un solo filtro autorización, según las informados pero quitar las citas internas.

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

Answer 2

Si desea utilizar las funciones personalizadas, usted puede hacer esto:

CustomRoles clase:

public static class CustomRoles 
{ 
    public const string Administrator = "Administrador"; 
    public const string User = "Usuario"; 
} 

Uso

[Authorize(Roles = CustomRoles.Administrator +","+ CustomRoles.User)] 

Si tiene pocos papeles, tal vez sea posible Combínelos (para mayor claridad) como este:

public static class CustomRoles 
{ 
    public const string Administrator = "Administrador"; 
    public const string User = "Usuario"; 
    public const string AdministratorOrUser = Administrator + "," + User; 
} 

Uso

[Authorize(Roles = CustomRoles.AdministratorOrUser)] 

Answer 3

Para MVC4, utilizando un Enum (UserRoles) con mis papeles, utilizo una costumbre AuthorizeAttribute.

En mi acción controlada, lo hago:

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

Y utilizo una costumbre AuthorizeAttribute así:

[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; 
     } 
    } 
} 

Esto es parte de FNHMVC modifed de Fabricio Martínez Tamayo https://github.com/fabriciomrtnz/FNHMVC/

Answer 4

Una posible simplificación sería la subclase AuthorizeAttribute:

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

Uso:

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

vista semántico que es la misma que la respuesta de Jim Schmehil.

Answer 5

código Mejor con la adición de una subclase 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 } 
        } 
      ); 
      } 
     } 
    } 

Cómo utilizar este

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

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

Answer 6

Otra solución clara, se puede usar constantes para mantener la convención y añadir múltiples [Autorizar] atributos.Mira esto:

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

Luego, en el controlador:

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

Answer 7

Si usted se encuentra la aplicación de esos 2 papeles a menudo se puede envolver en su propio Autorizar. Esto es realmente una extensión de la respuesta aceptada.

using System.Web.Mvc; 

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

Y luego, aplique su nueva autorización a la Acción. Creo que esto se ve más limpio y se lee fácilmente.

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