lockダウンロード - lockソースコードのダウンロード

ロック - PHP 5.4 以降の Acl

残念ながら、現在ロックはメンテナンスされていません。当面の間、サポートを提供したり、新たな寄付を受け付けたりすることはできません。他の優先事項が原因で、Lock に必要な作業を行うことができません。最終的にはまた仕事に就こうと思いますが、残念ながらいつになるかは言えません。すべての貢献者とユーザーに感謝します。
-- 乾燥します

Lock は、 PHP 5.4+用の柔軟なドライバーベースのAclパッケージです。

ドリス・ヴィンツによって作成されました。 BeatSwitch のおかげでそれが可能になりました。マシュー・マチュガの『権威』からインスピレーションを得た作品。ロゴはジェリー・ロウによるもの。

用語
特徴
導入
ドライバー
ロードマップ
インストール
使用法
- 発信者コントラクトの実装
- 静的ドライバーの使用
- 永続的なドライバーの使用
- 権限の設定と確認
- 権限のクリア
- アクションエイリアスの設定
- 神呼び出し者の設定
- ロールの操作
- 条件の操作
- 許可または拒否されたリソースの取得
- LockAware トレイトの使用
アピ
ドライバーの構築
- ドライバーをテストする
メンテナー
貢献する
変更履歴
ライセンス

用語

Lock : サブジェクトの ACL インスタンス。このパッケージには現在、 CallerLockとRoleLockが同梱されています。
Caller : 何かを行うためのアクセス許可を持つ ID オブジェクト
Driver : 静的または永続的なアクセス許可のストレージシステム
Permission : 権限には、アクションとオプションの (固有の) リソースが保持されます。 RestrictionまたはPrivilegeのいずれかになります
Restriction : 制限により、(オプションのリソースに対する) アクションの実行が拒否されます。
Privilege : 特権により、(オプションのリソースに対して) アクションを実行できます。
Action : アクションとは、実行が許可または拒否されるものです。
Resource : リソースは、1 つ以上のアクションを実行できるオブジェクトです。特定のタイプのリソースをターゲットにすることも、一意の識別子によって特定のリソースをターゲットにすることもできます
Role : ロールは複数の権限を保持することもできます。呼び出し元は複数の役割を持つことができます。ロールは他のロールから権限を継承できます

特徴

複数の ID (呼び出し元) に対する柔軟な ACL アクセス許可
アクセス許可を保存するための静的または永続的なドライバー
アクションのエイリアス
役割
条件 (アサート)
特性を持つ呼び出し元またはロールに ACL 機能を簡単に実装します。

導入

Lock は、複数のアクセス許可の呼び出し元を処理し、アクセス許可を保存するための最も柔軟な方法を提供しようとする点で、他の acl パッケージとは異なります。

Lock のCallerコントラクトを使用すると、複数の ID にアクセス許可を設定できます。

Driverコントラクトを使用すると、パーミッションを永続ストレージシステムまたは静的ストレージシステムに簡単に保存できます。デフォルトの静的ArrayDriverこのパッケージに付属しています。すでに用意されているその他のドライバーについては、以下のリストを確認してください。または、 Driverコントラクトを実装して独自のものを構築します。

リソースのタイプと (オプションの) 識別子を手動で渡すことで、リソースのアクセス許可を設定および確認したり、オブジェクトにResourceコントラクトを実装して、より簡単にロックできるようにオブジェクトに渡すこともできます。

Manager新しいLockインスタンスのインスタンス化、アクションエイリアスの設定、またはロールの登録を簡単に行うことができます。

ドライバー

フレームワーク固有の実装が必要な場合は、以下のすでに準備されているドライバーのいずれかを選択してください。

ArrayDriver (このパッケージに同梱)
ララベル5

ロードマップ

グループ権限
その他のドライバー (Symfony、Zend Framework、Doctrine など)
イベントリスナー

インストール

このパッケージは Composer を通じてインストールします。

$ composer require beatswitch/lock

使用法

発信者コントラクトの実装

何かを行うためのアクセス許可を持つすべての ID は、 BeatSwitchLockCallersCallerコントラクトを実装する必要があります。 Callerコントラクトは、呼び出し元にその型と一意の識別子を返すよう要求することで、呼び出し元を識別します。以下に例を見てみましょう。

 <?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 ' ];
    }
}

getCallerType関数を追加すると、一意のタイプを通じて発信者のグループを識別できます。ある時点で、別の呼び出し元グループにアクセス許可を設定したい場合は、別のオブジェクトにコントラクトを簡単に実装できます。

 <?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 ' ];
    }
}

したがって、ドライバーを通じて特定の呼び出し元タイプのアクセス許可を簡単に取得できます。

