lock

Bloquear - Acl para PHP 5.4+

Lamento dizer que o Lock não é mantido atualmente. Não poderei oferecer apoio ou aceitar novas contribuições no momento. Outras prioridades estão me impedindo de colocar no Lock o trabalho que ele merece. Eventualmente tentarei retomar o trabalho, mas infelizmente não posso dizer quando. Meus agradecimentos vão para todos os colaboradores e usuários.

- Seca

Lock é um pacote Acl flexível baseado em driver para PHP 5.4+ .

Criado por Dries Vints. Tornado possível graças ao BeatSwitch. Inspirado em Autoridade por Matthew Machuga. Logotipo de Jerry Low.

Índice

• Terminologia
• Características
• Introdução
• Motoristas
• Roteiro
• Instalação
• Uso
  • Implementando o contrato do chamador
  • Trabalhando com um driver estático
  • Trabalhando com um driver persistente
  • Configurando e verificando permissões
  • Limpando permissões
  • Configurando um alias de ação
  • Definindo um chamador de Deus
  • Trabalhando com funções
  • Trabalhando com condições
  • Recuperando recursos permitidos ou negados
  • Usando a característica LockAware
• API
• Construindo um driver
  • Testando seu driver
• Mantenedor
• Contribuindo
• Registro de alterações
• Licença

Terminologia

• Lock : uma instância acl para um assunto. Este pacote atualmente vem com um CallerLock e um RoleLock
• Caller : um objeto de identidade que pode ter permissões para fazer algo
• Driver : Um sistema de armazenamento para permissões que podem ser estáticas ou persistentes
• Permission : uma permissão contém uma ação e um recurso opcional (único). Pode ser uma Restriction ou um Privilege
• Restriction : Uma restrição impede que você execute uma ação (em um recurso opcional)
• Privilege : Um privilégio permite que você execute uma ação (em um recurso opcional)
• Action : Uma ação é algo que você pode ou não fazer
• Resource : um recurso pode ser um objeto onde você pode executar uma ou mais ações. Ele pode ter como alvo um determinado tipo de recurso ou um recurso específico por seu identificador exclusivo
• Role : uma função também pode conter várias permissões. Um chamador pode ter diversas funções. As funções podem herdar permissões de outras funções

Características

• Permissões ACL flexíveis para múltiplas identidades (chamadores)
• Drivers estáticos ou persistentes para armazenar permissões
• Aliases de ação
• Funções
• Condições (afirmações)
• Implemente facilmente a funcionalidade acl em seu chamador ou função com uma característica

Introdução

Lock difere de outros pacotes acl por tentar fornecer a maneira mais flexível de trabalhar com vários chamadores de permissão e armazenar permissões.

Ao trabalhar com o contrato Lock's Caller , você pode definir permissões em múltiplas identidades.

O contrato Driver permite uma maneira fácil de armazenar permissões em um sistema de armazenamento persistente ou estático. Um ArrayDriver estático padrão é fornecido com este pacote. Confira na lista abaixo mais drivers que já foram preparados para você. Ou crie o seu próprio implementando o contrato Driver .

Você pode definir e verificar permissões para recursos transmitindo manualmente o tipo de recurso e o identificador (opcional) ou pode implementar o contrato Resource em seus objetos para poder transmiti-los para bloqueio com mais facilidade.

O Manager permite uma maneira fácil de instanciar novas instâncias Lock , definir aliases de ação ou registrar funções.

Motoristas

Se você precisar de uma implementação específica da estrutura, escolha um dos drivers já preparados abaixo.

• ArrayDriver (enviado com este pacote)
• Laravel5

Roteiro

• Permissões de grupo
• Mais drivers (Symfony, Zend Framework, Doctrine, ...)
• Ouvintes de eventos

Instalação

Instale este pacote através do Composer.

$ composer require beatswitch/lock

Uso

Implementando o contrato do chamador

Toda identidade que deve ter permissão para fazer algo deve implementar o contrato BeatSwitchLockCallersCaller . O contrato Caller identifica um chamador, exigindo que ele retorne seu tipo e seu identificador exclusivo. Vejamos um exemplo abaixo.

 <?php

use BeatSwitch  Lock  Callers  Caller ;

