Beranda>Kode sumber PHP>Kategori lainnya
Unduh

Kunci - Acl untuk PHP 5.4+

Saya sedih untuk mengatakan bahwa Lock saat ini tidak dipertahankan. Saya tidak dapat menawarkan dukungan atau menerima kontribusi baru untuk saat ini. Prioritas lain menghalangi saya untuk melakukan pekerjaan yang layak dilakukan di Lock. Akhirnya saya akan mencoba untuk mengambil pekerjaan lagi tapi sayangnya saya tidak bisa mengatakan kapan. Terima kasih saya sampaikan kepada semua kontributor dan pengguna.

-- Mengering

Lock adalah paket Acl berbasis driver yang fleksibel untuk PHP 5.4+ .

Dibuat oleh Dries Vints. Ini dimungkinkan berkat BeatSwitch. Terinspirasi oleh Otoritas oleh Matthew Machuga. Logo oleh Jerry Low.

Daftar isi

  • Terminologi
  • Fitur
  • Perkenalan
  • Pengemudi
  • Peta jalan
  • Instalasi
  • Penggunaan
    • Menerapkan kontrak Penelepon
    • Bekerja dengan driver statis
    • Bekerja dengan driver yang gigih
    • Mengatur dan memeriksa izin
    • Menghapus izin
    • Menetapkan alias tindakan
    • Menetapkan pemanggil Tuhan
    • Bekerja dengan peran
    • Bekerja dengan kondisi
    • Mengambil sumber daya yang diizinkan atau ditolak
    • Menggunakan sifat LockAware
  • Api
  • Membangun pengemudi
    • Menguji driver Anda
  • Pemelihara
  • Berkontribusi
  • log perubahan
  • Lisensi

Terminologi

  • Lock : Contoh acl untuk suatu subjek. Paket ini saat ini dikirimkan dengan CallerLock dan RoleLock
  • Caller : Objek identitas yang dapat memiliki izin untuk melakukan sesuatu
  • Driver : Sistem penyimpanan untuk izin yang bersifat statis atau persisten
  • Permission : Izin menampung tindakan dan sumber daya opsional (unik). Dapat berupa Restriction atau Privilege
  • Restriction : Pembatasan membuat Anda tidak dapat melakukan suatu tindakan (pada sumber daya opsional)
  • Privilege : Hak istimewa memungkinkan Anda melakukan suatu tindakan (pada sumber daya opsional)
  • Action : Suatu tindakan adalah sesuatu yang boleh atau tidak boleh Anda lakukan
  • Resource : Sumber daya dapat berupa objek tempat Anda dapat melakukan satu atau beberapa tindakan. Itu dapat menargetkan jenis sumber daya tertentu atau sumber daya tertentu berdasarkan pengidentifikasi uniknya
  • Role : Sebuah peran juga dapat memiliki banyak izin. Seorang penelepon dapat memiliki banyak peran. Peran dapat mewarisi izin dari peran lain

Fitur

  • Izin acl fleksibel untuk banyak identitas (penelepon)
  • Driver statis atau persisten untuk menyimpan izin
  • Alias ​​aksi
  • Peran
  • Kondisi (Menegaskan)
  • Implementasikan fungsionalitas acl dengan mudah pada pemanggil atau peran Anda dengan suatu sifat

Perkenalan

Lock berbeda dari paket acl lainnya dengan mencoba memberikan cara paling fleksibel untuk bekerja dengan banyak pemanggil izin dan menyimpan izin.

Dengan bekerja dengan kontrak Caller Lock Anda dapat mengatur izin pada banyak identitas.

Kontrak Driver memungkinkan cara mudah untuk menyimpan izin ke sistem penyimpanan persisten atau statis. ArrayDriver statis default dikirimkan bersama paket ini. Lihat daftar di bawah ini untuk mengetahui lebih banyak driver yang telah disiapkan untuk Anda. Atau buat sendiri dengan menerapkan kontrak Driver .

Anda dapat mengatur dan memeriksa izin untuk sumber daya dengan meneruskan jenis sumber daya dan pengidentifikasi (opsional) secara manual atau Anda dapat menerapkan kontrak Resource ke objek Anda sehingga Anda dapat meneruskannya agar lebih mudah dikunci.

