Roles

Papéis

Utilitários de sistema de acesso baseados em papel de Alexya.

Conteúdo

• Criando permissões
• Criando papéis
• Adicionando permissões a funções
• Criando usuários

Criando permissões

As permissões são a maneira de os usuários autorizados executar determinadas ações.

A Classe AlexyaRolesPermission representa uma permissão que pode ser atribuída a uma função específica.

Uma permissão consiste em um identificador, um título e um sinalizador de status.

Você pode estender facilmente esta classe para fornecer mais funcionalidades, como nomes alternativos, classificações ...

Por exemplo, em um sistema de arquivos, cada usuário deve ter permissões para ler/gravar em determinados arquivos:

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

Criando papéis

Funções são os recipientes de várias permissões.

A AlexyaRolesRole representa um papel por si só.

Ele tem um identificador para o papel, um título e uma variedade de Permission com as permissões concedidas para esse papel. Como alternativa, uma função pode ter um papel pai de herança.

Ele também possui um número inteiro representando a prioridade do papel, quanto maior o número, a maior prioridade que possui.

O método hasPermission aceita um identificador de uma permissão ou uma instância da permissão e verifica se essa função foi concedida com a permissão.

Para uma versão mais curta, você pode usar can , 'porque mais curto> mais.

Exemplo:

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

Adicionando permissões a funções

Depois de ter as permissões e funções, você precisa especificar quais funções concederam quais permissões.

Uma permissão pode ser ativada, desativada ou herdada. Se uma permissão for herdada, a função verificará o status dessa permissão na função pai, se não houver função de pai, ela será tratada como desativada.

Adicionar permissões às funções é tão fácil quanto chamar o método addPermission com a permissão para adicionar.

Exemplo:

 $ 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 se uma função concedeu uma certa permissão, você pode usar a hasPermission ou can métodos:

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

O método getPermission retorna uma permissão da função:

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

Criando usuários

Agora que temos as funções e permissões, precisamos que os usuários os atribuam.

A classe AlexyaRolesUser representa um usuário, onde as funções são atribuídas.

É a classe que você deve se estender para adicionar funções aos seus usuários, pois fornece a hasPermission e can métodos para verificar se esse usuário tiver alguma permissão concedida.

Ele também possui os métodos addRole e removeRole para adicionar/remover funções.

Exemplo:

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