Roles

Roles

Utilidades del sistema de acceso basado en roles de Alexya.

Contenido

• Creación de permisos
• Creación de roles
• Agregar permisos a los roles
• Creación de usuarios

Creación de permisos

Los permisos son la forma de los usuarios autorizados para realizar ciertas acciones.

La clase AlexyaRolesPermission representa un permiso que puede asignarse a un rol específico.

Un permiso consiste en un identificador, un título y una bandera de estado.

Puede extender fácilmente esta clase para proporcionar más funcionalidad, como nombres alternativos, rangos ...

Por ejemplo, en un sistema de archivos, cada usuario debe tener permisos para leer/escribir en ciertos archivos:

 <?php
namespace Application  RBAC  Permissions ;

use Alexya  Roles  Permission ;

class Read extends Permission
{
    /**
     * Constructor.
     */
    public function __construct ()
    {
        parent :: __construct ( 1 , " read " , Permission:: STATUS_INHERITED );
    }
}

class Write extends Permission
{
    /**
     * Constructor.
     */
    public function __construct ()
    {
        parent :: __construct ( 2 , " write " , Permission:: STATUS_INHERITED );
    }
}

Creación de roles

Los roles son los contenedores de varios permisos.

La clase AlexyaRolesRole representa un papel por sí mismo.

Tiene un identificador para el papel, un título y una variedad de Permission con los permisos otorgados para este rol. Alternativamente, un papel puede tener un papel principal para la herencia.

También tiene un entero que representa la prioridad del papel, cuanto mayor sea el número, más prioridad tiene.

El método hasPermission acepta un identificador de un permiso o una instancia del permiso y verifica que este rol se ha otorgado con el permiso.

Para una versión más corta, puede usar can , 'porque más corto> más largo.

Ejemplo:

 namespace Application  RBAC  Roles ;

use Alexya  Roles  Role ;

class CanRead extends Role
{
    /**
     * Constructor
     */
    public function __construct ()
    {
        parent :: __construct ( 1 , " can_read " , 1 );
    }
}

class CanWrite extends Role
{
    /**
     * Constructor
     */
    public function __construct ()
    {
        parent :: __construct ( 2 , " can_write " , 1 );
    }
}

class CanReadAndWrite extends Role
{
    /**
     * Constructor.
     */
    public function __construct ()
    {
        parent :: __construct ( 3 , " can_read_and_write " , 2 );
    }
}

Agregar permisos a los roles

Una vez que tenga los permisos y roles, debe especificar qué roles ha otorgado qué permisos.

Se puede habilitar, deshabilitar o heredar un permiso. Si se hereda un permiso, el rol verificará el estado de ese permiso en el rol principal, si no hay un rol principal, se tratará como discapacitado.

Agregar permisos a los roles es tan fácil como llamar al método addPermission con el permiso para agregar.

Ejemplo:

 $ canRead = new CanRead ();
$ canRead -> addPermission ( new Read ());

$ canWrite = new CanWrite ();
$ canWrite -> addPermission ( new Write ());

$ canReadAndWrite = new CanReadAndWrite ();
$ canReadAndWrite -> addPermission ( new Read ());
$ canReadAndWrite -> addPermission ( new Write ());

// Alternatively you could have set the parent role like this:
// $canReadAndWrite = new CanReadAndWrite();
// $canReadAndWrite->parent = $canRead;
// $canReadAndWrite->addPermission(new Write());

Para verificar si un rol ha otorgado un cierto permiso, puede usar los métodos hasPermission o can :

 $ canRead -> can ( " read " ); // true
$ canRead -> can ( 2 ); // false (Write permission has ID 2)
$ canRead -> can ( new Read ()); // true

El método getPermission devuelve un permiso del rol:

 $ read  = $ canRead -> getPermission ( new Read ()); // The Read permission sent through `addPermission`
$ write = $ canRead -> getPermission ( " write " );    // null; 

Creación de usuarios

Ahora que tenemos los roles y permisos, necesitamos usuarios para asignarlos.

La clase AlexyaRolesUser representa a un usuario, donde se asignan los roles.

Es la clase que debe extender para agregar roles a sus usuarios, ya que proporciona el hasPermission y can métodos para verificar si este usuario tiene algún permiso otorgado.

También tiene los métodos addRole y removeRole para agregar/eliminar roles.

Ejemplo:

 $ user = new User ();

$ user -> addRole ( 2 );

$ user -> can ( new Read ());  // false
$ user -> can ( new Write ()); // true

$ user -> addRole ( new CanRead ());

$ user -> can ( " read " );  // true
$ user -> can ( new Write ()); // true

$ user -> getRole ( " can_write " )
     -> getPermission ( " write " )
     -> status = Permission:: STATUS_DISABLED ;

$ user -> can ( new Read ());  // true
$ user -> can ( new Write ()); // false

$ user -> addRole ( new CanReadAndWrite ());

$ user -> can ( new Read ());  // true
$ user -> can ( new Write ()); // true because the priority of `CanReadAndWrite` is bigger than the `CanWrite` priority.