Manager memungkinkan cara mudah untuk membuat instance Lock baru, mengatur alias tindakan, atau mendaftarkan peran.

Pengemudi

Jika Anda memerlukan implementasi kerangka kerja khusus, pilih salah satu driver yang sudah disiapkan di bawah ini.

  • ArrayDriver (dikirimkan bersama paket ini)
  • Laravel 5

Peta jalan

  • Izin Grup
  • Lebih banyak driver (Symfony, Zend Framework, Doctrine, ...)
  • Pendengar Acara

Instalasi

Instal paket ini melalui Komposer. 

$ composer require beatswitch/lock

Penggunaan

Menerapkan kontrak Penelepon

Setiap identitas yang seharusnya memiliki izin untuk melakukan sesuatu harus menerapkan kontrak BeatSwitchLockCallersCaller . Kontrak Caller mengidentifikasi penelepon dengan mengharuskannya mengembalikan tipe dan pengidentifikasi uniknya. Mari kita lihat contoh di bawah ini. 

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

Dengan menambahkan fungsi getCallerType kita dapat mengidentifikasi sekelompok penelepon melalui tipe unik. Jika suatu saat kami ingin menetapkan izin pada grup penelepon lain, kami dapat dengan mudah menerapkan kontrak pada objek lain. 

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

Dan dengan demikian kita dapat dengan mudah mengambil izin untuk jenis pemanggil tertentu melalui driver.

Bekerja dengan driver statis

Jika Anda ingin mengonfigurasi semua izin sebelumnya, Anda dapat menggunakan ArrayDriver statis yang dikirimkan bersama paket. Ini memungkinkan Anda menyetel daftar izin untuk pemanggil sebelum aplikasi Anda dijalankan. 

 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

Bekerja dengan driver yang gigih

Bekerja dengan driver persisten memungkinkan Anda menyimpan izin ke lapisan penyimpanan persisten dan menyesuaikannya selama runtime. Misalnya, jika Anda mengimplementasikan driver Laravel 5, driver tersebut akan menyimpan izin ke database menggunakan komponen database Laravel. Dengan membuat UI Anda sendiri, Anda dapat dengan mudah melampirkan fungsionalitas acl dari paket ini untuk membuat, misalnya, sistem manajemen pengguna di mana pengguna yang berbeda memiliki izin yang berbeda.

Mari kita lihat pengontrol manajemen pengguna yang sangat mendasar untuk melihat cara melakukannya. Kita asumsikan kita mendapatkan instance lock manager yang di-bootstrap dengan driver Laravel DB kita. 

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

Setiap kali metode togglePermission digunakan, izin pengguna untuk tindakan tertentu dan jenis sumber daya akan diubah.

Mengatur dan memeriksa izin

Anda dapat allow atau deny penelepon melakukan sesuatu. Berikut adalah beberapa cara untuk mengatur dan memeriksa izin.

Izinkan penelepon untuk membuat segalanya. 

 $ lock -> allow ( ' create ' );

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

Izinkan penelepon hanya membuat postingan. 

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

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

Izinkan penelepon hanya mengedit postingan tertentu dengan ID 5. 

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

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

Izinkan penelepon untuk mengedit semua postingan tetapi tolak mereka untuk mengedit postingan dengan id 5. 

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

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

Alihkan nilai izin. 

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

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

Anda dapat mengizinkan atau menolak beberapa tindakan sekaligus dan juga memeriksa beberapa tindakan sekaligus. 

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

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

Menghapus izin

Anda dapat dengan mudah menghapus izin untuk serangkaian kombinasi tindakan dan sumber daya tertentu. 

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

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

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

Anda juga dapat menghapus semua izin untuk contoh kunci. 

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

$ lock -> clear ();

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

Menetapkan alias tindakan

Untuk mengelompokkan beberapa tindakan dan menetapkan semuanya sekaligus, Anda mungkin ingin menetapkan alias tindakan. 

 $ 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

Menetapkan pemanggil Tuhan

Anda dapat dengan mudah mengatur pemanggil yang memiliki semua izin untuk semuanya dengan meneruskan all wildcard sebagai tindakan pada instance kunci. 

 $ lock -> allow ( ' all ' );

