Bagaimana untuk melaksanakan peruntukan automatik dan kitar semula kebenaran dalam Laravel

Laravel ialah rangka kerja PHP yang digunakan secara meluas yang menyediakan alatan mudah untuk melaksanakan masalah biasa seperti pengurusan kebenaran. Dalam kebanyakan aplikasi, kawalan terperinci ke atas kebenaran pengguna diperlukan untuk memastikan bahawa mereka hanya boleh mengakses perkara yang mereka perlukan untuk mengakses. Dalam artikel ini, kami akan meneroka cara menetapkan dan membatalkan kebenaran secara automatik dalam Laravel. Pada masa yang sama, kami juga akan menyediakan contoh kod khusus.

1. Gunakan perkaitan polimorfik dalam Laravel untuk merealisasikan peruntukan automatik dan kitar semula kebenaran

ORM Eloquent Laravel menyediakan fungsi perkaitan polimorfik, yang bermaksud kita boleh mengaitkan berbilang model berbeza dengan set data yang sama. Ini sangat berguna untuk peruntukan automatik dan kitar semula kebenaran.

Sebagai contoh, katakan kita perlu mengawal kebenaran pada "artikel" dan "komen" dalam aplikasi kita dan menetapkan peranan kepada pengguna. Kita boleh mencipta empat model berikut:

• Pengguna (pengguna)
• Artikel (artikel)
• Komen (komen)
• Peranan (peranan)

Kemudian, kita boleh menggunakan tiga model persatuan untuk menggabungkan tiga model persatuan Perkaitan dengan peranan:

class User extends Model
{
    public function roles()
    {
        return $this->morphToMany(Role::class, 'model', 'model_has_roles');
    }
}

class Article extends Model
{
    public function roles()
    {
        return $this->morphToMany(Role::class, 'model', 'model_has_roles');
    }
}

class Comment extends Model
{
    public function roles()
    {
        return $this->morphToMany(Role::class, 'model', 'model_has_roles');
    }
}

Contoh ini menggunakan fungsi perkaitan polimorfik Laravel, membolehkan kami mentakrifkan perhubungan peranan pada tiga model dan rekodnya. Langkah seterusnya ialah mencipta jadual perantaraan untuk mengadakan perhubungan ini:

class CreateModelHasRolesTable extends Migration
{
    public function up()
    {
        Schema::create('model_has_roles', function (Blueprint $table) {
            $table->unsignedBigInteger('role_id');
            $table->unsignedBigInteger('model_id');
            $table->string('model_type');
            $table->foreign('role_id')->references('id')->on('roles')->onDelete('cascade');
            $table->primary(['role_id', 'model_id', 'model_type']);
        });
    }
}

Kini kita boleh mengaitkan model di atas dengan peranan yang sepadan. Sebagai contoh, dengan mengandaikan kami menugaskan peranan "Pengarang" kepada pencipta siaran, kami boleh melakukan ini:

$article->roles()->syncWithoutDetaching([
    Role::where('name', 'author')->first()->id
]);

Begitu juga, membuat ulasan baharu dan memberikan peranan "Pengulas" kepada pencipta ulasan itu, kami boleh melakukan ini :

$comment = new Comment();
$comment->content = 'This is a new comment.';
$comment->user_id = Auth::user()->id;
$comment->save();
$comment->roles()->syncWithoutDetaching([
    Role::where('name', 'commenter')->first()->id
]);

Kod seperti ini membolehkan kita menggunakan peranan untuk mengawal siapa yang boleh melakukan tindakan yang mana. Kini, kami memerlukan cara untuk menetapkan peranan yang sesuai secara automatik kepada pengguna baharu dan siaran serta ulasan mereka, dan mengalih keluar tugasan peranan secara automatik apabila rekod tersebut dipadamkan.

2. Gunakan pendengar acara dalam Laravel untuk merealisasikan peruntukan automatik dan kitar semula kebenaran

Untuk merealisasikan peruntukan automatik dan kitar semula kebenaran, kami menggunakan pendengar acara dalam sistem acara Laravel untuk menangkap acara yang kami minati. Pendengar acara ialah mekanisme yang mendaftarkan fungsi tindak balas acara khusus aplikasi Mekanisme ini membolehkan kami bertindak balas kepada peristiwa yang berbeza dalam aplikasi dengan sangat fleksibel.