class User implements Caller
{
    public function getCallerType ()
    {
        return ' users ' ;
    }

    public function getCallerId ()
    {
        return $ this -> id ;
    }

    public function getCallerRoles ()
    {
        return [ ' editor ' , ' publisher ' ];
    }
}

Ao adicionar a função getCallerType podemos identificar um grupo de chamadores através de um tipo único. Se em algum momento quiséssemos definir permissões para outro grupo de chamadores, poderíamos facilmente implementar o contrato em outro objeto.

 <?php

use BeatSwitch  Lock  Callers  Caller ;

class Organization implements Caller
{
    public function getCallerType ()
    {
        return ' organizations ' ;
    }

    public function getCallerId ()
    {
        return $ this -> id ;
    }

    public function getCallerRoles ()
    {
        return [ ' enterprise ' ];
    }
}

E assim podemos recuperar facilmente permissões para um tipo específico de chamador por meio de um driver.

Trabalhando com um driver estático

Se desejar configurar todas as suas permissões antecipadamente, você pode usar o ArrayDriver estático que acompanha o pacote. Isso permite que você defina uma lista de permissões para um chamador antes que seu aplicativo seja executado.

 use  BeatSwitch  Lock  Drivers  ArrayDriver ;
use  BeatSwitch  Lock  Lock ;
use  BeatSwitch  Lock  Manager ;

// Create a new Manager instance.
$ manager = new Manager ( new ArrayDriver ());

// Instantiate a new Lock instance for an object which implements the Caller contract.
$ lock = $ manager -> caller ( $ caller );

// Set some permissions.
$ lock -> allow ( ' manage_settings ' );
$ lock -> allow ( ' create ' , ' events ' );

// Use the Lock instance to validate permissions on the given caller.
$ lock -> can ( ' manage_settings ' ); // true: can manage settings
$ lock -> can ( ' create ' , ' events ' ); // true: can create events
$ lock -> cannot ( ' update ' , ' events ' ); // true: cannot update events
$ lock -> can ( ' delete ' , ' events ' ); // false: cannot delete events

Trabalhando com um driver persistente

Trabalhar com um driver persistente permite armazenar permissões em uma camada de armazenamento persistente e ajustá-las durante o tempo de execução. Por exemplo, se você implementasse o driver Laravel 5, ele armazenaria as permissões para um banco de dados usando o componente de banco de dados do Laravel. Ao criar sua própria UI, você pode facilmente anexar a funcionalidade acl deste pacote para criar, por exemplo, um sistema de gerenciamento de usuários onde usuários diferentes têm permissões diferentes.

Vamos dar uma olhada em um controlador de gerenciamento de usuários muito básico para ver como isso é feito. Assumiremos que obteremos uma instância do gerenciador de bloqueio inicializada com nosso driver Laravel DB.

 <?php

use BeatSwitch  Lock  Manager ;

class UserManagementController extends BaseController
{
    protected $ lockManager ;

    public function __construct ( Manager $ lockManager )
    {
        $ this -> lockManager = $ lockManager ;
    }

    public function togglePermission ()
    {
        $ userId = Input:: get ( ' user ' );
        $ action = Input:: get ( ' action ' );
        $ resource = Input:: get ( ' resource ' );

        $ user = User:: find ( $ userId );

        $ this -> lockManager -> caller ( $ user )-> toggle ( $ action , $ resource );

        return Redirect:: route ( ' user_management ' );
    }
}

Cada vez que o método togglePermission for usado, a permissão do usuário para a ação e o tipo de recurso especificados será alternada.

Configurando e verificando permissões

Você pode allow ou deny que um chamador faça algo. Aqui estão algumas maneiras de definir e verificar permissões.

Permita que um chamador crie tudo.

 $ lock -> allow ( ' create ' );

$ lock -> can ( ' create ' ); // true

Permitir que um chamador crie apenas postagens.

 $ lock -> allow ( ' create ' , ' posts ' );

$ lock -> can ( ' create ' ); // false
$ lock -> can ( ' create ' , ' posts ' ); // true

Permitir que um chamador edite apenas uma postagem específica com um ID 5.

 $ lock -> allow ( ' edit ' , ' posts ' , 5 );

