lock
1.0.0
Leider muss ich sagen, dass Lock derzeit nicht gepflegt wird. Ich kann vorerst keinen Support anbieten oder neue Beiträge annehmen. Andere Prioritäten halten mich davon ab, die Arbeit in Lock zu stecken, die es verdient. Irgendwann werde ich versuchen, die Arbeit wieder aufzunehmen, aber leider kann ich nicht sagen, wann. Mein Dank geht an alle Mitwirkenden und Benutzer.
-- Trocknet
Lock ist ein flexibles, treiberbasiertes Acl- Paket für PHP 5.4+ .
Erstellt von Dries Vints. Möglich gemacht dank BeatSwitch. Inspiriert von Authority von Matthew Machuga. Logo von Jerry Low.
Lock : Eine ACL-Instanz für ein Subjekt. Dieses Paket wird derzeit mit einem CallerLock und einem RoleLock geliefertCaller : Ein Identitätsobjekt, das Berechtigungen haben kann, etwas zu tunDriver : Ein Speichersystem für Berechtigungen, die entweder statisch oder dauerhaft sein könnenPermission : Eine Berechtigung enthält eine Aktion und eine optionale (einzigartige) Ressource. Kann entweder eine Restriction oder ein Privilege seinRestriction : Eine Einschränkung verhindert, dass Sie eine Aktion ausführen können (auf einer optionalen Ressource).Privilege : Mit einem Privileg können Sie eine Aktion ausführen (auf einer optionalen Ressource).Action : Eine Aktion ist etwas, das Ihnen entweder gestattet oder verweigert wirdResource : Eine Ressource kann ein Objekt sein, an dem Sie eine oder mehrere Aktionen ausführen können. Es kann entweder auf einen bestimmten Ressourcentyp oder eine bestimmte Ressource anhand ihrer eindeutigen Kennung abzielenRole : Eine Rolle kann auch mehrere Berechtigungen enthalten. Ein Anrufer kann mehrere Rollen haben. Rollen können Berechtigungen von anderen Rollen erben Lock unterscheidet sich von anderen ACL-Paketen dadurch, dass versucht wird, die flexibelste Möglichkeit für die Arbeit mit mehreren Berechtigungsaufrufern und das Speichern von Berechtigungen bereitzustellen.
Durch die Arbeit mit Caller -Vertrag von Lock können Sie Berechtigungen für mehrere Identitäten festlegen.
Der Driver ermöglicht eine einfache Möglichkeit, Berechtigungen für ein dauerhaftes oder statisches Speichersystem zu speichern. Im Lieferumfang dieses Pakets ist ein standardmäßiger statischer ArrayDriver enthalten. In der Liste unten finden Sie weitere Treiber, die bereits für Sie vorbereitet wurden. Oder erstellen Sie Ihren eigenen, indem Sie den Driver implementieren.
Sie können Berechtigungen für Ressourcen festlegen und überprüfen, indem Sie den Typ und den (optionalen) Bezeichner einer Ressource manuell weitergeben, oder Sie können den Resource auf Ihre Objekte implementieren, damit Sie sie zum einfacheren Sperren weitergeben können.
Der Manager ermöglicht eine einfache Möglichkeit, neue Lock Instanzen zu instanziieren, Aktionsaliase festzulegen oder Rollen zu registrieren.
Wenn Sie eine Framework-spezifische Implementierung benötigen, wählen Sie unten einen der bereits vorbereiteten Treiber aus.
Installieren Sie dieses Paket über Composer.
$ composer require beatswitch/lock Jede Identität, die Berechtigungen haben soll, etwas zu tun, muss den BeatSwitchLockCallersCaller Vertrag implementieren. Der Caller -Vertrag identifiziert einen Anrufer, indem er von ihm verlangt, seinen Typ und seine eindeutige Kennung zurückzugeben. Schauen wir uns unten ein Beispiel an.
<?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 ' ];
}
} Durch Hinzufügen der Funktion getCallerType können wir eine Gruppe von Anrufern anhand eines eindeutigen Typs identifizieren. Wenn wir irgendwann Berechtigungen für eine andere Gruppe von Anrufern festlegen wollten, könnten wir den Vertrag problemlos für ein anderes Objekt implementieren.
<?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 ' ];
}
}Und so können wir über einen Treiber problemlos Berechtigungen für einen bestimmten Anrufertyp abrufen.
Wenn Sie alle Ihre Berechtigungen im Voraus konfigurieren möchten, können Sie den statischen ArrayDriver verwenden, der im Paket enthalten ist. Dadurch können Sie eine Liste von Berechtigungen für einen Anrufer festlegen, bevor Ihre Anwendung ausgeführt wird.
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 eventsWenn Sie mit einem persistenten Treiber arbeiten, können Sie Berechtigungen auf einer persistenten Speicherschicht speichern und diese während der Laufzeit anpassen. Wenn Sie beispielsweise den Laravel 5-Treiber implementieren würden, würden die Berechtigungen mithilfe der Datenbankkomponente von Laravel in einer Datenbank gespeichert. Durch die Erstellung Ihrer eigenen Benutzeroberfläche können Sie problemlos die ACL-Funktionalität aus diesem Paket anhängen, um beispielsweise ein Benutzerverwaltungssystem zu erstellen, in dem verschiedene Benutzer unterschiedliche Berechtigungen haben.
Werfen wir einen Blick auf einen sehr einfachen Benutzerverwaltungscontroller, um zu sehen, wie das funktioniert. Wir gehen davon aus, dass wir mit unserem Laravel-DB-Treiber eine Bootstrap-Lock-Manager-Instanz erhalten.
<?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 ' );
}
} Jedes Mal, wenn die togglePermission -Methode verwendet wird, wird die Berechtigung des Benutzers für die angegebene Aktion und den angegebenen Ressourcentyp umgeschaltet.
Sie können einem Anrufer entweder allow oder deny , etwas zu tun. Hier sind einige Möglichkeiten zum Festlegen und Überprüfen von Berechtigungen.
Erlauben Sie einem Anrufer, alles zu erstellen.
$ lock -> allow ( ' create ' );
$ lock -> can ( ' create ' ); // trueErlauben Sie einem Anrufer nur, Beiträge zu erstellen.
$ lock -> allow ( ' create ' , ' posts ' );
$ lock -> can ( ' create ' ); // false
$ lock -> can ( ' create ' , ' posts ' ); // trueErlauben Sie einem Anrufer nur, einen bestimmten Beitrag mit der ID 5 zu bearbeiten.
$ lock -> allow ( ' edit ' , ' posts ' , 5 );
$ lock -> can ( ' edit ' ); // false
$ lock -> can ( ' edit ' , ' posts ' ); // false
$ lock -> can ( ' edit ' , ' posts ' , 5 ); // trueErlauben Sie einem Anrufer, alle Beiträge zu bearbeiten, verbieten Sie ihm jedoch die Bearbeitung eines Beitrags mit der ID 5.
$ lock -> allow ( ' edit ' , ' posts ' );
$ lock -> deny ( ' edit ' , ' posts ' , 5 );
$ lock -> can ( ' edit ' , ' posts ' ); // true
$ lock -> can ( ' edit ' , ' posts ' , 5 ); // falseSchalten Sie den Wert einer Berechtigung um.
$ lock -> allow ( ' create ' );
$ lock -> can ( ' create ' ); // true
$ lock -> toggle ( ' create ' );
$ lock -> can ( ' create ' ); // falseSie können mehrere Aktionen gleichzeitig zulassen oder ablehnen und auch mehrere Aktionen gleichzeitig überprüfen.
$ lock -> allow ([ ' create ' , ' edit ' ], ' posts ' );
$ lock -> can ( ' create ' , ' posts ' ); // true
$ lock -> can ([ ' create ' , ' edit ' ], ' posts ' ); // true
$ lock -> can ([ ' create ' , ' delete ' ], ' posts ' ); // falseSie können Berechtigungen für eine bestimmte Kombination von Aktionen und Ressourcen ganz einfach löschen.
$ lock -> allow ([ ' create ' , ' edit ' ], ' posts ' );
$ lock -> clear ( ' edit ' , ' posts ' );
$ lock -> can ( ' edit ' , ' posts ' ); // false
$ lock -> can ( ' create ' , ' posts ' ); // trueSie können auch einfach alle Berechtigungen für eine Sperrinstanz löschen.
$ lock -> allow ( ' manage-posts ' );
$ lock -> allow ([ ' create ' , ' edit ' ], ' users ' );
$ lock -> clear ();
$ lock -> can ( ' manage-posts ' ); // false
$ lock -> can ( ' create ' , ' users ' ); // falseUm mehrere Aktionen zu gruppieren und alle auf einmal festzulegen, möchten Sie möglicherweise einen Aktionsalias festlegen.
$ 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 Sie könnten ganz einfach einen Aufrufer festlegen, der alle Berechtigungen für alles hat, indem Sie den Platzhalter all “ als Aktion für die Sperrinstanz übergeben.
$ lock -> allow ( ' all ' );Jetzt wird jeder „can“-Methodenaufruf für diesen Aufrufer auf „true“ validiert.
Lock bietet eine einfache Möglichkeit, mit Rollen zu arbeiten. Sie können standardmäßig mit Rollen arbeiten, wenn Sie jedoch mit Vererbung arbeiten möchten, müssen Sie die Rollen bei der Manager-Instanz registrieren.
$ manager -> setRole ( ' guest ' );
$ manager -> setRole ( ' user ' , ' guest ' ); // "user" will inherit all permissions from "guest"Oder registrieren Sie mehrere Rollen gleichzeitig.
$ manager -> setRole ([ ' editor ' , ' admin ' ], ' user ' ); // "editor" and "admin" will inherit all permissions from "user".Lassen Sie uns einige Berechtigungen festlegen und sehen, wie sie gelöst werden.
// 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 ' ); // trueSie müssen sich darüber im Klaren sein, dass Berechtigungen auf Anruferebene Vorrang vor Berechtigungen auf Rollenebene haben. Mal sehen, wie das funktioniert.
Unser Anrufer wird die Benutzerrolle haben.
$ 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. Bedingungen sind eigentlich Zusicherungen, bei denen es sich um zusätzliche Prüfungen handelt, die Sie für Berechtigungen festlegen können. Sie können ihnen ein Array als letzten Parameter allow und deny übergeben. Alle Bedingungen müssen die Schnittstelle BeatSwitchLockPermissionsCondition implementieren.
Achtung: Bitte beachten Sie, dass die Bedingungen derzeit nur mit statischen Treibern funktionieren.
Lassen Sie uns eine Bedingung einrichten.
<?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 ();
}
}Sehen wir uns nun an, wie dies beim Einrichten einer Berechtigung funktioniert.
$ condition = App:: make ( ' LoggedInCondition ' );
$ lock -> allow ( ' create ' , ' posts ' , null , $ condition );
$ lock -> can ( ' create ' , ' posts ' ); // true if logged in, otherwise false.Sie können auch mehrere Bedingungen weitergeben.
$ lock -> allow ( ' create ' , ' posts ' , null , [ $ falseCondition , $ trueCondition ]);
$ lock -> can ( ' create ' , ' posts ' ); // false: there's at least one false conditionSie können so viele Bedingungen weitergeben, wie Sie möchten, aber alle müssen erfolgreich sein, damit die Berechtigung funktioniert.
Wenn Sie möchten, können Sie auch einen Rückruf nutzen.
$ lock -> allow ( ' create ' , ' posts ' , null , function ( $ lock , $ permission , $ action , $ resource = null ) {
return false ;
});
$ lock -> can ( ' create ' , ' posts ' ); // false because the callback returns false. Wenn Sie eine Liste der Ressourcen abrufen möchten, denen die Ausführung einer bestimmten Aktion gestattet oder verweigert wird, können Sie die Methoden allowed und denied für eine Lock Instanz verwenden.
$ 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];Bitte beachten Sie, dass Sie IDs nur von Ressourcen abrufen können, für die Berechtigungen festgelegt sind. Ressourcen, die nicht über Lock registriert sind, werden nicht zurückgegeben.
Sie können Ihrem Anrufer oder Ihrer Rolle ganz einfach ACL-Funktionalität hinzufügen, indem Sie das Merkmal BeatSwitchLockLockAware implementieren.
<?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 ' ];
}
}Jetzt müssen wir seine Sperrinstanz festlegen.
$ caller -> setLock ( $ lock );Und jetzt kann Ihr Anrufer alle Sperrmethoden auf sich selbst anwenden.
$ caller -> can ( ' create ' , ' posts ' );
$ caller -> allow ( ' edit ' , ' pages ' ); Wenn Sie einen Anrufer haben, der das LockAware Merkmal implementiert, aber die Sperrinstanz des Anrufers noch nicht gebootet hat, können Sie die Sperre des Anrufers einfach mit der makeCallerLockAware -Methode des Managers erkennen.
$ caller = $ manager -> makeCallerLockAware ( $ caller ); Und jetzt kann Ihr Anrufer die LockAware -Methoden verwenden. Für Rollen gibt es eine ähnliche Methode.
$ role = $ manager -> makeRoleLockAware ( ' guest ' ); Dadurch wird ein SimpleRole -Objekt gebootet, das bereits über die LockAware -Eigenschaft verfügt.
Die folgenden Methoden können alle auf einer BeatSwitchLockLock Instanz aufgerufen werden.
Überprüft, ob der aktuelle Anrufer die Berechtigung hat, etwas zu tun.
can(
string|array $action,
string|BeatSwitchLockResourcesResource $resource = null,
int $resourceId = null
)
Prüft, ob es dem aktuellen Anrufer verboten ist, etwas zu tun.
cannot(
string|array $action,
string|BeatSwitchLockResourcesResource $resource = null,
int $resourceId = null
)
Legt eine Privilege -Berechtigung für einen Anrufer fest, um ihm zu erlauben, etwas zu tun. Entfernt alle Übereinstimmungseinschränkungen.
allow(
string|array $action,
string|BeatSwitchLockResourcesResource $resource = null,
int $resourceId = null,
BeatSwitchLockPermissionsCondition[] $conditions = []
)
Legt eine Restriction für einen Anrufer fest, um ihn daran zu hindern, etwas zu tun. Entfernt alle entsprechenden Berechtigungen.
deny(
string|array $action,
string|BeatSwitchLockResourcesResource $resource = null,
int $resourceId = null,
BeatSwitchLockPermissionsCondition[] $conditions = []
)
Schaltet den Wert für die gegebene Berechtigung um.
toggle(
string|array $action,
string|BeatSwitchLockResourcesResource $resource = null,
int $resourceId = null
)
Gibt alle IDs in einem Array des angegebenen Ressourcentyps zurück, für die das Subjekt die angegebene Aktion ausführen darf.
allowed(
string|array $action,
string|BeatSwitchLockResourcesResource $resourceType
)
Gibt alle IDs in einem Array des angegebenen Ressourcentyps zurück, für die dem Subjekt die Ausführung der angegebenen Aktion verweigert wird.
denied(
string|array $action,
string|BeatSwitchLockResourcesResource $resourceType
)
Die folgenden Methoden können alle auf einer BeatSwitchLockManager Instanz aufgerufen werden.
Gibt eine BeatSwitchLockLock Instanz für einen Anrufer zurück.
caller(
BeatSwitchLockCallersCaller $caller
)
Gibt eine BeatSwitchLockLock Instanz für eine Rolle zurück.
role(
BeatSwitchLockRolesRole $role
)
Fügen Sie einen Alias für eine oder mehrere Aktionen hinzu.
alias(
string $name,
string|array $actions
)
Legen Sie eine oder mehrere Rollen und eine optionale Rolle fest, von der Berechtigungen geerbt werden sollen.
setRole(
string|array $name,
string $inherit = null
)
Legt die Sperrinstanz für einen Aufrufer fest, der das LockAware Merkmal implementiert. Gibt den Aufrufer mit der festgelegten Sperrinstanz zurück.
makeCallerLockAware(
BeatSwitchLockCallersCaller $caller
)
Legt die Sperrinstanz für eine Rolle fest, die das LockAware Merkmal implementiert. Gibt die Rolle mit der festgelegten Sperrinstanz zurück.
makeRoleLockAware(
BeatSwitchLockRolesRole|string $role
)
Sie können ganz einfach einen Treiber erstellen, indem Sie den Vertrag BeatSwitchLockDriversDriver implementieren. Im Folgenden zeigen wir, wie wir mit Laravel’s Eloquent ORM als Speichermechanismus unseren eigenen persistenten Treiber erstellen.
Wir gehen davon aus, dass wir eine CallerPermission -Modellklasse mit mindestens den folgenden Datenbankspalten haben:
caller_type (varchar, 100)caller_id (int, 11)type (varchar, 10)action (varchar, 100)resource_type (varchar, 100, nullable)resource_id (int, 11, nullable) Und wir haben ein RolePermission -Modell mit den folgenden Datenbankspalten:
role (varchar, 100)type (varchar, 10)action (varchar, 100)resource_type (varchar, 100, nullable)resource_id (int, 11, nullable) Schauen wir uns unten eine vollständige Implementierung des Treibers an. Beachten Sie, dass wir für die getCallerPermissions -Methode die PermissionFactory Klasse verwenden, um die Daten einfach zuzuordnen und daraus Permission Objekte zu erstellen. Die Methode createFromData der PermissionFactory akzeptiert sowohl Arrays als auch Objekte.
<?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 ();
}
} Beachten Sie, dass wir nicht prüfen, ob die Berechtigung bereits vorhanden ist, wenn wir versuchen, sie zu speichern. Darüber müssen Sie sich keine Sorgen machen, da dies alles in der Lock -Instanz für Sie erledigt wurde.
Jetzt haben wir einen Treiber, der das Speichern von Berechtigungen für Anrufer und Rollen unterstützt.
Sie können ganz einfach sicherstellen, dass Ihr Treiber wie erwartet funktioniert. Wenn Sie einen persistenten Treiber erstellen, können Sie ihn einfach testen, indem Sie einen PHPUnit-Test erstellen, der die Klasse PersistentDriverTestCase erweitert.
<?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 ();
}
} Und das ist alles was Sie brauchen! Der PersistentDriverTestCase enthält alle Tests, die Sie benötigen, um sicherzustellen, dass Ihr Treiber wie erwartet funktioniert. Wenn also alle diese Tests bestanden wurden, wurde Ihr Treiber korrekt eingerichtet. Kein Grund, sich über irgendetwas lustig zu machen, dies ist ein reiner Integrationstestfall. Damit Eloquent in diesem speziellen Beispiel oben funktioniert, müssen Sie natürlich einen Bootstrap für Laravel durchführen. Die Arbeit mit einer Datenbank wie SQLite wäre hier die beste Möglichkeit, Ihren Treiber zu testen.
Die Sperre ist derzeit nicht aufrechterhalten.
Dieses Paket wird derzeit von Dries Vints gepflegt.
Wenn Sie Fragen haben, zögern Sie bitte nicht, diese in einer Ausgabe zu stellen.
Weitere Informationen finden Sie in der beitragenden Datei.
Eine Liste der Änderungen für jede Version finden Sie in unserer Changelog-Datei.
Die MIT-Lizenz. Weitere Informationen finden Sie in der Lizenzdatei.