Sebagai contoh, Laravel menyediakan acara UserCreating dan UserDeleting, yang dicetuskan secara automatik apabila pengguna dibuat dan dipadamkan. Kita boleh menulis pendengar acara untuk mencipta hubungan peranan yang diperlukan apabila pengguna dibuat dan memadamkan hubungan ini apabila ia dipadamkan.

Pertama, kita perlu mentakrifkan pendengar acara baharu:

class UserEventListener
{
    public function onUserCreating(UserCreating $event)
    {
        $user = $event->user;
        $roles = Role::where('name', 'user')->get();

        foreach ($roles as $role) {
            $user->roles()->create([
                'role_id' => $role->id,
            ]);
        }
    }

    public function onUserDeleting(UserDeleting $event)
    {
        $user = $event->user;
        $user->roles()->detach();
    }
}

Pendengar acara ini mentakrifkan dua kaedah. Satu kaedah (onUserCreating) dicetuskan secara automatik apabila pengguna dibuat dan memberikan peranan "Pengguna" kepada pengguna. Kaedah lain (onUserDeleting) menyala secara automatik apabila pengguna memadam dan memadam semua rekod yang berkaitan dengan peranan itu.

Seterusnya, kami perlu mendaftarkan pendengar acara ini dalam penyedia perkhidmatan aplikasi kami:

class AppServiceProvider extends ServiceProvider
{
    protected $listen = [
        UserCreating::class => [
            UserEventListener::class,
        ],

        UserDeleting::class => [
            UserEventListener::class,
        ],
    ];

    public function boot()
    {
        //
    }
}

Kini apabila kami mencipta atau memadam pengguna, tindakan yang sesuai akan dilakukan secara automatik. Langkah terakhir dalam memasang peranan adalah untuk menentukan pendengar acara yang serupa untuk siaran dan ulasan.

class ArticleEventListener
{
    public function onArticleCreating(ArticleCreating $event)
    {
        $article = $event->article;
        $roles = Role::where('name', 'author')->get();

        foreach ($roles as $role) {
            $article->roles()->create([
                'role_id' => $role->id,
            ]);
        }
    }

    public function onArticleDeleting(ArticleDeleting $event)
    {
        $article = $event->article;
        $article->roles()->detach();
    }
}

class CommentEventListener
{
    public function onCommentCreating(CommentCreating $event)
    {
        $comment = $event->comment;
        $roles = Role::where('name', 'commenter')->get();

        foreach ($roles as $role) {
            $comment->roles()->create([
                'role_id' => $role->id,
            ]);
        }
    }

    public function onCommentDeleting(CommentDeleting $event)
    {
        $comment = $event->comment;
        $comment->roles()->detach();
    }
}

Kami juga perlu mendaftarkan pendengar ini sebagai acara yang sepadan dalam penyedia perkhidmatan:

class AppServiceProvider extends ServiceProvider
{
    protected $listen = [
        UserCreating::class => [
            UserEventListener::class,
        ],

        UserDeleting::class => [
            UserEventListener::class,
        ],

        ArticleCreating::class => [
            ArticleEventListener::class,
        ],

        ArticleDeleting::class => [
            ArticleEventListener::class,
        ],

        CommentCreating::class => [
            CommentEventListener::class,
        ],

        CommentDeleting::class => [
            CommentEventListener::class,
        ],
    ];

    public function boot()
    {
        //
    }
}

Kini, kami telah menyelesaikan semua langkah untuk melaksanakan peruntukan automatik dan kitar semula kebenaran. Selepas ini, apabila kami membuat pengguna, artikel atau ulasan, peranan yang sepadan akan diberikan secara automatik. Apabila rekod ini dipadamkan, kami akan mengalih keluarnya secara automatik daripada peranan yang berkaitan.

Ringkasan:

Dalam artikel ini, kami memperkenalkan cara untuk menetapkan dan mengitar semula kebenaran secara automatik dalam Laravel. Kami menggunakan fungsi perkaitan polimorfik dan pendengar acara untuk mengaitkan pengguna, peranan, siaran dan ulasan bersama-sama dan secara automatik menetapkan dan mengitar semula peranan untuk mereka. Pada masa yang sama, kami juga memberikan anda contoh kod terperinci untuk membantu anda memahami dengan lebih baik kaedah melaksanakan pengurusan kebenaran dalam Laravel.

Atas ialah kandungan terperinci Bagaimana untuk melaksanakan peruntukan automatik dan kitar semula kebenaran dalam Laravel. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!