it-swarm.com.de

Erlauben Sie mehreren Rollen den Zugriff auf die Controller-Aktion

Im Moment dekoriere ich eine Methode wie diese, um "Mitgliedern" den Zugriff auf meine Controller-Aktion zu ermöglichen

[Authorize(Roles="members")]

Wie erlaube ich mehr als eine Rolle? Zum Beispiel funktioniert das Folgende nicht, aber es zeigt, was ich versuche ("Mitglieder" und "Admin" Zugriff erlauben):

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

Eine andere Option besteht darin, einen einzelnen Autorisierungsfilter zu verwenden, während Sie den Beitrag veröffentlichen, die inneren Angebote jedoch entfernen.

[Authorize(Roles="members, admin")]
529
Jim Schmehil

Wenn Sie benutzerdefinierte Rollen verwenden möchten, können Sie Folgendes tun:

CustomRoles Klasse: 

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

Verwendungszweck

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

Wenn Sie nur wenige Rollen haben, können Sie sie (zur Verdeutlichung) folgendermaßen kombinieren:

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

Verwendungszweck

[Authorize(Roles = CustomRoles.AdministratorOrUser)]
111
Pablo Claus

Eine mögliche Vereinfachung wäre die Unterklasse AuthorizeAttribute:

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

Verwendungszweck:

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

Semantisch ist es das Gleiche wie Jim Schmehils Antwort.

70
Mihkel Müür

Für MVC4 verwende ich eine Enum (UserRoles) mit meinen Rollen und verwende eine benutzerdefinierte AuthorizeAttribute.

Bei meiner kontrollierten Aktion mache ich:

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

Und ich benutze eine benutzerdefinierte AuthorizeAttribute so:

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

Dies ist Teil der modifizierten FNHMVC von Fabricio Martínez Tamayo https://github.com/fabriciomrtnz/FNHMVC/

16

Wenn Sie feststellen, dass Sie diese beiden Rollen häufig anwenden, können Sie sie in ihre eigenen Berechtigungen einbetten. Dies ist wirklich eine Erweiterung der akzeptierten Antwort.

using System.Web.Mvc;

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

Wenden Sie dann Ihre neue Berechtigung für die Aktion an. Ich denke, das sieht sauberer aus und lässt sich leicht lesen.

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

Besserer Code durch Hinzufügen einer Unterklasse 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 }
                  }
              );
            }
        }
    }

Wie benutzt man das?

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

public ActionResult Index()
{
return View();
}
1
kinzzy goel

Eine weitere klare Lösung: Sie können Konstanten verwenden, um Konventionen einzuhalten und mehrere [Authorize] -Attribute hinzuzufügen. Überprüfen Sie dies heraus:

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

Dann in der Steuerung:

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

Bei Verwendung von AspNetCore 2.x müssen Sie einen anderen Weg gehen:

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

benutze es einfach so:

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