Sekarang setiap pemanggilan metode "can" akan divalidasi menjadi true untuk pemanggil ini.

Bekerja dengan peran

Lock menyediakan cara mudah untuk bekerja dengan peran. Anda dapat bekerja dengan peran secara langsung, tetapi jika Anda ingin bekerja dengan warisan, Anda harus mendaftarkan peran tersebut ke instance manajer. 

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

Atau daftarkan beberapa peran sekaligus. 

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

Mari atur beberapa izin dan lihat cara penyelesaiannya. 

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

Sesuatu yang perlu Anda waspadai adalah izin tingkat pemanggil menggantikan izin tingkat peran. Mari kita lihat cara kerjanya.

Penelepon kami akan memiliki peran pengguna. 

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

Bekerja dengan kondisi

Kondisi sebenarnya ditegaskan yang merupakan pemeriksaan tambahan yang dapat Anda atur untuk izin. Anda dapat meneruskan array dengan mereka sebagai parameter terakhir dari allow dan deny . Semua kondisi harus mengimplementasikan antarmuka BeatSwitchLockPermissionsCondition .

Peringatan: harap dicatat bahwa kondisi saat ini hanya berfungsi dengan driver statis.

Mari kita siapkan suatu kondisi. 

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

Sekarang mari kita lihat cara kerjanya saat menyiapkan izin. 

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

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

Anda juga dapat menyampaikan berbagai ketentuan. 

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

Anda dapat menyampaikan sebanyak mungkin ketentuan yang Anda suka, tetapi semuanya harus berhasil agar izin dapat berfungsi.

Anda juga dapat menggunakan panggilan balik jika Anda mau. 

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

Mengambil sumber daya yang diizinkan atau ditolak

Jika Anda ingin mengambil daftar sumber daya yang diperbolehkan atau ditolak untuk melakukan tindakan tertentu, Anda dapat menggunakan metode allowed dan denied pada 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];

Harap diingat bahwa Anda hanya dapat mengambil id dari sumber daya yang izinnya ditetapkan. Sumber daya yang tidak didaftarkan melalui Lock tidak akan dikembalikan.

Menggunakan sifat LockAware

Anda dapat dengan mudah menambahkan fungsionalitas acl ke pemanggil atau peran Anda dengan menerapkan sifat 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 ' ];
    }
}

Sekarang kita perlu menyetel instance kuncinya. 

 $ caller -> setLock ( $ lock );

Dan sekarang penelepon Anda dapat menggunakan semua metode kunci itu sendiri. 

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

Jika Anda memiliki penelepon yang mengimplementasikan sifat LockAware tetapi belum mem-bootstrap instance kunci penelepon, Anda dapat dengan mudah membuat penelepon mengunci dengan menggunakan metode makeCallerLockAware manajer. 

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

Dan sekarang penelepon Anda dapat menggunakan metode LockAware . Ada metode serupa untuk peran. 

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

Ini akan mem-bootstrap objek SimpleRole yang sudah dilengkapi dengan sifat LockAware .

Api

BeatSwitchKunciKunci

Semua metode berikut dapat dipanggil pada instans BeatSwitchLockLock .

Bisa

Memeriksa apakah penelepon saat ini memiliki izin untuk melakukan sesuatu. 

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

tidak bisa

Memeriksa apakah penelepon saat ini dilarang melakukan sesuatu. 

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

mengizinkan

Menetapkan izin Privilege pada penelepon untuk mengizinkannya melakukan sesuatu. Menghapus batasan yang cocok. 

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

membantah

Menetapkan izin Restriction pada penelepon untuk mencegahnya melakukan sesuatu. Menghapus hak istimewa apa pun yang cocok. 

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

beralih

Mengalihkan nilai untuk izin yang diberikan. 

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

diizinkan

Mengembalikan semua id dalam larik jenis sumber daya tertentu yang memungkinkan subjek melakukan tindakan tertentu. 

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

ditolak

Mengembalikan semua id dalam larik dengan tipe sumber daya tertentu yang subjeknya ditolak untuk melakukan tindakan tertentu. 

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

BeatSwitchLockManager

Semua metode berikut dapat dipanggil pada instance BeatSwitchLockManager .

