Buenas tardes

Estoy armando un API de autorización para un cliente y ya que estoy
aprovecho armar algo mas o menos formal.
La idea es poder desacoplar, sobre todo si estamos en una aplicación MVC,
la autorización del código.

El proyecto esta publicado en Assembla bajo el nombre DACAuthorization como
opensource, si quieren pegarle una mirada y hacer sugerencias será
bienvenido. ( Hay mucho código subido pero poca funcionalidad aun )

El objetivo es:
En vez de ( miren la linea en negrita ):

        [Autorize]
        public class HomeController : Controller
        {

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

                *[Authorize(Roles="Role_1, Role_3", Users="User_A, User_Z")]*
                public ActionResult Info()

Poder hacer simplemente:

        [Autorize] // Se apoya en la forma declarariva del web config.
        public class HomeController : Controller
        {
                public ActionResult Index()
                {
                        ViewBag.Message = "Welcome to ASP.NET MVC!";
                        return View();
                }

                *[DACAuthorize]* // Infiere los Roles y usuarios declarados
externamente, mediante DACAuthorization
                public ActionResult Info()
                {

O, en vez de:

.Visible(principal.IsInRole("AlgunRole"))

Hacer:

.Visible(RolesPrivileges.IsInSameRoleFor(MySubject,
BasicActionsEnum.Agregar))// MySubject y BasicActionsEnum representan
Controller type y Action respectivamente.

Para alcanzar el objetivo implementa un mecanismo de sinónimos entre
acciones y valores enumerados, lo mismo para asociar Roles de la aplicación
a los definidos por el RoleProvider que este configutrado, etc, etc.



Nada de esto invalida el esquema de Authorization de aspnet, solo lo
complementa.
El framework esta compuesto por una serie de clases y expone servicios, se
integra a una aplicación web MVC mediante un event handler que se declara
en el web.config.

[Flags()]
public enum BasicActionsEnum
{
    Add = Math.Pow(2, 0),
    Update = Math.Pow(2, 1),
    Delete = Math.Pow(2, 2),
    List = Math.Pow(2, 3),
    Export = Math.Pow(2, 4),
    Execute = Math.Pow(2, 5),
    All = BasicActionsEnum.Add | BasicActionsEnum.Update | .......

<synonyms>
        <actions>
              <add action="List" synonymous="index,Exportar" />
              <add action="Update" synonymous="update,updateajax" />
              <add action="Add" synonymous="alta,altaajax" />
        </actions>
        <roles>
              <add approle="Administrador" 
rolename="SISTEMA_ZZZZ_ADMINISTRADOR" />
              <add approle="Supervisor" rolename="SISTEMA_ZZZZ__SUPERVISOR" />
              <add approle="Operador" rolename="SISTEMA_ZZZZ__OPERADOR" />
              <add approle="Consultas" rolename="SISTEMA_ZZZZ__CONSULTAS" />
         </roles>
</synonyms>

Hay bastante mas, la idea es que en forma declarativa se desacople el
código de la aplicación del manejo de la Autorización.

wiki http://www.assembla.com/wiki/show/dacauthorization
svn http://subversion.assembla.com/svn/dacauthorization

Perdón por el OT


-- 
*Daniel A. Calvin*
Cooperator Team Member

Responder a