Roles

Rollen

Alexyas rollenbasierte Zugriffssystem -Dienstprogramme.

Inhalt

• Berechtigungen erstellen
• Rollen erstellen
• Hinzufügen von Berechtigungen zu Rollen
• Benutzer erstellen

Berechtigungen erstellen

Berechtigungen sind der Weg für autorisierte Benutzer, um bestimmte Aktionen auszuführen.

Die AlexyaRolesPermission stellt eine Erlaubnis dar, die einer bestimmten Rolle zugeordnet werden kann.

Eine Erlaubnis besteht aus einer Kennung, einem Titel und einer Statusflagge.

Sie können diese Klasse problemlos erweitern, um mehr Funktionen wie alternative Namen zu liefern, Ränge ...

In einem Dateisystem sollte beispielsweise jeder Benutzer Berechtigungen zum Lesen/Schreiben in bestimmte Dateien haben:

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

Rollen erstellen

Rollen sind die Behälter verschiedener Berechtigungen.

Die Klasse AlexyaRolesRole ist eine Rolle für sich.

Es hat eine Kennung für die Rolle, einen Titel und eine Auswahl an Permission mit den gewährten Berechtigungen für diese Rolle. Alternativ kann eine Rolle eine Elternrolle für die Vererbung spielen.

Es hat auch eine Ganzzahl, die die Priorität der Rolle darstellt, je größer die Zahl, die Priorität.

Die Methode hasPermission akzeptiert eine Kennung einer Genehmigung oder einer Instanz der Genehmigung und überprüft, ob diese Rolle mit der Genehmigung erteilt wurde.

Für eine kürzere Version können Sie can verwenden, weil kürzer> länger.

Beispiel:

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

Hinzufügen von Berechtigungen zu Rollen

Sobald Sie über die Berechtigungen und Rollen verfügen, müssen Sie angeben, welche Rollen die Berechtigungen erteilt haben.

Eine Berechtigung kann aktiviert, deaktiviert oder vererbt werden. Wenn eine Erlaubnis erbelt wird, überprüft die Rolle den Status dieser Erlaubnis in der übergeordneten Rolle, wenn es keine Elternrolle gibt, wird sie als behindert behandelt.

Das Hinzufügen von Berechtigungen zu Rollen ist so einfach wie das Aufrufen der addPermission -Methode mit der Hinzufügen von Erlaubnis.

Beispiel:

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

Um zu überprüfen, ob eine Rolle eine bestimmte Genehmigung erteilt hat, können Sie die hasPermission oder can -Methoden verwenden:

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

Die Methode getPermission gibt eine Erlaubnis aus der Rolle zurück:

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

Benutzer erstellen

Nachdem wir die Rollen und Berechtigungen haben, müssen Benutzer sie zuweisen.

Die Klasse AlexyaRolesUser repräsentiert einen Benutzer, bei dem die Rollen zugewiesen werden.

Es ist die Klasse, die Sie erweitern sollten, um Ihren Benutzern Rollen hinzuzufügen, da sie die hasPermission und can zur Überprüfung hinzufügen, ob dieser Benutzer eine Erlaubnis erteilt hat.

Es verfügt auch über die Methoden, addRole und removeRole zum Hinzufügen/Entfernen von Rollen hinzufügen/entfernen.

Beispiel:

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