$ lock -> can ( ' edit ' ); // false
$ lock -> can ( ' edit ' , ' posts ' ); // false
$ lock -> can ( ' edit ' , ' posts ' , 5 ); // true

Permitir que um chamador edite todas as postagens, mas proibi-lo de editar uma com o ID 5.

 $ lock -> allow ( ' edit ' , ' posts ' );
$ lock -> deny ( ' edit ' , ' posts ' , 5 );

$ lock -> can ( ' edit ' , ' posts ' ); // true
$ lock -> can ( ' edit ' , ' posts ' , 5 ); // false

Alternar o valor de uma permissão.

 $ lock -> allow ( ' create ' );
$ lock -> can ( ' create ' ); // true

$ lock -> toggle ( ' create ' );
$ lock -> can ( ' create ' ); // false

Você pode permitir ou negar várias ações ao mesmo tempo e também verificar várias ações ao mesmo tempo.

 $ lock -> allow ([ ' create ' , ' edit ' ], ' posts ' );

$ lock -> can ( ' create ' , ' posts ' ); // true
$ lock -> can ([ ' create ' , ' edit ' ], ' posts ' ); // true
$ lock -> can ([ ' create ' , ' delete ' ], ' posts ' ); // false

Limpando permissões

Você pode limpar facilmente as permissões para uma combinação específica de ações e recursos.

 $ lock -> allow ([ ' create ' , ' edit ' ], ' posts ' );

$ lock -> clear ( ' edit ' , ' posts ' );

$ lock -> can ( ' edit ' , ' posts ' ); // false
$ lock -> can ( ' create ' , ' posts ' ); // true

Você também pode simplesmente limpar todas as permissões de uma instância de bloqueio.

 $ lock -> allow ( ' manage-posts ' );
$ lock -> allow ([ ' create ' , ' edit ' ], ' users ' );

$ lock -> clear ();

$ lock -> can ( ' manage-posts ' ); // false
$ lock -> can ( ' create ' , ' users ' ); // false

Configurando um alias de ação

Para agrupar diversas ações e defini-las todas de uma vez, você pode querer definir um alias de ação.

 $ lock -> alias ( ' manage ' , [ ' create ' , ' read ' , ' delete ' ]);
$ lock -> allow ( ' manage ' , ' posts ' );

$ lock -> can ( ' manage ' , ' posts ' ); // true
$ lock -> can ( ' create ' , ' posts ' ); // true
$ lock -> can ( ' delete ' , ' posts ' , 1 ); // true
$ lock -> can ( ' update ' , ' posts ' ); // false

Definindo um chamador de Deus

Você pode facilmente definir um chamador que tenha todas as permissões para tudo, passando o curinga all como uma ação na instância de bloqueio.

 $ lock -> allow ( ' all ' );

Agora, cada chamada de método "can" será validada como verdadeira para este chamador.

Trabalhando com funções

Lock fornece uma maneira fácil de trabalhar com funções. Você pode trabalhar com funções prontas para uso, mas se quiser trabalhar com herança, precisará registrar as funções na instância do gerenciador.

 $ manager -> setRole ( ' guest ' );
$ manager -> setRole ( ' user ' , ' guest ' ); // "user" will inherit all permissions from "guest"

Ou registre várias funções de uma só vez.

 $ manager -> setRole ([ ' editor ' , ' admin ' ], ' user ' ); // "editor" and "admin" will inherit all permissions from "user".

Vamos definir algumas permissões e ver como elas são resolvidas.

 // Allow a guest to read everything.
$ manager -> role ( ' guest ' )-> allow ( ' guest ' , ' read ' );

// Allow a user to create posts.
$ manager -> role ( ' user ' )-> allow ( ' create ' , ' posts ' );

// Allow an editor and admin to publish posts.
$ manager -> role ( ' editor ' )-> allow ( ' publish ' , ' posts ' );
$ manager -> role ( ' admin ' )-> allow ( ' publish ' , ' posts ' );

// Allow an admin to delete posts.
$ manager -> role ( ' admin ' )-> allow ( ' delete ' , ' posts ' );

// Let's assume our caller has the role of "editor" and check some permissions.
$ lock = $ manager -> caller ( $ caller );
$ lock -> can ( ' read ' ); // true
$ lock -> can ( ' delete ' , ' posts ' ); // false
$ lock -> can ( ' publish ' ); // false: we can't publish everything, just posts.
$ lock -> can ([ ' create ' , ' publish ' ], ' posts ' ); // true

