Roles

Rôles

Les utilitaires du système d'accès basé sur les rôles d'Alexya.

Contenu

• Créer des autorisations
• Créer des rôles
• Ajout d'autorisations aux rôles
• Créer des utilisateurs

Créer des autorisations

Les autorisations sont le moyen de faire des utilisateurs autorisés à effectuer certaines actions.

La classe AlexyaRolesPermission représente une autorisation qui peut être attribuée à un rôle spécifique.

Une autorisation consiste en un identifiant, un titre et un drapeau de statut.

Vous pouvez facilement étendre cette classe pour fournir plus de fonctionnalités telles que des noms alternatifs, les rangs ...

Par exemple, dans un système de fichiers, chaque utilisateur doit avoir des autorisations pour lire / écrire dans certains fichiers:

 <?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 );
    }
}

Créer des rôles

Les rôles sont les conteneurs de diverses autorisations.

La classe AlexyaRolesRole représente un rôle en soi.

Il a un identifiant pour le rôle, un titre et un éventail d' Permission avec les autorisations accordées pour ce rôle. Alternativement, un rôle peut avoir un rôle parent pour l'héritage.

Il a également un entier représentant la priorité du rôle, plus le nombre est important, plus il est prioritaire.

La hasPermission de la méthode accepte un identifiant d'une autorisation ou d'une instance de l'autorisation et des vérifications selon lesquelles ce rôle a été accordé avec l'autorisation.

Pour une version plus courte, vous pouvez utiliser can , 'Cuz Shorter> plus longtemps.

Exemple:

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

Ajout d'autorisations aux rôles

Une fois que vous avez les autorisations et les rôles, vous devez spécifier les rôles qui ont accordé les autorisations.

Une autorisation peut être activée, désactivée ou héritée. Si une autorisation est héritée, le rôle vérifie le statut de cette autorisation dans le rôle parent, s'il n'y a pas de rôle parent, il sera traité comme désactivé.

L'ajout d'autorisations aux rôles est aussi simple que d'appeler la méthode addPermission avec l'autorisation d'ajouter.

Exemple:

 $ 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());

Pour vérifier si un rôle a accordé une certaine autorisation, vous pouvez utiliser les méthodes hasPermission ou can :

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

La méthode getPermission renvoie une autorisation du rôle:

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

Créer des utilisateurs

Maintenant que nous avons les rôles et les autorisations, nous avons besoin que les utilisateurs les affectent.

La classe AlexyaRolesUser représente un utilisateur, où les rôles sont attribués.

C'est la classe que vous devriez étendre afin d'ajouter des rôles à vos utilisateurs car il fournit la hasPermission et can méthodes de vérification si cet utilisateur a l'autorisation accordée.

Il dispose également des méthodes addRole et removeRole pour ajouter / supprimer les rôles.

Exemple:

 $ 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.