lock
1.0.0
ฉันเสียใจที่ต้องบอกว่าขณะนี้ Lock ไม่ได้รับการบำรุงรักษา ฉันจะให้การสนับสนุนหรือรับการสนับสนุนใหม่ไม่ได้ในขณะนี้ ลำดับความสำคัญอื่น ๆ กำลังขัดขวางฉันไม่ให้ทำงานให้กับล็อคอย่างที่สมควรได้รับ ในที่สุดฉันก็จะพยายามรับงานอีกครั้ง แต่น่าเสียดายที่ไม่สามารถบอกได้ว่าเมื่อไหร่ ฉันขอขอบคุณผู้มีส่วนร่วมและผู้ใช้ทุกคน
-- แห้ง
Lock เป็นแพ็คเกจ Acl ที่ยืดหยุ่นและอิงไดรเวอร์สำหรับ PHP 5.4+
สร้างโดย Dries Vints เกิดขึ้นได้ด้วย BeatSwitch แรงบันดาลใจจากผู้มีอำนาจโดย Matthew Machuga โลโก้โดยเจอร์รี่โลว์
Lock : อินสแตนซ์ ACL สำหรับหัวเรื่อง ปัจจุบันแพ็คเกจนี้มาพร้อมกับ CallerLock และ RoleLockCaller : วัตถุประจำตัวที่สามารถมีสิทธิ์ในการทำบางสิ่งบางอย่างDriver : ระบบจัดเก็บข้อมูลสำหรับการอนุญาตซึ่งอาจเป็นแบบคงที่หรือถาวรก็ได้Permission : การอนุญาตระงับการดำเนินการและทรัพยากรทางเลือก (ไม่ซ้ำกัน) อาจเป็น Restriction หรือ Privilege ก็ได้Restriction : ข้อจำกัดปฏิเสธว่าคุณไม่สามารถดำเนินการได้ (บนทรัพยากรทางเลือก)Privilege : สิทธิ์อนุญาตให้คุณดำเนินการได้ (บนทรัพยากรทางเลือก)Action : การกระทำคือสิ่งที่คุณได้รับอนุญาตหรือปฏิเสธไม่ให้ทำResource : ทรัพยากรอาจเป็นออบเจ็กต์ที่คุณสามารถดำเนินการได้อย่างน้อย 1 รายการ สามารถกำหนดเป้าหมายทรัพยากรบางประเภทหรือทรัพยากรเฉพาะตามตัวระบุเฉพาะได้Role : บทบาทสามารถถือสิทธิ์ได้หลายรายการ ผู้โทรสามารถมีได้หลายบทบาท บทบาทสามารถสืบทอดสิทธิ์จากบทบาทอื่นได้ การล็อกแตกต่างจากแพ็คเกจ ACL อื่นๆ โดยพยายามจัดเตรียมวิธีที่ยืดหยุ่นที่สุดในการทำงานกับผู้เรียกสิทธิ์หลายรายและการจัดเก็บสิทธิ์
ด้วยการทำงานร่วมกับสัญญา Caller ของ Lock คุณสามารถตั้งค่าการอนุญาตสำหรับข้อมูลประจำตัวหลายรายการได้
สัญญา Driver อนุญาตให้มีวิธีง่ายๆ ในการจัดเก็บสิทธิ์ในระบบจัดเก็บข้อมูลถาวรหรือแบบคงที่ ArrayDriver แบบคงที่เริ่มต้นจะมาพร้อมกับแพ็คเกจนี้ ตรวจสอบรายการด้านล่างเพื่อดูไดรเวอร์เพิ่มเติมที่เตรียมไว้สำหรับคุณ หรือสร้างของคุณเองโดยใช้สัญญา Driver
คุณสามารถตั้งค่าและตรวจสอบสิทธิ์สำหรับทรัพยากรได้โดยการส่งผ่านประเภทของทรัพยากรและตัวระบุ (ไม่บังคับ) ด้วยตนเอง หรือคุณสามารถใช้สัญญา Resource กับออบเจ็กต์ของคุณ เพื่อให้คุณสามารถส่งต่อเพื่อล็อคได้ง่ายขึ้น
Manager ช่วยให้มีวิธีที่ง่ายดายในการสร้างอินสแตนซ์ Lock ใหม่ ตั้งค่านามแฝงการดำเนินการ หรือลงทะเบียนบทบาท
หากคุณต้องการการใช้งานเฉพาะกรอบงาน ให้เลือกไดรเวอร์ตัวใดตัวหนึ่งที่เตรียมไว้แล้วด้านล่าง
ติดตั้งแพ็คเกจนี้ผ่าน Composer
$ composer require beatswitch/lock ข้อมูลระบุตัวตนทุกรายการที่ควรมีสิทธิ์ในการทำบางสิ่งจะต้องปฏิบัติตามสัญญา 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อนุญาตให้ผู้โทรแก้ไขโพสต์ทั้งหมด แต่ปฏิเสธไม่ให้แก้ไขข้อความที่มีรหัส 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" ทุกรายการจะตรวจสอบว่าเป็นจริงสำหรับผู้โทรรายนี้
ล็อคช่วยให้ทำงานกับบทบาทต่างๆ ได้อย่างง่ายดาย คุณสามารถทำงานกับบทบาทได้ทันที แต่ถ้าคุณต้องการทำงานกับการสืบทอด คุณจะต้องลงทะเบียนบทบาทกับอินสแตนซ์ผู้จัดการ
$ 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. หากคุณต้องการดึงข้อมูลรายการทรัพยากรที่ได้รับอนุญาตหรือปฏิเสธให้ดำเนินการบางอย่าง คุณสามารถใช้วิธี allowed และ denied ในอินสแตนซ์ 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];โปรดจำไว้ว่าคุณสามารถดึงข้อมูล ID จากแหล่งข้อมูลที่มีการอนุญาตที่กำหนดไว้เท่านั้น ทรัพยากรที่ไม่ได้ลงทะเบียนผ่านล็อคจะไม่ถูกส่งคืน
คุณสามารถเพิ่มฟังก์ชัน acl ให้กับผู้โทรหรือบทบาทของคุณได้อย่างง่ายดายโดยการใช้คุณสมบัติ 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 ' ];
}
}ตอนนี้เราต้องตั้งค่าอินสแตนซ์การล็อค
$ caller -> setLock ( $ lock );และตอนนี้ผู้โทรของคุณสามารถใช้วิธีการล็อคทั้งหมดกับตัวมันเองได้
$ caller -> can ( ' create ' , ' posts ' );
$ caller -> allow ( ' edit ' , ' pages ' ); หากคุณมีผู้เรียกที่ใช้คุณลักษณะ LockAware แต่ไม่ได้บูตอินสแตนซ์การล็อคของผู้โทร แต่คุณสามารถทำให้ทราบการล็อคผู้โทรได้อย่างง่ายดายโดยใช้เมธอด makeCallerLockAware ของผู้จัดการ
$ caller = $ manager -> makeCallerLockAware ( $ caller ); และตอนนี้ผู้โทรของคุณจะสามารถใช้วิธี LockAware ได้ มีวิธีที่คล้ายกันสำหรับบทบาท
$ role = $ manager -> makeRoleLockAware ( ' guest ' ); การดำเนินการนี้จะบูตออบเจ็กต์ SimpleRole ที่มาพร้อมกับคุณลักษณะ LockAware อยู่แล้ว
วิธีการต่อไปนี้สามารถเรียกใช้ได้บนอินสแตนซ์ 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
)
ส่งกลับรหัสทั้งหมดในอาร์เรย์ของประเภททรัพยากรที่กำหนดซึ่งหัวเรื่องได้รับอนุญาตให้ดำเนินการที่กำหนด
allowed(
string|array $action,
string|BeatSwitchLockResourcesResource $resourceType
)
ส่งกลับรหัสทั้งหมดในอาร์เรย์ของประเภททรัพยากรที่กำหนดซึ่งหัวเรื่องถูกปฏิเสธไม่ให้ดำเนินการตามที่กำหนด
denied(
string|array $action,
string|BeatSwitchLockResourcesResource $resourceType
)
วิธีการต่อไปนี้สามารถเรียกใช้ได้บนอินสแตนซ์ BeatSwitchLockManager
ส่งคืนอินสแตนซ์ BeatSwitchLockLock สำหรับผู้โทร
caller(
BeatSwitchLockCallersCaller $caller
)
ส่งคืนอินสแตนซ์ BeatSwitchLockLock สำหรับบทบาท
role(
BeatSwitchLockRolesRole $role
)
เพิ่มนามแฝงสำหรับการดำเนินการอย่างน้อย 1 รายการ
alias(
string $name,
string|array $actions
)
ตั้งค่าอย่างน้อยหนึ่งบทบาทและบทบาททางเลือกเพื่อสืบทอดสิทธิ์
setRole(
string|array $name,
string $inherit = null
)
ตั้งค่าอินสแตนซ์การล็อกสำหรับผู้เรียกซึ่งใช้คุณลักษณะ LockAware ส่งคืนผู้โทรโดยตั้งค่าอินสแตนซ์ล็อคไว้
makeCallerLockAware(
BeatSwitchLockCallersCaller $caller
)
ตั้งค่าอินสแตนซ์การล็อกสำหรับบทบาทที่ใช้ลักษณะ LockAware ส่งคืนบทบาทพร้อมกับชุดอินสแตนซ์ล็อค
makeRoleLockAware(
BeatSwitchLockRolesRole|string $role
)
คุณสามารถสร้างไดรเวอร์ได้อย่างง่ายดายโดยใช้สัญญา BeatSwitchLockDriversDriver ด้านล่างนี้เราจะสาธิตวิธีสร้างไดรเวอร์ถาวรของเราเองโดยใช้ Eloquent ORM ของ Laravel เป็นกลไกการจัดเก็บข้อมูลของเรา
เราจะถือว่าเรามีคลาสโมเดล CallerPermission โดยมีคอลัมน์ฐานข้อมูลอย่างน้อยต่อไปนี้:
caller_type (varchar, 100)caller_id (int, 11)type (varchar, 10)action (varchar, 100)resource_type (varchar, 100, เป็นโมฆะ)resource_id (int, 11, เป็นโมฆะ) และเรามีโมเดล RolePermission พร้อมด้วยคอลัมน์ฐานข้อมูลต่อไปนี้:
role (varchar, 100)type (varchar, 10)action (varchar, 100)resource_type (varchar, 100, เป็นโมฆะ)resource_id (int, 11, เป็นโมฆะ) มาดูการใช้งานไดร์เวอร์แบบเต็มด้านล่างกัน โปรดสังเกตว่าสำหรับเมธอด getCallerPermissions เราใช้คลาส PermissionFactory เพื่อแมปข้อมูลและสร้างอ็อบเจ็กต์ Permission จากสิ่งเหล่านั้นได้อย่างง่ายดาย เมธอด createFromData ของ PermissionFactory จะยอมรับทั้งอาร์เรย์และอ็อบเจ็กต์
<?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
ตอนนี้เรามีไดรเวอร์ที่รองรับการจัดเก็บสิทธิ์สำหรับผู้โทรและบทบาท
เป็นเรื่องง่ายมากสำหรับคุณที่จะตรวจสอบให้แน่ใจว่าไดรเวอร์ของคุณทำงานตามที่คาดไว้ หากคุณกำลังสร้างไดรเวอร์ถาวร คุณสามารถทดสอบได้อย่างง่ายดายโดยสร้างการทดสอบ PHPUnit ซึ่งจะขยายคลาส 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 ();
}
} และนี่คือทั้งหมดที่คุณต้องการ! PersistentDriverTestCase มีการทดสอบทั้งหมดที่คุณต้องการเพื่อให้แน่ใจว่าไดรเวอร์ของคุณทำงานตามที่คาดไว้ ดังนั้นหากการทดสอบทั้งหมดผ่านไป แสดงว่าไดรเวอร์ของคุณได้รับการตั้งค่าอย่างถูกต้อง ไม่จำเป็นต้องล้อเลียนอะไรเลย นี่เป็นกรณีทดสอบการบูรณาการอย่างแท้จริง แน่นอนในตัวอย่างข้างต้นนี้ เพื่อให้ Eloquent ทำงานได้ คุณจะต้องบูตเครื่อง Laravel การทำงานกับฐานข้อมูลเช่น sqlite จะเป็นวิธีที่ดีที่สุดสำหรับการทดสอบไดรเวอร์ของคุณ
ล็อคไม่ได้รับการดูแลในขณะนี้
ปัจจุบันแพ็คเกจนี้ได้รับการดูแลโดย Dries Vints
หากคุณมีคำถามใดๆ โปรดอย่าลังเลที่จะถามพวกเขาในประเด็นปัญหา
โปรดดูไฟล์ที่มีส่วนร่วมสำหรับรายละเอียด
คุณสามารถดูรายการการเปลี่ยนแปลงสำหรับแต่ละรุ่นได้ในไฟล์บันทึกการเปลี่ยนแปลงของเรา
ใบอนุญาตเอ็มไอที โปรดดูไฟล์ใบอนุญาตสำหรับข้อมูลเพิ่มเติม
