ในปัจจุบัน เว็บแอปพลิเคชันจำนวนมากจะแสดงหน้าเว็บที่เข้าถึงได้แบบสาธารณะ เช่น หน้าแรก และหน้าเว็บที่มีความปลอดภัยมากขึ้น ซึ่งผู้ใช้ต้องเข้าสู่ระบบเพื่อเข้าถึง กระบวนการลงทะเบียนผู้ใช้ การเข้าสู่ระบบ และการติดตามสถานะเซสชันของผู้ใช้เรียกว่า "การรับรองความถูกต้อง"
ในเวลาเดียวกัน เมื่อต้องจัดการกับผู้ใช้ที่เข้าสู่ระบบ จำเป็นต้องแยกการดำเนินการและทรัพยากรที่พร้อมใช้งานตามบทบาทของผู้ใช้ ตัวอย่างเช่น โดยทั่วไป "ผู้ดูแลระบบ" จะมีสิทธิ์เข้าถึงมากกว่าผู้ใช้ทั่วไป กระบวนการแยกการเข้าถึงของผู้ใช้ที่ผ่านการรับรองความถูกต้องนี้เรียกว่า "การอนุญาต"
ในโพสต์นี้ เราจะสำรวจไลบรารีการอนุญาตที่ได้รับความนิยมมากที่สุดสองแห่งใน Ruby:Pundit และ CanCanCan
มาดำดิ่งกันเถอะ!
การตั้งค่าและข้อกำหนดเบื้องต้น
ในบทความนี้ เราจะใช้แอป Rails 7 แบบง่ายๆ ที่มีผู้ใช้และโพสต์ ผู้ใช้จะได้รับมอบหมายบทบาท "บรรณาธิการ" หรือ "ผู้เขียน" สถานการณ์ดังกล่าวเหมาะอย่างยิ่งสำหรับการจัดแสดงวิธีการทำงานของการอนุญาต
ตรวจสอบที่เก็บโค้ดสำหรับแอปตัวอย่างของเราด้วย:
- บัณฑิต
- แคนแคนแคน
แม้ว่าบทความนี้จะเน้นไปที่การอนุญาต แต่ก็ไม่สามารถละเลยหัวข้อร่วมของการตรวจสอบสิทธิ์ได้
เราจะไม่ลงรายละเอียดการตั้งค่าการตรวจสอบสิทธิ์เนื่องจากอยู่นอกขอบเขตของโพสต์นี้ คุณสามารถปฏิบัติตามคำแนะนำในการติดตั้งในเอกสาร Devise gem (เราจะจับคู่ Devise กับ authorization gems ของเรา)
อีกประการหนึ่ง ไม่ว่าคุณจะจัดการกับ Pundit หรือ CanCanCan งานจริงในการกำหนดบทบาทผู้ใช้ของแอปของคุณจะไม่เกิดขึ้นโดยอัตโนมัติเมื่อคุณติดตั้งอัญมณีการอนุญาตอันใดอันหนึ่ง คุณจะต้องตั้งค่าด้วยตนเอง
มาทำกันเถอะ
การกำหนดบทบาทของผู้ใช้
สมมติว่าคุณได้ติดตั้ง Devise gem และตั้งค่าโมเดลผู้ใช้แล้ว ขั้นตอนต่อไปคือการตัดสินใจว่าผู้ใช้แอปจะมีบทบาทใด ในกรณีของเรา เราจะกำหนดบทบาทต่อไปนี้:
- นักเขียน - บทบาทของผู้ใช้นี้สามารถ สร้าง ได้ , แก้ไข , อัปเดต และลบ โพสต์ของตนเอง ในขณะเดียวกัน นักเขียนก็สามารถ ดู ได้เช่นกัน โพสต์ของนักเขียนคนอื่น
- ผู้แก้ไข - ผู้ใช้ที่มีบทบาทผู้แก้ไขสามารถ แก้ไข ได้ , อัปเดต , ดู และลบ โพสต์ของผู้ใช้คนใดคนหนึ่ง แต่ไม่สามารถ สร้าง ได้ โพสต์ของตนเอง
เพิ่มคอลัมน์เพื่อจัดเก็บบทบาทของผู้ใช้ (โดยใช้การย้ายข้อมูลเพื่อแก้ไขตารางของผู้ใช้):
จากนั้นเรียกใช้การย้ายข้อมูล:
จากนั้นแก้ไขโมเดลผู้ใช้เพื่อรวมบทบาทที่เราเพิ่งกำหนดไว้:
ขณะที่เรากำลังดำเนินการอยู่ เรามาตั้งค่า 01 กันดีกว่า โมเดลที่มีแอตทริบิวต์ 11 และ 23 รวมถึงการอ้างอิงถึงผู้ใช้ที่เขียนโพสต์:
เราเพิ่มคีย์ต่างประเทศ user_id ลงใน 35 แบบจำลองเพื่อเชื่อมโยงทุกโพสต์ที่สร้างขึ้นกับผู้ใช้รายใดรายหนึ่ง เนื่องจากเราได้ตั้งค่าการตรวจสอบสิทธิ์ผู้ใช้โดยใช้ Devise แล้ว เราจึงสามารถแก้ไขวิธีการสร้างของ 44 ได้ คอนโทรลเลอร์เพื่อตั้งค่า user_id โดยอัตโนมัติ ถึงผู้ใช้ที่เข้าสู่ระบบอยู่ในปัจจุบัน:
นอกจากนี้เรายังสามารถแก้ไขโมเดลผู้ใช้เพื่อให้แน่ใจว่าเชื่อมโยงกับ 59 รุ่น:
สุดท้ายนี้ เรามาเริ่มต้นฐานข้อมูลกับผู้ใช้บางคน ซึ่งแต่ละคนมีบทบาทที่แตกต่างกัน:
จากนั้นทำการเพาะฐานข้อมูล:
จนถึงตอนนี้แอปของเรามี:
- การตรวจสอบสิทธิ์ที่ตั้งค่าโดยใช้ Devise
- บทบาทผู้ใช้ที่กำหนดไว้สองบทบาทคือ "ผู้เขียน" และ "บรรณาธิการ"
- A
62 รุ่น.
ด้วยเหตุนี้ ตอนนี้เราจึงมีทุกสิ่งที่จำเป็นในการทำงานกับบัณฑิตอย่างเหมาะสม
การอนุญาตในแอป Ruby ของคุณด้วย Pundit
Pundit เป็นไลบรารีการอนุญาตที่สร้างขึ้นจากสถาปัตยกรรมเชิงวัตถุและคลาส Ruby ธรรมดา โดยให้เครื่องมือแก่คุณในการสร้างเลเยอร์การอนุญาตที่มั่นคงซึ่งสามารถปรับขนาดตามแอปของคุณได้
การติดตั้ง Pundit ในแอป Ruby ของคุณ
เพิ่มอัญมณีลงใน Gemfile ของแอปของคุณ:
จากนั้นในเทอร์มินัล ให้รันคำสั่ง:
หรือรันคำสั่งต่อไปนี้:
เนื่องจากการอนุญาตส่วนใหญ่เกี่ยวข้องกับการอนุญาตหรือการปฏิเสธการเข้าถึงทรัพยากรตัวควบคุม ขั้นตอนต่อไปคือการเพิ่มโมดูลการอนุญาตของ Pundit ไปยังตัวควบคุมแอปพลิเคชัน:
และสุดท้าย สร้างคลาสนโยบายพื้นฐาน นโยบายอื่นๆ ทั้งหมดจะสืบทอดมาจาก:
ซึ่งให้คลาสนโยบายพื้นฐานต่อไปนี้แก่คุณ:
ด้วยเหตุนี้ บัณฑิตจึงได้รับการตั้งค่าอย่างเหมาะสมและพร้อมที่จะดำเนินการแล้ว นอกจากนี้เรายังมีการตั้งค่าการตรวจสอบสิทธิ์และบทบาทของผู้ใช้
ต่อไป ลองใช้นโยบายเพื่อใช้กฎที่กำหนดวิธีที่แต่ละบทบาทของผู้ใช้จะเข้าถึง 76 ทรัพยากร
การกำหนดค่านโยบายบัณฑิต
ในศัพท์แสงของบัณฑิต "นโยบาย" คือคลาส Ruby ธรรมดาที่คุณกำหนดกฎทั้งหมดสำหรับวิธีที่บทบาทของผู้ใช้โต้ตอบกับทรัพยากรต่างๆ
นโยบายเหล่านี้มาพร้อมกับคุณลักษณะเด่นบางประการ:
- แต่ละนโยบายตั้งชื่อตามโมเดลที่มีอยู่ โดยต่อท้ายด้วยคำว่า "นโยบาย" ตัวอย่างเช่น นโยบายที่กำหนดวิธีการ
80การเข้าถึงโมเดลเรียกว่า93. - เป็น
102:ใช้เวลาสองอาร์กิวเมนต์ - อันแรกคือ110โดยเฉพาะผู้ใช้ที่เข้าสู่ระบบในปัจจุบัน —126— และอาร์กิวเมนต์ที่สองคือโมเดลที่คุณต้องการกำหนดกฎการให้สิทธิ์ ในกรณีของเรา138. - วิธีการสืบค้นที่จะแมปกับวิธีการควบคุมของทรัพยากรที่มีการตั้งค่ากฎการให้สิทธิ์ เพื่อวัตถุประสงค์ขององค์กร วิธีที่ดีที่สุดคือมีนโยบายทั้งหมดภายใต้
148โฟลเดอร์
เนื่องจากเรารู้ว่ากฎการเข้าถึงใดที่เราจำเป็นต้องกำหนดสำหรับบทบาทผู้ใช้ต่างๆ ในแอปของเรา เรามาเริ่มกันที่บทบาทผู้เขียนกันดีกว่า
การกำหนดนโยบายผู้รอบรู้สำหรับบทบาท
ลองใช้บทบาทนักเขียนเพื่อดูว่าจะทำเช่นนี้ได้อย่างไร ขั้นแรก เราสามารถร่างโครงร่างการเข้าถึงของบทบาทผู้เขียนใน 158 ได้ ทรัพยากรดังต่อไปนี้:
- สร้าง โพสต์ของตนเอง
- แก้ไขและอัปเดต โพสต์ของตนเอง
- ดู (หรืออ่าน) โพสต์ของตนเองและโพสต์ของผู้ใช้รายอื่น
- ลบ โพสต์ของตนเอง
ด้วยเหตุนี้ โปรดสร้างนโยบายใหม่เพื่อควบคุมวิธีเข้าถึงโพสต์:
สิ่งนี้ทำให้เรามีคลาสนโยบายทั่วไปต่อไปนี้ที่สืบทอดมาจากนโยบายพื้นฐานที่เราสร้างไว้ก่อนหน้านี้:
ตอนนี้เรามาเพิ่มกฎการเข้าถึงสำหรับบทบาทผู้เขียนตามลำดับ (สิ่งเหล่านี้จะแทนที่กฎใด ๆ ที่สืบทอดมาจากคลาสนโยบายพื้นฐานด้วย):
ที่นี่ เรากำหนดสิ่งที่ผู้เขียนสามารถทำได้เมื่อสร้าง แก้ไข อัปเดต และลบโพสต์ ซึ่งเป็นการดำเนินการที่สอดคล้องกันบนตัวควบคุมของโพสต์ หากคุณสังเกตเห็น กฎเหล่านี้ใช้กับโพสต์โดยทั่วไป และไม่จำเป็นกับโพสต์ของผู้เขียนเอง (เราจะพูดถึงกฎนั้นในหัวข้อขอบเขต)
สำหรับตอนนี้ เรามาดูกันว่าเราจะใช้นโยบายนี้ได้อย่างไร
การใช้นโยบายในบัณฑิต
หากต้องการใช้นโยบาย ให้โทรไปที่ 169 ของบัณฑิต วิธีการของตัวควบคุมที่คุณต้องการตรวจสอบกฎการเข้าถึง คุณสร้างอินสแตนซ์ของคลาสนโยบายที่เกี่ยวข้อง และโดยเฉพาะอย่างยิ่ง การดำเนินการที่ควรถูกเรียกใช้โดยยึดตามตำแหน่งที่ 176 วิธีการถูกเรียกแล้ว
ตัวอย่างเช่น เรียก 185 บน สร้าง ของตัวควบคุมโพสต์ วิธีการ:
หากต้องการทดสอบ ให้เข้าสู่ระบบในฐานะโปรแกรมแก้ไขและลอง 196 โพสต์ การทำเช่นนี้จะส่งผลให้เกิดข้อผิดพลาดต่อไปนี้:
แม้ว่าการดำเนินการนี้จะเป็นไปตามที่เราต้องการ แต่การแสดงหน้าข้อผิดพลาดดังกล่าวนั้นไม่ดีต่อประสบการณ์ของผู้ใช้ ในส่วนถัดไป คุณจะได้เรียนรู้วิธีช่วยเหลือ 202 และให้บริการที่เป็นมิตรต่อผู้ใช้มากขึ้น
การช่วยเหลือจาก 214 ของบัณฑิต
ก่อนอื่น เราจะต้องแก้ไข 224 ดังนี้:
โดยพื้นฐานแล้ว เรากำลังบอกให้บัณฑิตใช้ 237 วิธีการเมื่อใดก็ตามที่ 248 ถูกยกขึ้น มันจะเปลี่ยนเส้นทางผู้ใช้ที่ไม่ได้รับอนุญาตไปยังเพจเฉพาะและยังมีข้อความแฟลชที่เกี่ยวข้องเพื่ออธิบายสิ่งที่เกิดขึ้น:
ขณะนี้เรามีระบบการอนุญาตที่เรียบง่ายซึ่งสามารถจัดการกรณีการอนุญาตทั่วไปได้
แต่ถ้าเราต้องการการอนุญาตที่ละเอียดกว่านี้ล่ะ? สำหรับสิ่งนี้ เราจำเป็นต้องใช้ขอบเขตของบัณฑิต
ขอบเขตของบัณฑิต
ขอบเขตบัณฑิตมีความคล้ายคลึงกับขอบเขต ActiveRecord ในระยะหลัง คุณสามารถใช้ขอบเขตเพื่อดึงข้อมูลบันทึกตามเกณฑ์เฉพาะได้ อย่างไรก็ตาม ด้วยขอบเขตของบัณฑิต คุณสามารถจัดการการเข้าถึงทรัพยากรเฉพาะตามกฎเกณฑ์ที่คุณตั้งไว้
สมมติว่าเราต้องการให้บรรณาธิการสามารถดูและแก้ไขโพสต์ที่อยู่ในสถานะ "ฉบับร่าง" และในขณะเดียวกันก็อนุญาตให้ผู้เขียนสร้าง ดู แก้ไข อัปเดต และลบโพสต์ที่เป็นของพวกเขาเท่านั้น
เราสามารถเริ่มต้นด้วยการแก้ไขนโยบายการโพสต์ให้มีลักษณะดังนี้:
จากนั้นเราจะให้สิทธิ์การเข้าถึงทรัพยากรในตัวควบคุมโพสต์ เช่น:
แน่นอนว่าการกำหนดขอบเขตด้วย Pundit สามารถเจาะลึกได้มากกว่าที่เราแสดงไว้ แต่เราจะทิ้งไว้อย่างนั้นในโพสต์นี้ หากคุณต้องการ โปรดดูเอกสารประกอบของบัณฑิตเพื่อดูว่าคุณสามารถใช้ขอบเขตในลักษณะขั้นสูงได้อย่างไร
สำหรับตอนนี้ มาดูกันว่าคุณสามารถใช้ไลบรารี่กับพารามิเตอร์ที่แข็งแกร่งของ Rails ได้อย่างไร
การใช้บัณฑิตกับพารามิเตอร์ที่แข็งแกร่งของ Rails
ด้วยการรวมกฎการอนุญาตของ Pundit เข้ากับพารามิเตอร์ที่รัดกุมของ Rails คุณสามารถเข้าถึงคุณลักษณะของทรัพยากรแบบล็อกดาวน์ได้ สมมติว่าคุณต้องการ บรรณาธิการ เป็นคนเดียวที่สามารถเข้าถึงฟิลด์ข้อความที่ตัดตอนมาจาก 258 โมเดล คุณจะทำยังไง?
ขั้นแรก เพิ่มบล็อกที่มีชื่อเหมาะสมให้กับนโยบายที่เกี่ยวข้อง:
จากนั้น แก้ไขบล็อกพารามิเตอร์ที่ได้รับอนุญาตในคอนโทรลเลอร์:
ด้วยเหตุนี้ คุณจึงได้ข้อความที่ตัดตอนมา คุณลักษณะมีให้สำหรับผู้แก้ไขเท่านั้น
ตอนนี้เราจะเปลี่ยนเกียร์เพื่อดูไลบรารีการอนุญาตอื่น CanCanCan
ขอแนะนำ CanCanCan สำหรับแอป Ruby ของคุณ
CanCanCan เป็นไลบรารีการอนุญาตที่ใช้คลาส "ความสามารถ" เพื่อกำหนดว่าใครสามารถเข้าถึงสิ่งใดในแอป Rails การควบคุมการเข้าถึงจริงทำได้โดยใช้โมดูลการอนุญาตและตัวช่วยมุมมองต่างๆ
การติดตั้ง CanCanCan
การติดตั้งทำได้ง่ายเพียงแค่รันคำสั่งด้านล่าง:
เช่นเดียวกับ Pundit ด้วย CanCanCan คุณสามารถกำหนดกฎการเข้าถึงทั้งหมดภายในอ็อบเจ็กต์คลาส Ruby ธรรมดาที่เรียกว่าคลาส "ความสามารถ" มาทำอย่างนั้นต่อไปด้วยคำสั่งตัวสร้างต่อไปนี้:
ซึ่งสร้างวัตถุคลาสด้านล่าง:
มาเรียนรู้เพิ่มเติมว่าคลาสความสามารถสามารถกำหนดกฎการเข้าถึงสำหรับแอป Rails ตัวอย่างของเราได้อย่างไรต่อไป
การกำหนดและการตรวจสอบความสามารถของ CanCanCan
เราจะใช้บทบาทของผู้ใช้เช่นเดียวกับในตัวอย่างบัณฑิต:นักเขียนและบรรณาธิการ ผู้เขียนสามารถสร้าง แก้ไข อัปเดต ทำลายโพสต์ของตนเอง และดูโพสต์ของผู้เขียนคนอื่นได้ ผู้แก้ไขสามารถทำทุกอย่างยกเว้นสร้างโพสต์ของตนเอง
หากต้องการใช้ CanCanCan ขั้นแรกให้กำหนดสิ่งที่ผู้ใช้หรือบทบาทแต่ละคนสามารถเข้าถึงได้ในคลาสความสามารถ ตามรูปแบบนี้:
เป็นตัวอย่าง:
จากนั้น ในคอนโทรลเลอร์ ให้ตรวจสอบว่ามีกฎการเข้าถึงสำหรับการดำเนินการเฉพาะหรือไม่ โดยใช้ตัวอย่างของเรา 267 การกระทำ:
ด้วยเหตุนี้ หากเราไปที่มุมมองแก้ไขโพสต์ในฐานะผู้เขียนรายอื่น เราจะได้รับข้อผิดพลาดด้านล่าง:
และเช่นเดียวกับที่เราทำกับ Pundit มาแก้ไขข้อผิดพลาดนี้และแสดงหน้าข้อผิดพลาดที่ดีขึ้นแก่ผู้ใช้
การจัดการข้อผิดพลาด “การเข้าถึงถูกปฏิเสธ” ของ CanCanCan
เมื่อใดก็ตามที่ทรัพยากรไม่ได้รับอนุญาต CanCanCan จะเพิ่ม 272 ข้อผิดพลาด วิธีที่ง่ายที่สุดในการตรวจจับข้อยกเว้นนี้คือการแก้ไข 285 ดังนี้:
การทำเช่นนี้ทำให้ผู้ใช้ได้รับประสบการณ์ที่ดี ในภาพหน้าจอด้านล่าง ผู้ใช้ที่ไม่ได้รับอนุญาตจะถูกเปลี่ยนเส้นทางไปยังหน้าแรกและแสดงข้อความแฟลชที่เกี่ยวข้อง:
คุณยังสามารถปรับแต่งข้อความแสดงข้อผิดพลาดที่แสดงต่อผู้ใช้:
หากแอปของคุณให้บริการ XML เป็นการตอบกลับ หรือคุณเพียงต้องการเจาะลึกยิ่งขึ้นในการจัดการ 293 ข้อยกเว้น โปรดดูเอกสารของ CanCanCan สำหรับตอนนี้ เรามาดูกันว่าเราจะรวมความสามารถต่างๆ ของ CanCanCan เพื่อสร้างเลเยอร์การอนุญาตที่แข็งแกร่งยิ่งขึ้นได้อย่างไร
การรวมความสามารถ CanCanCan หลายรายการเข้าด้วยกัน
คุณสามารถกำหนดกฎการเข้าถึงได้หลายกฎสำหรับทรัพยากรในคลาสความสามารถ ตัวอย่างเช่น การรับบทบาทนักเขียนและบรรณาธิการ เราสามารถทำสิ่งนี้ได้:
คำถามคือ ทำไมคุณถึงต้องการทำเช่นนี้
ด้วย CanCanCan คุณสามารถกำหนดกฎการเข้าถึงทั้งหมดในไฟล์ความสามารถเดียว สิ่งนี้มีทั้งข้อดีและข้อเสีย
การมีกฎทั้งหมดไว้ในที่เดียวสะดวกมากในการจัดการกฎการเข้าถึง เนื่องจากกฎทั้งหมดได้รับการกำหนดไว้ในที่เดียว
อย่างไรก็ตาม หากแอปของคุณเกี่ยวข้องกับบทบาทของผู้ใช้จำนวนมากหรือคุณมีทรัพยากรหลายอย่างที่ต้องมีการอนุญาต คลาสความสามารถอาจมีขนาดใหญ่เกินไปและซับซ้อนเกินกว่าจะจัดการได้อย่างง่ายดาย วิธีหนึ่งในการจัดการกับสิ่งนี้คือการจัดคลาสความสามารถใหม่เพื่อใช้คำจำกัดความของเมธอด ดังเช่น:
CanCanCan มีอะไรอีกมากมายเกินกว่าที่จะกล่าวถึงได้อย่างมีประสิทธิภาพในบทความนี้ ตรวจสอบเอกสาร CanCanCan โดยละเอียดเพื่อเรียนรู้เพิ่มเติม
เพื่อสรุป เราจะกล่าวถึงคุณลักษณะต่างๆ ของแต่ละห้องสมุดโดยสรุป และให้เหตุผลว่าทำไมคุณถึงเลือกห้องสมุดใดห้องสมุดหนึ่ง
การเปรียบเทียบคุณสมบัติ:Pundit กับ CanCanCan สำหรับแอป Ruby ของคุณ
- การจัดระเบียบไฟล์ - ด้วย Pundit คุณสามารถจัดระเบียบการอนุญาตของแอปของคุณผ่านไฟล์นโยบายหลายไฟล์ได้อย่างง่ายดาย แต่ด้วย CanCanCan กฎการอนุญาตจะอยู่ในไฟล์ความสามารถเดียว การทำงานกับไฟล์ความสามารถหลายไฟล์ยังคงเป็นไปได้ แต่นี่ไม่ใช่รูปแบบการใช้งานเริ่มต้น
- การทดสอบ - เนื่องจากรหัสสิทธิ์ส่วนใหญ่จะอยู่ภายในคลาสเดียวเมื่อเทียบกับคลาสความสามารถหลายคลาสของ Pundit การเขียนการทดสอบสำหรับ CanCanCan อาจง่ายกว่าสำหรับ Pundit
- ผู้ช่วยเหลือ - ไลบรารีทั้งสองมีตัวช่วยดูจำนวนหนึ่งเพื่อตรวจสอบสิทธิ์ในเลเยอร์มุมมอง CanCanCan ให้
300แก่คุณ วิธีการใช้ในมุมมองของคุณ ในขณะที่ Pundit ให้ฟังก์ชันการทำงานที่ค่อนข้างคล้ายกับ317ผู้ช่วยเหลือ - บูรณาการอุปกรณ์ - ดังที่คุณเห็นจากตัวอย่างที่เราใช้ในบทความ ไลบรารีทั้งสองทำงานร่วมกับ Devise ได้เป็นอย่างดี
สรุป
ในบทความนี้ เราได้ดูอัญมณีการอนุญาตที่ได้รับความนิยมมากที่สุดสองรายการในระบบนิเวศ Ruby และ Rails:Pundit และ CanCanCan
ไลบรารีทั้งสองมีชุดคุณสมบัติมากมายสำหรับการจัดการสิทธิ์ในแอป Rails ของคุณ ด้วยเหตุนี้ จึงแทบจะเป็นไปไม่ได้เลยที่จะบอกคุณว่าควรเลือกอัญมณีใด — ทั้งสองสามารถจัดการได้แม้กระทั่งการตั้งค่าสิทธิ์ที่ซับซ้อนที่สุด
เราขอแนะนำให้คุณลองใช้ Pundit และ CanCanCan ในแอปของคุณและดูว่าอันไหนที่เหมาะกับความต้องการของคุณมากที่สุด
ขอให้สนุกกับการเขียนโค้ด!
ปล. หากคุณต้องการอ่านโพสต์ Ruby Magic ทันทีที่เผยแพร่ สมัครรับจดหมายข่าว Ruby Magic ของเราและไม่พลาดแม้แต่โพสต์เดียว!
