ASP.NET MVC-alternatywa dla dostawcy ról?

Zaimplementowałem dostawcę ról w oparciu o post @TheCloudlessSky tutaj. Jest kilka rzeczy, które myślałem, że mogę dodać i podzielić się tym, co zrobiłem. Najpierw, jeśli chcesz użyć klasy RequirepPermission dla filtrów akcji jako atrybutu, musisz zaimplementować klasę ActionFilterAttribute dla klasy RequirepPermission.

Klasy interfejsu IAuthenticationService i IAuthorizationService

public interface IAuthenticationService
{
    void SignIn(string userName, bool createPersistentCookie);
    void SignOut();
}

public interface IAuthorizationService
{
    bool Authorize(UserSession user, string[] requiredRoles);
}

FormsAuthenticationService Klasa

/// <summary>
/// This class is for Form Authentication
/// </summary>
public class FormsAuthenticationService : IAuthenticationService
{

    public void SignIn(string userName, bool createPersistentCookie)
    {
        if (String.IsNullOrEmpty(userName)) throw new ArgumentException(@"Value cannot be null or empty.", "userName");

        FormsAuthentication.SetAuthCookie(userName, createPersistentCookie);
    }

    public void SignOut()
    {
        FormsAuthentication.SignOut();
    }
}

UserSession calss

public class UserSession
{
    public string UserName { get; set; }
    public IEnumerable<string> UserRoles { get; set; }
}

Kolejny punkt to FormsAuthorizationServiceklasa i jak możemy przypisać użytkownika do httpContext.Session["CurrentUser"]. My Podejściem w tej sytuacji jest utworzenie nowej instancji klasy userSession i bezpośrednie przypisanie użytkownika z httpContext.User.Identity.Name do zmiennej userSession, jak widać w klasie FormsAuthorizationService.

[AttributeUsageAttribute(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Constructor | AttributeTargets.Method, Inherited = false)]
public class RequirePermissionAttribute : ActionFilterAttribute, IAuthorizationFilter
{
    #region Fields

    private readonly IAuthorizationService _authorizationService;
    private readonly string[] _permissions;

    #endregion

    #region Constructors

    public RequirePermissionAttribute(string requiredRoles)
    {
        _permissions = requiredRoles.Trim().Split(',').ToArray();
        _authorizationService = null;
    }

    #endregion

    #region Methods

    private IAuthorizationService CreateAuthorizationService(HttpContextBase httpContext)
    {
        return _authorizationService ?? new FormsAuthorizationService(httpContext);
    }

    public void OnAuthorization(AuthorizationContext filterContext)
    {
        var authSvc = CreateAuthorizationService(filterContext.HttpContext);
        // Get the current user... you could store in session or the HttpContext if you want too. It would be set inside the FormsAuthenticationService.
        if (filterContext.HttpContext.Session == null) return;
        if (filterContext.HttpContext.Request == null) return;
        var success = false;
        if (filterContext.HttpContext.Session["__Roles"] != null)
        {
            var rolesSession = filterContext.HttpContext.Session["__Roles"];
            var roles = rolesSession.ToString().Trim().Split(',').ToList();
            var userSession = new UserSession
            {
                UserName = filterContext.HttpContext.User.Identity.Name,
                UserRoles = roles
            };
            success = authSvc.Authorize(userSession, _permissions);
        }
        if (success)
            {
                // Since authorization is performed at the action level, the authorization code runs
                // after the output caching module. In the worst case this could allow an authorized user
                // to cause the page to be cached, then an unauthorized user would later be served the
                // cached page. We work around this by telling proxies not to cache the sensitive page,
                // then we hook our custom authorization code into the caching mechanism so that we have
                // the final say on whether or not a page should be served from the cache.
                var cache = filterContext.HttpContext.Response.Cache;
                cache.SetProxyMaxAge(new TimeSpan(0));
                cache.AddValidationCallback((HttpContext context, object data, ref HttpValidationStatus validationStatus) =>
                                                {
                                                    validationStatus = OnCacheAuthorization(new HttpContextWrapper(context));
                                                }, null);
            }
            else
            {
                HandleUnauthorizedRequest(filterContext);
            }
    }