Algo que você precisa saber é que as permissões no nível do chamador substituem as permissões no nível da função. Vamos ver como isso funciona.

Nosso chamador terá a função de usuário.

 $ manager -> caller ( $ caller )-> allow ( ' create ' , ' posts ' );

// Notice that we don't need to set the role in the
// manager first if we don't care about inheritance.
$ manager -> role ( ' user ' )-> deny ( ' user ' , ' create ' , ' posts ' );

$ manager -> caller ( $ caller )-> can ( ' create ' , ' posts ' ); // true: the user has explicit permission to create posts.

Trabalhando com condições

As condições são, na verdade, declarações que são verificações extras que você pode definir para permissões. Você pode passar um array com eles como último parâmetro de allow e deny . Todas as condições devem implementar a interface BeatSwitchLockPermissionsCondition .

Aviso: observe que atualmente as condições funcionam apenas com drivers estáticos.

Vamos configurar uma condição.

 <?php

use BeatSwitch  Lock  Lock ;
use BeatSwitch  Lock  Permissions  Condition ;
use BeatSwitch  Lock  Permissions  Permission ;
use BeatSwitch  Lock  Resources  Resource ;
use Illuminate  Auth  AuthManager ;

class LoggedInCondition implements Condition
{
    /**
     * The Laravel AuthManager instance
     *
     * @var IlluminateAuthAuthManager
     */
    protected $ auth ;

    /**
     * @param IlluminateAuthAuthManager $auth
     */
    public function __construct ( AuthManager $ auth )
    {
        $ this -> auth = $ auth ;
    }

    /**
     * Assert if the condition is correct
     *
     * @param BeatSwitchLockLock $lock                         The current Lock instance that's being used
     * @param BeatSwitchLockPermissionsPermission $permission The Permission that's being checked
     * @param string $action                                      The action passed to the can or cannot method
     * @param BeatSwitchLockResourcesResource|null $resource  The resource passed to the can or cannot method
     * @return bool
     */
    public function assert ( Lock $ lock , Permission $ permission , $ action , Resource $ resource = null )
    {
        // Condition will succeed if the user is logged in.
        return $ this -> auth -> check ();
    }
}

Agora vamos ver como isso funcionará ao configurar uma permissão.

 $ condition = App:: make ( ' LoggedInCondition ' );

$ lock -> allow ( ' create ' , ' posts ' , null , $ condition );
$ lock -> can ( ' create ' , ' posts ' ); // true if logged in, otherwise false.

Você também pode transmitir várias condições.

 $ lock -> allow ( ' create ' , ' posts ' , null , [ $ falseCondition , $ trueCondition ]);
$ lock -> can ( ' create ' , ' posts ' ); // false: there's at least one false condition

Você pode repassar quantas condições quiser, mas todas elas precisam ser bem-sucedidas para que a permissão funcione.

Você também pode usar um retorno de chamada, se desejar.

 $ lock -> allow ( ' create ' , ' posts ' , null , function ( $ lock , $ permission , $ action , $ resource = null ) {
    return false ;
});
$ lock -> can ( ' create ' , ' posts ' ); // false because the callback returns false.

Recuperando recursos permitidos ou negados

Se desejar recuperar uma lista de recursos que são permitidos ou negados para executar uma ação específica, você pode usar os métodos allowed e denied em uma instância Lock .

 $ lock -> allow ( ' update ' , ' users ' , 1 );
$ lock -> allow ( ' update ' , ' users ' , 2 );
$ lock -> allow ( ' update ' , ' users ' , 3 );
$ lock -> deny ( ' update ' , ' users ' , 2 );

$ lock -> allowed ( ' update ' , ' users ' ); // Returns [1, 3];
$ lock -> denied ( ' update ' , ' users ' ); // Returns [2];

Lembre-se de que você só pode recuperar IDs de recursos que tenham permissões definidas. Recursos que não forem cadastrados através do Lock não serão devolvidos.

Usando a característica LockAware

Você pode adicionar facilmente a funcionalidade acl ao seu chamador ou função implementando a característica BeatSwitchLockLockAware .

 <?php

