**Course Title:** Mastering Laravel Framework: Building Scalable Modern Web Applications **Section Title:** Authentication and Authorization **Topic:** Build a user authentication system with login, registration, and role-based access control.(Lab topic) **Introduction:** In this lab topic, we will build a comprehensive user authentication system using Laravel's built-in authentication system. We will cover user registration, login, and role-based access control. By the end of this topic, you will have a solid understanding of how to implement a robust authentication system in your Laravel application. **Prerequisites:** * You should have a good understanding of Laravel's directory structure, routing, controllers, and views. * You should have a good grasp of Laravel's Eloquent ORM and database interactions. * You should have a basic understanding of Laravel's authentication system, including user registration, login, and password resets. **Step 1: Setting up the Authentication System** To start, we need to set up the authentication system in our Laravel application. We will use the default Laravel authentication system, which includes the following features: * User registration * Login * Password resets * Email verification Run the following command in your terminal to set up the authentication system: ```bash composer require laravel/ui ``` This command will install the `laravel/ui` package, which includes the default Laravel authentication system. Next, run the following command to install the authentication system: ```bash php artisan ui:auth ``` This command will install the authentication system and generate the necessary routes, controllers, and views. **Step 2: Creating the Role Model and Migration** To implement role-based access control, we need to create a `Role` model and migration. Run the following command to create the `Role` model and migration: ```bash php artisan make:model Role -m ``` This command will create a `Role` model in the `app/Models` directory and a `roles` migration in the `database/migrations` directory. Open the `Role` model and add the following code: ```php // app/Models/Role.php namespace App\Models; use Illuminate\Database\Eloquent\Factories\HasFactory; use Illuminate\Database\Eloquent\Model; class Role extends Model { use HasFactory; protected $fillable = ['name', 'description']; public function users() { return $this->belongsToMany(User::class); } } ``` Next, open the `roles` migration and add the following code: ```php // database/migrations/XXXX_XX_XX_XXXXXX_create_roles_table.php use Illuminate\Database\Migrations\Migration; use Illuminate\Database\Schema\Blueprint; use Illuminate\Support\Facades\Schema; class CreateRolesTable extends Migration { public function up() { Schema::create('roles', function (Blueprint $table) { $table->id(); $table->string('name'); $table->string('description'); $table->timestamps(); }); } public function down() { Schema::dropIfExists('roles'); } } ``` Run the following command to migrate the `roles` table: ```bash php artisan migrate ``` **Step 3: Creating the User-Role Pivot Table** To establish the many-to-many relationship between users and roles, we need to create a pivot table. Run the following command to create the pivot table migration: ```bash php artisan make:migration create_user_role_table ``` Open the `create_user_role_table` migration and add the following code: ```php // database/migrations/XXXX_XX_XX_XXXXXX_create_user_role_table.php use Illuminate\Database\Migrations\Migration; use Illuminate\Database\Schema\Blueprint; use Illuminate\Support\Facades\Schema; class CreateUserRoleTable extends Migration { public function up() { Schema::create('user_role', function (Blueprint $table) { $table->foreignId('user_id'); $table->foreignId('role_id'); $table->timestamps(); $table->foreign('user_id')->references('id')->on('users'); $table->foreign('role_id')->references('id')->on('roles'); }); } public function down() { Schema::dropIfExists('user_role'); } } ``` Run the following command to migrate the `user_role` table: ```bash php artisan migrate ``` **Step 4: Implementing Role-Based Access Control** To implement role-based access control, we need to update the `User` model to include the `roles` relationship. Open the `User` model and add the following code: ```php // app/Models/User.php use Illuminate\Contracts\Auth\MustVerifyEmail; use Illuminate\Database\Eloquent\Factories\HasFactory; use Illuminate\Database\Eloquent\Model; use Illuminate\Foundation\Auth\User as Authenticatable; use Illuminate\Notifications\Notifiable; class User extends Authenticatable { use HasFactory, Notifiable; protected $fillable = [ 'name', 'email', 'password', ]; protected $hidden = [ 'password', 'remember_token', ]; protected $casts = [ 'email_verified_at' => 'datetime', ]; public function roles() { return $this->belongsToMany(Role::class); } } ``` Next, we need to update the `login` and `registration` controllers to include role assignment. Open the `AuthenticatedSessionController` and add the following code: ```php // app/Http/Controllers/Auth/AuthenticatedSessionController.php namespace App\Http\Controllers\Auth; use App\Models\Role; use Illuminate\Http\Request; use Illuminate\Support\Facades\Auth; class AuthenticatedSessionController extends Controller { public function login(Request $request) { // ... if (Auth::attempt($credentials)) { // ... $user = Auth::user(); $user->assignRole('user'); return redirect()->intended(RouteServiceProvider::HOME); } // ... } } ``` Open the `RegisteredUserController` and add the following code: ```php // app/Http/Controllers/Auth/RegisteredUserController.php namespace App\Http\Controllers\Auth; use App\Models\Role; use Illuminate\Auth\Events\Registered; use Illuminate\Http\Request; use Illuminate\Support\Facades\Auth; class RegisteredUserController extends Controller { public function store(Request $request) { $request->validate([ // ... ]); $user = User::create($request->only(['name', 'email', 'password'])); event(new Registered($user)); $user->assignRole('user'); return redirect('/')->with('success', 'Registered successfully'); } } ``` **Conclusion:** In this lab topic, we built a comprehensive user authentication system with login, registration, and role-based access control using Laravel's built-in authentication system. We created a `Role` model and migration, established the many-to-many relationship between users and roles, and implemented role-based access control using middleware and controllers. **Practical Takeaway:** In your own Laravel application, you can use the code provided in this lab topic as a starting point to build your own user authentication system with role-based access control. **Additional Resources:** * [Laravel Documentation - Authentication](https://laravel.com/docs/9.x/authentication) * [Laravel Documentation - Authorization](https://laravel.com/docs/9.x/authorization) * [Laravel Documentation - Roles and Permissions](https://laravel.com/docs/9.x/sanctum#roles-and-permissions) **Leave a comment below if you have any questions or need help with implementing user authentication with role-based access control in your own Laravel application.