静的ドライバーの使用

事前にすべての権限を設定したい場合は、パッケージに同梱されている静的なArrayDriverを使用できます。これにより、アプリケーションを実行する前に呼び出し元の権限のリストを設定できます。

 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

永続的なドライバーの使用

永続ドライバーを使用すると、永続ストレージ層にアクセス許可を保存し、実行時にそれらを調整できます。たとえば、Laravel 5 ドライバーを実装する場合、Laravel のデータベースコンポーネントを使用してデータベースへのアクセス許可を保存します。独自の UI を作成すると、このパッケージの acl 機能を簡単に接続して、たとえば、異なるユーザーが異なる権限を持つユーザー管理システムを作成できます。

それがどのように行われるかを確認するために、非常に基本的なユーザー管理コントローラーを見てみましょう。 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 ' );
    }
}

togglePermissionメソッドが使用されるたびに、指定されたアクションとリソースタイプに対するユーザーの権限が切り替わります。

権限の設定と確認

発信者が何かをすることをallowまたはdenyできます。権限を設定および確認する方法をいくつか紹介します。

呼び出し元がすべてを作成できるようにします。

 $ lock -> allow ( ' create ' );

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

発信者に投稿の作成のみを許可します。

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

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

発信者が ID 5 の特定の投稿のみを編集できるようにします。

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

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

発信者はすべての投稿を編集できますが、ID が 5 の投稿の編集は拒否されます。

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

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

権限の値を切り替えます。

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

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

複数のアクションを一度に許可または拒否したり、複数のアクションを一度にチェックしたりすることもできます。

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

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

権限のクリア

アクションとリソースの特定の組み合わせに対するアクセス許可を簡単にクリアできます。

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

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

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

ロックインスタンスのすべての権限をクリアすることもできます。

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

$ lock -> clear ();

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

アクションエイリアスの設定

複数のアクションをグループ化し、それらをすべて一度に設定するには、アクションのエイリアスを設定するとよいでしょう。

 $ 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

神呼び出し者の設定

ロックインスタンスのアクションとしてallワイルドカードを渡すことで、すべてに対するすべてのアクセス許可を持つ呼び出し元を簡単に設定できます。

 $ lock -> allow ( ' all ' );

これで、すべての「can」メソッド呼び出しが、この呼び出し元に対して true と検証されるようになります。

ロールの操作

ロックを使用すると、ロールを操作する簡単な方法が提供されます。ロールをそのまま使用できますが、継承を使用する場合は、ロールをマネージャーインスタンスに登録する必要があります。

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

または、複数のロールを一度に登録します。

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

いくつかの権限を設定し、それらがどのように解決されるかを見てみましょう。

 // 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

注意する必要があるのは、呼び出し元レベルのアクセス許可がロールレベルのアクセス許可よりも優先されるということです。それがどのように機能するかを見てみましょう。

呼び出し元にはユーザーの役割が与えられます。

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

条件の操作

条件は実際にはアサートであり、アクセス許可に対して設定できる追加のチェックです。これらを含む配列を、 allowおよびdenyの最後のパラメータとして渡すことができます。すべての条件はBeatSwitchLockPermissionsConditionインターフェイスを実装する必要があります。

警告:現在、条件は静的ドライバーでのみ機能することに注意してください。

条件を設定してみましょう。

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

次に、権限を設定するときにこれがどのように機能するかを見てみましょう。

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

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

複数の条件を渡すこともできます。

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

条件は好きなだけ渡すことができますが、許可が機能するにはすべての条件が成功する必要があります。

必要に応じてコールバックを使用することもできます。

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

許可または拒否されたリソースの取得

特定のアクションの実行が許可または拒否されているリソースのリストを取得したい場合は、 Lockインスタンスでallowedおよびdeniedメソッドを使用できます。

 $ 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];

ID を取得できるのは、アクセス許可が設定されているリソースからのみであることに注意してください。 Lock によって登録されていないリソースは返されません。

LockAware トレイトの使用

BeatSwitchLockLockAwareトレイトを実装することで、呼び出し元またはロールに ACL 機能を簡単に追加できます。

 <?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 ' ];
    }
}

次に、そのロックインスタンスを設定する必要があります。

 $ caller -> setLock ( $ lock );

これで、呼び出し元は自分自身に対してすべてのロックメソッドを使用できるようになります。

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

LockAwareトレイトを実装する呼び出し元があり、呼び出し元のロックインスタンスをまだブートストラップしていない場合は、マネージャーのmakeCallerLockAwareメソッドを使用して呼び出し元のロックを簡単に認識させることができます。

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

これで、呼び出し元はLockAwareメソッドを使用できるようになります。ロールについても同様の方法があります。

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