    private static void HandleUnauthorizedRequest(AuthorizationContext filterContext)
    {
        // Ajax requests will return status code 500 because we don't want to return the result of the
        // redirect to the login page.
        if (filterContext.RequestContext.HttpContext.Request.IsAjaxRequest())
        {
            filterContext.Result = new HttpStatusCodeResult(500);
        }
        else
        {
            filterContext.Result = new HttpUnauthorizedResult();
        }
    }

    private HttpValidationStatus OnCacheAuthorization(HttpContextBase httpContext)
    {
        var authSvc = CreateAuthorizationService(httpContext);
        if (httpContext.Session != null)
        {
            var success = false;
            if (httpContext.Session["__Roles"] != null)
            {
                var rolesSession = httpContext.Session["__Roles"];
                var roles = rolesSession.ToString().Trim().Split(',').ToList();
                var userSession = new UserSession
                {
                    UserName = httpContext.User.Identity.Name,
                    UserRoles = roles
                };
                success = authSvc.Authorize(userSession, _permissions);
            }
            return success ? HttpValidationStatus.Valid : HttpValidationStatus.IgnoreThisRequest;
        }
        return 0;
    }

    #endregion
}

internal class FormsAuthorizationService : IAuthorizationService
{
    private readonly HttpContextBase _httpContext;

    public FormsAuthorizationService(HttpContextBase httpContext)
    {
        _httpContext = httpContext;
    }

    public bool Authorize(UserSession userSession, string[] requiredRoles)
    {
        return userSession.UserRoles.Any(role => requiredRoles.Any(item => item == role));
    }
}

Następnie w kontrolerze po uwierzytelnieniu użytkownika można pobrać role z bazy danych i przypisać je do sesji ról:

var roles = Repository.GetRolesByUserId(Id);
if (ControllerContext.HttpContext.Session != null)
   ControllerContext.HttpContext.Session.Add("__Roles",roles);
FormsService.SignIn(collection.Name, true);

Po wylogowaniu się użytkownika z systemu możesz wyczyścić sesję

FormsService.SignOut();
Session.Abandon();
return RedirectToAction("Index", "Account");

Zastrzeżenie w tym modelu jest takie, że gdy użytkownik jest zalogowany do system, jeśli rola jest przypisana do użytkownika, autoryzacja nie działa, chyba że wyloguje się i loguje z powrotem w systemie.

Inną rzeczą jest to, że nie ma potrzeby posiadania osobnej klasy dla ról, ponieważ możemy pobrać role bezpośrednio z bazy danych i ustawić je w sesji ról w kontrolerze.

Po zakończeniu implementacji wszystkich tych kodów ostatnim krokiem jest powiązanie tego atrybutu z metodami w kontrolerze:

[RequirePermission("Admin,DM")]
public ActionResult Create()
{
return View();
}

Jeśli używasz Castle Windsor Dependency Injection, możesz wprowadzić listy Roleproviderów, które mogą być użyte do ustalenia praw Użytkownika z dowolnego źródła, które zdecydujesz się zaimplementować.

Http://ivida.co.uk/2011/05/18/mvc-getting-user-roles-from-multiple-sources-register-and-resolve-arrays-of-dependencis-using-the-fluent-api/

Nie musisz używać klasy statycznej dla ról. Na przykład, SqlRoleProvider pozwala zdefiniować role w bazie danych.

Oczywiście, jeśli chcesz odzyskać role z własnej warstwy usług, nie jest tak trudno stworzyć własnego dostawcę ról - naprawdę nie ma zbyt wielu metod do wdrożenia.

Możesz zaimplementować własne członkostwo i rolę dostawców poprzez nadpisanie odpowiednich interfejsów.

Jeśli chcesz zacząć od zera, zazwyczaj tego typu rzeczy są zaimplementowane jako niestandardowy moduł http, który przechowuje poświadczenia użytkowników w httpcontext lub sesji. Tak czy inaczej prawdopodobnie będziesz chciał ustawić plik cookie z jakimś tokenem uwierzytelniania.