lock
1.0.0
Je suis triste de dire que Lock n'est actuellement pas maintenu. Je ne pourrai pas offrir de soutien ni accepter de nouvelles contributions pour le moment. D’autres priorités m’empêchent de mettre dans Lock le travail qu’il mérite. Finalement, j'essaierai de reprendre du travail mais malheureusement je ne peux pas dire quand. Mes remerciements vont à tous les contributeurs et utilisateurs.
-- Sèche
Lock est un package Acl flexible basé sur un pilote pour PHP 5.4+ .
Créé par Dries Vints. Rendu possible grâce à BeatSwitch. Inspiré par Autorité de Matthew Machuga. Logo de Jerry Low.
Lock : Une instance acl pour un sujet. Ce package est actuellement livré avec un CallerLock et un RoleLockCaller : un objet d'identité qui peut avoir des autorisations pour faire quelque choseDriver : Un système de stockage pour les autorisations qui peuvent être statiques ou persistantesPermission : Une autorisation contient une action et une ressource facultative (unique). Peut être une Restriction ou un PrivilegeRestriction : Une restriction vous interdit de pouvoir effectuer une action (sur une ressource facultative)Privilege : Un privilège permet d'effectuer une action (sur une ressource facultative)Action : Une action est quelque chose que vous êtes autorisé ou refusé à faireResource : Une ressource peut être un objet sur lequel vous pouvez effectuer une ou plusieurs actions. Il peut soit cibler un certain type de ressource, soit une ressource spécifique par son identifiant uniqueRole : Un rôle peut également détenir plusieurs autorisations. Un appelant peut avoir plusieurs rôles. Les rôles peuvent hériter des autorisations d'autres rôles Lock diffère des autres packages acl en essayant de fournir le moyen le plus flexible de travailler avec plusieurs appelants d'autorisations et de stocker les autorisations.
En travaillant avec le contrat Caller de Lock, vous pouvez définir des autorisations sur plusieurs identités.
Le contrat Driver permet de stocker facilement les autorisations sur un système de stockage persistant ou statique. Un ArrayDriver statique par défaut est livré avec ce package. Consultez la liste ci-dessous pour découvrir d’autres pilotes déjà préparés pour vous. Ou créez le vôtre en mettant en œuvre le contrat Driver .
Vous pouvez définir et vérifier les autorisations pour les ressources en transmettant manuellement le type d'une ressource et son identifiant (facultatif) ou vous pouvez implémenter le contrat Resource sur vos objets afin de pouvoir les transmettre pour les verrouiller plus facilement.
Le Manager permet d'instancier facilement de nouvelles instances Lock , de définir des alias d'action ou d'enregistrer des rôles.
Si vous avez besoin d'une implémentation spécifique au framework, choisissez l'un des pilotes déjà préparés ci-dessous.
Installez ce package via Composer.
$ composer require beatswitch/lock Chaque identité qui devrait avoir l'autorisation de faire quelque chose doit implémenter le contrat BeatSwitchLockCallersCaller . Le contrat Caller identifie un appelant en lui demandant de renvoyer son type et son identifiant unique. Regardons un exemple ci-dessous.
<?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 ' ];
}
} En ajoutant la fonction getCallerType nous pouvons identifier un groupe d'appelants grâce à un type unique. Si nous voulions à un moment donné définir des autorisations sur un autre groupe d'appelants, nous pourrions facilement implémenter le contrat sur un autre objet.
<?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 ' ];
}
}Et ainsi, nous pouvons facilement récupérer les autorisations pour un type d'appelant spécifique via un pilote.
Si vous souhaitez configurer toutes vos autorisations au préalable, vous pouvez utiliser le ArrayDriver statique fourni avec le package. Cela vous permet de définir une liste d'autorisations pour un appelant avant l'exécution de votre application.
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 eventsTravailler avec un pilote persistant vous permet de stocker les autorisations sur une couche de stockage persistante et de les ajuster pendant l'exécution. Par exemple, si vous implémentez le pilote Laravel 5, il stockera les autorisations sur une base de données à l'aide du composant de base de données de Laravel. En créant votre propre interface utilisateur, vous pouvez facilement attacher la fonctionnalité acl de ce package pour créer, par exemple, un système de gestion des utilisateurs dans lequel différents utilisateurs disposent d'autorisations différentes.
Jetons un coup d'œil à un contrôleur de gestion des utilisateurs très basique pour voir comment cela se fait. Nous supposerons que nous obtenons une instance de gestionnaire de verrous amorcée avec notre pilote 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 ' );
}
} Chaque fois que la méthode togglePermission est utilisée, l'autorisation de l'utilisateur pour l'action et le type de ressource donnés sera basculée.
Vous pouvez allow ou deny à un appelant de faire quelque chose. Voici quelques façons de définir et de vérifier les autorisations.
Autorisez un appelant à tout créer.
$ lock -> allow ( ' create ' );
$ lock -> can ( ' create ' ); // trueAutorisez un appelant à créer uniquement des messages.
$ lock -> allow ( ' create ' , ' posts ' );
$ lock -> can ( ' create ' ); // false
$ lock -> can ( ' create ' , ' posts ' ); // trueAutoriser un appelant à modifier uniquement une publication spécifique avec un identifiant de 5.
$ lock -> allow ( ' edit ' , ' posts ' , 5 );
$ lock -> can ( ' edit ' ); // false
$ lock -> can ( ' edit ' , ' posts ' ); // false
$ lock -> can ( ' edit ' , ' posts ' , 5 ); // trueAutoriser un appelant à modifier tous les messages, mais lui refuser d'en modifier un avec l'identifiant 5.
$ lock -> allow ( ' edit ' , ' posts ' );
$ lock -> deny ( ' edit ' , ' posts ' , 5 );
$ lock -> can ( ' edit ' , ' posts ' ); // true
$ lock -> can ( ' edit ' , ' posts ' , 5 ); // falseChanger la valeur d'une autorisation.
$ lock -> allow ( ' create ' );
$ lock -> can ( ' create ' ); // true
$ lock -> toggle ( ' create ' );
$ lock -> can ( ' create ' ); // falseVous pouvez autoriser ou refuser plusieurs actions à la fois et également vérifier plusieurs actions à la fois.
$ lock -> allow ([ ' create ' , ' edit ' ], ' posts ' );
$ lock -> can ( ' create ' , ' posts ' ); // true
$ lock -> can ([ ' create ' , ' edit ' ], ' posts ' ); // true
$ lock -> can ([ ' create ' , ' delete ' ], ' posts ' ); // falseVous pouvez facilement effacer les autorisations pour une combinaison spécifique d’actions et de ressources.
$ lock -> allow ([ ' create ' , ' edit ' ], ' posts ' );
$ lock -> clear ( ' edit ' , ' posts ' );
$ lock -> can ( ' edit ' , ' posts ' ); // false
$ lock -> can ( ' create ' , ' posts ' ); // trueVous pouvez également simplement supprimer toutes les autorisations pour une instance de verrouillage.
$ lock -> allow ( ' manage-posts ' );
$ lock -> allow ([ ' create ' , ' edit ' ], ' users ' );
$ lock -> clear ();
$ lock -> can ( ' manage-posts ' ); // false
$ lock -> can ( ' create ' , ' users ' ); // falsePour regrouper plusieurs actions et les définir toutes en même temps, vous souhaiterez peut-être définir un alias d'action.
$ 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 Vous pouvez facilement définir un appelant disposant de toutes les autorisations pour tout en transmettant le caractère générique all comme action sur l'instance de verrouillage.
$ lock -> allow ( ' all ' );Désormais, chaque appel de méthode « can » sera validé comme étant vrai pour cet appelant.
Lock offre un moyen simple de travailler avec des rôles. Vous pouvez travailler avec des rôles directement, mais si vous souhaitez travailler avec l'héritage, vous devrez enregistrer les rôles dans l'instance du gestionnaire.
$ manager -> setRole ( ' guest ' );
$ manager -> setRole ( ' user ' , ' guest ' ); // "user" will inherit all permissions from "guest"Ou enregistrez plusieurs rôles à la fois.
$ manager -> setRole ([ ' editor ' , ' admin ' ], ' user ' ); // "editor" and "admin" will inherit all permissions from "user".Définissons quelques autorisations et voyons comment elles sont résolues.
// 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 ' ); // trueVous devez être conscient du fait que les autorisations au niveau de l’appelant remplacent les autorisations au niveau du rôle. Voyons comment cela fonctionne.
Notre appelant aura le rôle d’utilisateur.
$ 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. Les conditions sont en fait des assertions qui sont des contrôles supplémentaires que vous pouvez définir pour les autorisations. Vous pouvez transmettre un tableau avec eux comme dernier paramètre de allow et deny . Toutes les conditions doivent implémenter l’interface BeatSwitchLockPermissionsCondition .
Attention : veuillez noter que les conditions ne fonctionnent actuellement qu'avec des pilotes statiques.
Définissons une condition.
<?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 ();
}
}Voyons maintenant comment cela fonctionnera lors de la configuration d'une autorisation.
$ condition = App:: make ( ' LoggedInCondition ' );
$ lock -> allow ( ' create ' , ' posts ' , null , $ condition );
$ lock -> can ( ' create ' , ' posts ' ); // true if logged in, otherwise false.Vous pouvez également transmettre plusieurs conditions.
$ lock -> allow ( ' create ' , ' posts ' , null , [ $ falseCondition , $ trueCondition ]);
$ lock -> can ( ' create ' , ' posts ' ); // false: there's at least one false conditionVous pouvez transmettre autant de conditions que vous le souhaitez, mais elles doivent toutes réussir pour obtenir l'autorisation de travailler.
Vous pouvez également utiliser un rappel si vous le souhaitez.
$ lock -> allow ( ' create ' , ' posts ' , null , function ( $ lock , $ permission , $ action , $ resource = null ) {
return false ;
});
$ lock -> can ( ' create ' , ' posts ' ); // false because the callback returns false. Si vous souhaitez récupérer une liste de ressources autorisées ou refusées à effectuer une action particulière, vous pouvez utiliser les méthodes allowed et denied sur une instance 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];Veuillez garder à l'esprit que vous ne pouvez récupérer les identifiants que des ressources pour lesquelles des autorisations sont définies. Les ressources qui ne sont pas enregistrées via Lock ne seront pas restituées.
Vous pouvez facilement ajouter une fonctionnalité acl à votre appelant ou à votre rôle en implémentant le trait 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 ' ];
}
}Nous devons maintenant définir son instance de verrouillage.
$ caller -> setLock ( $ lock );Et maintenant, votre appelant peut utiliser toutes les méthodes de verrouillage sur lui-même.
$ caller -> can ( ' create ' , ' posts ' );
$ caller -> allow ( ' edit ' , ' pages ' ); Si vous avez un appelant qui implémente le trait LockAware mais que vous n'avez pas encore démarré l'instance de verrouillage de l'appelant, vous pouvez facilement informer le verrouillage de l'appelant en utilisant la méthode makeCallerLockAware du gestionnaire.
$ caller = $ manager -> makeCallerLockAware ( $ caller ); Et désormais, votre appelant pourra utiliser les méthodes LockAware . Il existe une méthode similaire pour les rôles.
$ role = $ manager -> makeRoleLockAware ( ' guest ' ); Cela amorcera un objet SimpleRole qui est déjà livré avec le trait LockAware en place.
Les méthodes suivantes peuvent toutes être appelées sur une instance BeatSwitchLockLock .
Vérifie si l'appelant actuel est autorisé à faire quelque chose.
can(
string|array $action,
string|BeatSwitchLockResourcesResource $resource = null,
int $resourceId = null
)
Vérifie s'il est interdit à l'appelant actuel de faire quelque chose.
cannot(
string|array $action,
string|BeatSwitchLockResourcesResource $resource = null,
int $resourceId = null
)
Définit une autorisation Privilege sur un appelant pour lui permettre de faire quelque chose. Supprime toutes les restrictions de correspondance.
allow(
string|array $action,
string|BeatSwitchLockResourcesResource $resource = null,
int $resourceId = null,
BeatSwitchLockPermissionsCondition[] $conditions = []
)
Définit une autorisation Restriction sur un appelant pour l'empêcher de faire quelque chose. Supprime tous les privilèges correspondants.
deny(
string|array $action,
string|BeatSwitchLockResourcesResource $resource = null,
int $resourceId = null,
BeatSwitchLockPermissionsCondition[] $conditions = []
)
Bascule la valeur de l'autorisation donnée.
toggle(
string|array $action,
string|BeatSwitchLockResourcesResource $resource = null,
int $resourceId = null
)
Renvoie tous les identifiants d'un tableau du type de ressource donné sur lequel le sujet est autorisé à effectuer l'action donnée.
allowed(
string|array $action,
string|BeatSwitchLockResourcesResource $resourceType
)
Renvoie tous les identifiants d'un tableau du type de ressource donné sur lequel le sujet n'a pas le droit d'effectuer l'action donnée.
denied(
string|array $action,
string|BeatSwitchLockResourcesResource $resourceType
)
Les méthodes suivantes peuvent toutes être appelées sur une instance BeatSwitchLockManager .
Renvoie une instance BeatSwitchLockLock pour un appelant.
caller(
BeatSwitchLockCallersCaller $caller
)
Renvoie une instance BeatSwitchLockLock pour un rôle.
role(
BeatSwitchLockRolesRole $role
)
Ajoutez un alias pour une ou plusieurs actions.
alias(
string $name,
string|array $actions
)
Définissez un ou plusieurs rôles et un rôle facultatif dont vous souhaitez hériter des autorisations.
setRole(
string|array $name,
string $inherit = null
)
Définit l'instance de verrouillage pour un appelant qui implémente le trait LockAware . Renvoie l'appelant avec l'instance de verrouillage définie.
makeCallerLockAware(
BeatSwitchLockCallersCaller $caller
)
Définit l'instance de verrouillage pour un rôle qui implémente le trait LockAware . Renvoie le rôle avec l'instance de verrouillage définie.
makeRoleLockAware(
BeatSwitchLockRolesRole|string $role
)
Vous pouvez facilement créer un pilote en implémentant le contrat BeatSwitchLockDriversDriver . Ci-dessous, nous montrerons comment créer notre propre pilote persistant en utilisant l'ORM Eloquent de Laravel comme mécanisme de stockage.
Nous supposerons que nous disposons d'une classe de modèle CallerPermission avec au moins les colonnes de base de données suivantes :
caller_type (varchar, 100)caller_id (int, 11)type (varchar, 10)action (varchar, 100)resource_type (varchar, 100, nullable)resource_id (int, 11, nullable) Et nous avons un modèle RolePermission avec les colonnes de base de données suivantes :
role (varchar, 100)type (varchar, 10)action (varchar, 100)resource_type (varchar, 100, nullable)resource_id (int, 11, nullable) Voyons une implémentation complète du pilote ci-dessous. Notez que pour la méthode getCallerPermissions , nous utilisons la classe PermissionFactory pour mapper facilement les données et créer des objets Permission à partir d'elles. La méthode createFromData de PermissionFactory acceptera à la fois les tableaux et les objets.
<?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 ();
}
} Notez que nous ne vérifions pas si l'autorisation existe déjà lorsque nous essayons de la stocker. Vous n'avez pas à vous en soucier car tout a été fait pour vous dans l'instance Lock .
Nous disposons désormais d'un pilote qui prend en charge le stockage des autorisations pour les appelants et les rôles.
Il est très simple pour vous de vous assurer que votre pilote fonctionne comme prévu. Si vous créez un pilote persistant, vous pouvez facilement le tester en créant un test PHPUnit qui étend la 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 ();
}
} Et c'est tout ce dont vous avez besoin ! Le PersistentDriverTestCase contient tous les tests dont vous aurez besoin pour vous assurer que votre pilote fonctionne comme prévu. Donc, si tous ces tests réussissent, votre pilote a été correctement configuré. Pas besoin de se moquer de quoi que ce soit, il s’agit d’un pur cas de test d’intégration. Bien sûr, dans cet exemple spécifique ci-dessus, pour qu'Eloquent fonctionne, vous devrez amorcer Laravel. Travailler avec une base de données comme SQLite serait le meilleur moyen de tester votre pilote.
Le verrouillage n'est pas maintenu pour le moment.
Ce package est actuellement maintenu par Dries Vints.
Si vous avez des questions, n'hésitez pas à les poser dans un numéro.
Veuillez consulter le fichier de contribution pour plus de détails.
Vous pouvez voir une liste des modifications pour chaque version dans notre fichier journal des modifications.
La licence MIT. Veuillez consulter le fichier de licence pour plus d'informations.