use BeatSwitch  Lock  Callers  Caller ;
use BeatSwitch  Lock  LockAware ;

class Organization implements Caller
{
    use LockAware;

    public function getCallerType ()
    {
        return ' organizations ' ;
    }

    public function getCallerId ()
    {
        return $ this -> id ;
    }

    public function getCallerRoles ()
    {
        return [ ' enterprise ' ];
    }
}

Agora precisamos definir sua instância de bloqueio.

 $ caller -> setLock ( $ lock );

E agora seu chamador pode usar todos os métodos de bloqueio nele mesmo.

 $ caller -> can ( ' create ' , ' posts ' );
$ caller -> allow ( ' edit ' , ' pages ' );

Se você tem um chamador que implementa a característica LockAware , mas ainda não inicializou a instância de bloqueio do chamador, você pode facilmente tornar o bloqueio do chamador ciente usando o método makeCallerLockAware do gerenciador.

 $ caller = $ manager -> makeCallerLockAware ( $ caller );

E agora seu chamador poderá usar os métodos LockAware . Existe um método semelhante para funções.

 $ role = $ manager -> makeRoleLockAware ( ' guest ' );

Isso inicializará um objeto SimpleRole que já vem com a característica LockAware instalada.

API

BeatSwitchBloquearBloquear

Os métodos a seguir podem ser chamados em uma instância BeatSwitchLockLock .

pode

Verifica se o chamador atual tem permissão para fazer alguma coisa.

 can(
    string|array $action,
    string|BeatSwitchLockResourcesResource $resource = null,
    int $resourceId = null
)

não pode

Verifica se é proibido ao chamador atual fazer alguma coisa.

 cannot(
    string|array $action,
    string|BeatSwitchLockResourcesResource $resource = null,
    int $resourceId = null
)

permitir

Define uma permissão Privilege em um chamador para permitir que ele faça algo. Remove quaisquer restrições correspondentes.

 allow(
    string|array $action,
    string|BeatSwitchLockResourcesResource $resource = null,
    int $resourceId = null,
    BeatSwitchLockPermissionsCondition[] $conditions = []
)

negar

Define uma permissão Restriction para um chamador para impedi-lo de fazer algo. Remove quaisquer privilégios correspondentes.

 deny(
    string|array $action,
    string|BeatSwitchLockResourcesResource $resource = null,
    int $resourceId = null,
    BeatSwitchLockPermissionsCondition[] $conditions = []
)

alternar

Alterna o valor da permissão fornecida.

 toggle(
    string|array $action,
    string|BeatSwitchLockResourcesResource $resource = null,
    int $resourceId = null
)

permitido

Retorna todos os IDs em uma matriz do tipo de recurso fornecido no qual o sujeito pode executar a ação especificada.

 allowed(
    string|array $action,
    string|BeatSwitchLockResourcesResource $resourceType
)

negado

Retorna todos os IDs em uma matriz do tipo de recurso fornecido ao qual o sujeito não pode executar a ação especificada.

 denied(
    string|array $action,
    string|BeatSwitchLockResourcesResource $resourceType
)

BeatSwitchLockManager

Os métodos a seguir podem ser chamados em uma instância BeatSwitchLockManager .

chamador

Retorna uma instância BeatSwitchLockLock para um chamador.

 caller(
    BeatSwitchLockCallersCaller $caller
)

papel

Retorna uma instância BeatSwitchLockLock para uma função.

 role(
    BeatSwitchLockRolesRole $role
)

apelido

Adicione um alias para uma ou mais ações.

 alias(
    string $name,
    string|array $actions
)

definirRole

Defina uma ou mais funções e uma função opcional da qual herdar permissões.

 setRole(
    string|array $name,
    string $inherit = null
)

makeCallerLockAware

Define a instância de bloqueio para um chamador que implementa a característica LockAware . Retorna o chamador com a instância de bloqueio definida.

 makeCallerLockAware(
    BeatSwitchLockCallersCaller $caller
)

makeRoleLockAware

Define a instância de bloqueio para uma função que implementa a característica LockAware . Retorna a função com a instância de bloqueio definida.

 makeRoleLockAware(
    BeatSwitchLockRolesRole|string $role
)