penelepon

Mengembalikan instance BeatSwitchLockLock untuk pemanggil. 

 caller(
    BeatSwitchLockCallersCaller $caller
)

peran

Mengembalikan instance BeatSwitchLockLock untuk sebuah peran. 

 role(
    BeatSwitchLockRolesRole $role
)

alias

Tambahkan alias untuk satu atau beberapa tindakan. 

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

setPeran

Tetapkan satu atau beberapa peran dan peran opsional untuk mewarisi izin. 

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

makeCallerLockAware

Menyetel instance kunci untuk pemanggil yang mengimplementasikan sifat LockAware . Mengembalikan pemanggil dengan set instance kunci. 

 makeCallerLockAware(
    BeatSwitchLockCallersCaller $caller
)

makeRoleLockAware

Menyetel instance kunci untuk peran yang mengimplementasikan sifat LockAware . Mengembalikan peran dengan kumpulan instance kunci. 

 makeRoleLockAware(
    BeatSwitchLockRolesRole|string $role
)

Membangun pengemudi

Anda dapat dengan mudah membuat driver dengan menerapkan kontrak BeatSwitchLockDriversDriver . Di bawah ini kami akan mendemonstrasikan cara membuat driver persisten kami sendiri menggunakan Eloquent ORM Laravel sebagai mekanisme penyimpanan kami.

Kita asumsikan kita memiliki kelas model CallerPermission dengan setidaknya kolom database berikut:

  • caller_type (varchar, 100)
  • caller_id (int, 11)
  • type (varchar, 10)
  • action (varchar, 100)
  • resource_type (varchar, 100, dapat dibatalkan)
  • resource_id (int, 11, dapat dibatalkan)

Dan kami memiliki model RolePermission dengan kolom database berikut:

  • role (varchar, 100)
  • type (varchar, 10)
  • action (varchar, 100)
  • resource_type (varchar, 100, dapat dibatalkan)
  • resource_id (int, 11, dapat dibatalkan)

Mari kita lihat implementasi lengkap dari driver di bawah ini. Perhatikan bahwa untuk metode getCallerPermissions kita menggunakan kelas PermissionFactory untuk memetakan data dengan mudah dan membuat objek Permission dari data tersebut. Metode createFromData PermissionFactory akan menerima array dan objek. 

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

Perhatikan bahwa kami tidak memeriksa apakah izin sudah ada saat kami mencoba menyimpannya. Anda tidak perlu khawatir tentang hal itu karena semuanya telah dilakukan untuk Anda di instance Lock .

Sekarang kami memiliki driver yang mendukung penyimpanan izin untuk penelepon dan peran.

Menguji driver Anda

Sangat mudah bagi Anda untuk memastikan driver Anda berfungsi sesuai harapan. Jika Anda membuat driver persisten, Anda dapat dengan mudah mengujinya dengan membuat pengujian PHPUnit yang memperluas kelas 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 ();
    }
}

Dan hanya ini yang Anda butuhkan! PersistentDriverTestCase berisi semua tes yang Anda perlukan untuk memastikan driver Anda berfungsi seperti yang diharapkan. Jadi jika semua tes tersebut lulus maka driver Anda telah dikonfigurasi dengan benar. Tidak perlu mengejek apa pun, ini adalah kasus uji integrasi murni. Tentu saja dalam contoh spesifik di atas, agar Eloquent berfungsi, Anda perlu melakukan bootstrap Laravel. Bekerja dengan database seperti sqlite akan menjadi cara terbaik untuk menguji driver Anda.

Pemelihara

Kunci tidak dipertahankan pada saat ini.

Paket ini saat ini dikelola oleh Dries Vints.
Jika Anda memiliki pertanyaan, jangan ragu untuk menanyakannya dalam suatu masalah.

Berkontribusi

Silakan lihat file kontribusi untuk detailnya.

log perubahan

Anda dapat melihat daftar perubahan untuk setiap rilis di file changelog kami.

Lisensi

Lisensi MIT. Silakan lihat file lisensi untuk informasi lebih lanjut.

Memperluas
Informasi Tambahan
Aplikasi Terkait
Direkomendasikan untuk Anda
Informasi Terkait Semua