これにより、 LockAware特性がすでに組み込まれているSimpleRoleオブジェクトがブートストラップされます。

アピ

ビートスイッチロックロック

次のメソッドはすべてBeatSwitchLockLockインスタンスで呼び出すことができます。

できる

現在の呼び出し元に何かを行う権限があるかどうかを確認します。

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

できない

現在の呼び出し元が何かを行うことが禁止されているかどうかを確認します。

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

許可する

呼び出し元にPrivilege許可を設定して、呼び出し元が何かをできるようにします。一致する制限を削除します。

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

拒否

呼び出し元にRestrictionアクセス許可を設定して、呼び出し元が何かを実行できないようにします。一致する権限をすべて削除します。

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

トグル

指定された権限の値を切り替えます。

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

許可された

サブジェクトが指定されたアクションの実行を許可されている、指定されたリソースタイプの配列内のすべての ID を返します。

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

拒否されました

サブジェクトが指定されたアクションの実行を拒否されている、指定されたリソースタイプの配列内のすべての ID を返します。

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

BeatSwitchロックマネージャー

次のメソッドはすべてBeatSwitchLockManagerインスタンスで呼び出すことができます。

発信者

呼び出し元のBeatSwitchLockLockインスタンスを返します。

 caller(
    BeatSwitchLockCallersCaller $caller
)

役割

ロールのBeatSwitchLockLockインスタンスを返します。

 role(
    BeatSwitchLockRolesRole $role
)

エイリアス

1 つ以上のアクションのエイリアスを追加します。

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

セットロール

権限を継承する 1 つ以上のロールとオプションのロールを設定します。

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

makeCallerLockAware

LockAware特性を実装する呼び出し元のロックインスタンスを設定します。ロックインスタンスが設定された呼び出し元を返します。

 makeCallerLockAware(
    BeatSwitchLockCallersCaller $caller
)

ロールロックを認識させる

LockAware特性を実装するロールのロックインスタンスを設定します。ロックインスタンスが設定されたロールを返します。

 makeRoleLockAware(
    BeatSwitchLockRolesRole|string $role
)

ドライバーの構築

BeatSwitchLockDriversDriverコントラクトを実装することで、ドライバーを簡単に構築できます。以下では、Laravel の Eloquent ORM をストレージメカニズムとして使用して、独自の永続ドライバーを作成する方法を示します。

少なくとも次のデータベース列を持つCallerPermissionモデルクラスがあると仮定します。

caller_type (varchar, 100)
caller_id (int, 11)
type (varchar、10)
action (varchar、100)
resource_type (varchar、100、nullable)
resource_id (int、11、null 可能)

そして、次のデータベース列を含むRolePermissionモデルがあります。

role (varchar、100)
type (varchar、10)
action (varchar, 100)
resource_type (varchar、100、nullable)
resource_id (int、11、null 可能)

以下のドライバーの完全な実装を確認してみましょう。 getCallerPermissionsメソッドでは、 PermissionFactoryクラスを使用してデータを簡単にマップし、そこからPermissionオブジェクトを作成していることに注意してください。 PermissionFactoryのcreateFromDataメソッドは、配列とオブジェクトの両方を受け入れます。

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

アクセス許可を保存しようとするときに、アクセス許可がすでに存在するかどうかを確認していないことに注意してください。それはすべてLockインスタンスで行われるため、心配する必要はありません。

これで、呼び出し元とロールのアクセス許可の保存をサポートするドライバーが完成しました。

ドライバーをテストする

ドライバーが期待どおりに動作することを確認するのは非常に簡単です。永続ドライバーを構築している場合は、 PersistentDriverTestCaseクラスを拡張する PHPUnit テストを作成することで簡単にテストできます。

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

必要なのはこれだけです！ PersistentDriverTestCaseドライバーが期待どおりに動作することを確認するために必要なすべてのテストが含まれています。したがって、これらのテストがすべて合格した場合、ドライバーは正しくセットアップされています。何もモックする必要はありません。これは純粋な統合テストケースです。もちろん、上記のこの特定の例では、Eloquent が動作するには、Laravel をブートストラップする必要があります。ここでドライバーをテストするには、sqlite などのデータベースを使用するのが最良の方法です。

メンテナー

現時点ではロックはメンテナンスされていません。

このパッケージは現在、Dries Vints によって管理されています。
ご質問がございましたら、問題内でお気軽にご質問ください。

貢献する

詳細については、寄稿ファイルを参照してください。

変更履歴

各リリースの変更点のリストは、変更ログファイルで確認できます。

ライセンス

MITライセンス。詳細については、ライセンスファイルを参照してください。

拡大する

lock