Construindo um driver

Você pode criar facilmente um driver implementando o contrato BeatSwitchLockDriversDriver . Abaixo demonstraremos como criar nosso próprio driver persistente usando o Eloquent ORM do Laravel como mecanismo de armazenamento.

Assumiremos que temos uma classe de modelo CallerPermission com pelo menos as seguintes colunas de banco de dados:

• caller_type (varchar, 100)
• caller_id (int, 11)
• type (varchar, 10)
• action (varchar, 100)
• resource_type (varchar, 100, anulável)
• resource_id (int, 11, anulável)

E temos um modelo RolePermission com as seguintes colunas de banco de dados:

• role (varchar, 100)
• type (varchar, 10)
• action (varchar, 100)
• resource_type (varchar, 100, anulável)
• resource_id (int, 11, anulável)

Vamos verificar uma implementação completa do driver abaixo. Observe que para o método getCallerPermissions estamos usando a classe PermissionFactory para mapear facilmente os dados e criar objetos Permission a partir deles. O método createFromData do PermissionFactory aceitará matrizes e objetos.

 <?php

use BeatSwitch  Lock  Callers  Caller ;
use BeatSwitch  Lock  Drivers  Driver ;
use BeatSwitch  Lock  Permissions  Permission ;
use BeatSwitch  Lock  Permissions  PermissionFactory ;
use BeatSwitch  Lock  Roles  Role ;
use CallerPermission ;
use RolePermission ;

class EloquentDriver implements Driver
{
    /**
     * Returns all the permissions for a caller
     *
     * @param BeatSwitchLockCallersCaller $caller
     * @return BeatSwitchLockPermissionsPermission[]
     */
    public function getCallerPermissions ( Caller $ caller )
    {
        $ permissions = CallerPermission:: where ( ' caller_type ' , $ caller -> getCallerType ())
            -> where ( ' caller_id ' , $ caller -> getCallerId ())
            -> get ();

        return PermissionFactory:: createFromData ( $ permissions -> toArray ());
    }

    /**
     * Stores a new permission into the driver for a caller
     *
     * @param BeatSwitchLockCallersCaller $caller
     * @param BeatSwitchLockPermissionsPermission
     * @return void
     */
    public function storeCallerPermission ( Caller $ caller , Permission $ permission )
    {
        $ eloquentPermission = new CallerPermission ;
        $ eloquentPermission -> caller_type = $ caller -> getCallerType ();
        $ eloquentPermission -> caller_id = $ caller -> getCallerId ();
        $ eloquentPermission -> type = $ permission -> getType ();
        $ eloquentPermission -> action = $ permission -> getAction ();
        $ eloquentPermission -> resource_type = $ permission -> getResourceType ();
        $ eloquentPermission -> resource_id = $ permission -> getResourceId ();
        $ eloquentPermission -> save ();
    }

    /**
     * Removes a permission from the driver for a caller
     *
     * @param BeatSwitchLockCallersCaller $caller
     * @param BeatSwitchLockPermissionsPermission
     * @return void
     */
    public function removeCallerPermission ( Caller $ caller , Permission $ permission )
    {
        CallerPermission:: where ( ' caller_type ' , $ caller -> getCallerType ())
            -> where ( ' caller_id ' , $ caller -> getCallerId ())
            -> where ( ' type ' , $ permission -> getType ())
            -> where ( ' action ' , $ permission -> getAction ())
            -> where ( ' resource_type ' , $ permission -> getResourceType ())
            -> where ( ' resource_id ' , $ permission -> getResourceId ())
            -> delete ();
    }

    /**
     * Checks if a permission is stored for a user
     *
     * @param BeatSwitchLockCallersCaller $caller
     * @param BeatSwitchLockPermissionsPermission
     * @return bool
     */
    public function hasCallerPermission ( Caller $ caller , Permission $ permission )
    {
        return ( bool ) CallerPermission:: where ( ' caller_type ' , $ caller -> getCallerType ())
            -> where ( ' caller_id ' , $ caller -> getCallerId ())
            -> where ( ' type ' , $ permission -> getType ())
            -> where ( ' action ' , $ permission -> getAction ())
            -> where ( ' resource_type ' , $ permission -> getResourceType ())
            -> where ( ' resource_id ' , $ permission -> getResourceId ())
            -> first ();
    }

    /**
     * Returns all the permissions for a role
     *
     * @param BeatSwitchLockRolesRole $role
     * @return BeatSwitchLockPermissionsPermission[]
     */
    public function getRolePermissions ( Role $ role )
    {
        $ permissions = RolePermission:: where ( ' role ' , $ role -> getRoleName ())-> get ();

        return PermissionFactory:: createFromData ( $ permissions -> toArray ());
    }

    /**
     * Stores a new permission for a role
     *
     * @param BeatSwitchLockRolesRole $role
     * @param BeatSwitchLockPermissionsPermission
     * @return void
     */
    public function storeRolePermission ( Role $ role , Permission $ permission )
    {
        $ eloquentPermission = new RolePermission ;
        $ eloquentPermission -> role = $ role -> getRoleName ();
        $ eloquentPermission -> type = $ permission -> getType ();
        $ eloquentPermission -> action = $ permission -> getAction ();
        $ eloquentPermission -> resource_type = $ permission -> getResourceType ();
        $ eloquentPermission -> resource_id = $ permission -> getResourceId ();
        $ eloquentPermission -> save ();
    }

    /**
     * Removes a permission for a role
     *
     * @param BeatSwitchLockRolesRole $role
     * @param BeatSwitchLockPermissionsPermission
     * @return void
     */
    public function removeRolePermission ( Role $ role , Permission $ permission )
    {
        RolePermission:: where ( ' role ' , $ role -> getRoleName ())
            -> where ( ' type ' , $ permission -> getType ())
            -> where ( ' action ' , $ permission -> getAction ())
            -> where ( ' resource_type ' , $ permission -> getResourceType ())
            -> where ( ' resource_id ' , $ permission -> getResourceId ())
            -> delete ();
    }

    /**
     * Checks if a permission is stored for a role
     *
     * @param BeatSwitchLockRolesRole $role
     * @param BeatSwitchLockPermissionsPermission
     * @return bool
     */
    public function hasRolePermission ( Role $ role , Permission $ permission )
    {
        return ( bool ) RolePermission:: where ( ' role ' , $ role -> getRoleName ())
            -> where ( ' type ' , $ permission -> getType ())
            -> where ( ' action ' , $ permission -> getAction ())
            -> where ( ' resource_type ' , $ permission -> getResourceType ())
            -> where ( ' resource_id ' , $ permission -> getResourceId ())
            -> first ();
    }
}

Observe que não estamos verificando se a permissão já existe quando tentamos armazená-la. Você não precisa se preocupar com isso porque tudo foi feito para você na instância Lock .

Agora temos um driver que suporta o armazenamento de permissões para chamadores e funções.

Testando seu driver

É muito fácil garantir que seu driver funcione conforme o esperado. Se você estiver construindo um driver persistente, poderá testá-lo facilmente criando um teste PHPUnit que estende a classe PersistentDriverTestCase .

 <?php

use BeatSwitch  Lock  Tests  PersistentDriverTestCase ;

class EloquentDriverTest extends PersistentDriverTestCase
{
    public function setUp ()
    {
        // Don't forget to reset your DB here.
        
        // Bootstrap your driver.
        $ this -> driver = new EloquentDriver ();

        parent :: setUp ();
    }
}

E isso é tudo que você precisa! O PersistentDriverTestCase contém todos os testes necessários para garantir que seu driver funcione conforme o esperado. Portanto, se todos esses testes forem aprovados, seu driver foi configurado corretamente. Não há necessidade de zombar de nada, este é um caso de teste de integração puro. É claro que neste exemplo específico acima, para o Eloquent funcionar você precisará inicializar o Laravel. Trabalhar com um banco de dados como o sqlite seria a melhor maneira de testar seu driver.

Mantenedor

O bloqueio não está mantido neste momento.

Este pacote é atualmente mantido por Dries Vints.
Se você tiver alguma dúvida, não hesite em perguntar em um problema.

Contribuindo

Consulte o arquivo de contribuição para obter detalhes.

Registro de alterações

Você pode ver uma lista de alterações para cada versão em nosso arquivo changelog.

Licença

A licença do MIT. Consulte o arquivo de licença para obter mais informações.