Dans ce tutoriel, vous allez apprendre à mettre en place un système d’authentification basée sur les rôles dans Laravel.
Lire aussi: Comment installer Font Awesome dans Laravel
Si vous travaillez sur une application Web dans laquelle vous devez gérer différents types d’utilisateurs et les rediriger vers leur page sécurisée, nous aborderons cela dans ce tutoriel.
Nous couvrirons les scénarios suivants dans notre application:
- Notre application se compose d’une partie front-end et d’une partie back-end
- Front-end pour les utilisateurs de notre site et back-end pour nos administrateurs
- Nous avons une page de connexion commune où les deux utilisateurs se connectent
- En utilisant leur rôle, nous les redirigerons vers le front-end ou le back-end
Mise en place d’authentification basée sur les rôles dans Laravel
Avant de pouvoir mettre en place un système d’authentification basée sur les rôles dans Laravel, tout d’abord, nous devons créer une table utilisateur et un modèle utilisateur. Pour créer dynamiquement une table utilisateur, nous devons d’abord créer un fichier de migration.
Créer une table utilisateur
Exécutez la commande suivante dans la fenêtre de votre terminal tout en étant sur notre dossier de projet racine:
php artisan make:migration user_table
La commande ci-dessus générera un fichier de migration dans le dossier database/migrations, ouvrez maintenant ce fichier nouvellement créé et le modifiez avec le contenu suivant:
<?php
use Illuminate\Support\Facades\Schema;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Database\Migrations\Migration;
class UsersTable extends Migration
{
/**
* Run the migrations.
*
* @return void
*/
public function up()
{
Schema::create('users', function (Blueprint $table) {
$table->increments('id');
$table->string('password');
$table->string('name')->index();
$table->string('email')->unique()->index();
$table->enum('role', ['user','admin'])->default('user');
$table->rememberToken();
$table->timestamps();
});
}
/**
* Reverse the migrations.
*
* @return void
*/
public function down()
{
Schema::dropIfExists('users');
}
}
Une fois que nous avons terminé avec les modifications ci-dessus, nous devons exécuter cette migration qui créerait une nouvelle table utilisateur dans notre base de données.
Lire aussi: Comment gérer une base de données PostgreSQL à partir de la ligne de commande
Assurez-vous que votre fichier .env est défini avec les informations d’identification de base de données correctes.
Maintenant, ouvrez votre terminal et exécutez la commande suivante pour créer une table utilisateur:
php artisan migrate
Une fois la table utilisateur migrée correctement, nous devons modifier notre modèle utilisateur. Ouvrez le fichier app/User.php et ajoutez le code suivant à notre modèle:
namespace App;
use Illuminate\Auth\Authenticatable;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Auth\Passwords\CanResetPassword;
use Illuminate\Contracts\Auth\Authenticatable as AuthenticatableContract;
use Illuminate\Contracts\Auth\CanResetPassword as CanResetPasswordContract;
class User extends Model implements AuthenticatableContract, CanResetPasswordContract
{
use Authenticatable, CanResetPassword;
protected $table = 'users';
protected $fillable = ['name', 'email', 'password', 'role'];
protected $hidden = ['password', 'remember_token'];
public function isAdmin() {
return $this->role === 'admin';
}
public function isUser() {
return $this->role === 'user';
}
}
Comprendre les requêtes Laravel
Afin d’accomplir notre tâche qui est la mise place d’un système d’authentification basée sur les rôles dans Laravel, nous devons avant tout comprendre comment laravel traite une requête Web:
- L’utilisateur accède à un site Web en utilisant l’URL
- Laravel trouve l’URL liée à une fonction de contrôleur en utilisant des routes
- Puis la demande passe par les middlewares si définis
- Puis la demande va au contrôleur et traite la vue
Ainsi, avant qu’une requête ne parvienne réellement à un contrôleur, elle passe par un middleware.
Qu’est-ce qu’un middleware Laravel?
Un middleware est une couche entre une demande utilisateur (requête) et un contrôleur. Fondamentalement, vous pouvez effectuer des logiques supplémentaires ici avant que notre demande n’atteigne un contrôleur.
Par exemple, si vous souhaitez que certains utilisateurs voient certaines pages, vous pouvez ajouter cette logique au middleware. C’est exactement ce dont nous avons besoin pour l’authentification basée sur les rôles dans une application Laravel.
Nous voulons nous assurer que l’utilisateur accède au front-end tandis que les administrateurs doivent accéder aux pages d’administration. Nous voulons empêcher les utilisateurs d’accéder aux pages d’administration.
Nous pouvons donc essentiellement créer deux middlewares ici, un pour l’utilisateur et un pour les administrateurs. Dans le middleware utilisateur, nous voulons nous assurer que les administrateurs ne peuvent pas accéder aux pages utilisateur et pour le middleware administrateur, nous voulons nous assurer que les utilisateurs n’y accèdent pas.
Ouvrez à nouveau la fenêtre de votre terminal en étant dans le répertoire racine du projet laravel et exécutez les commandes suivantes:
php artisan make:middleware UserAuthenticated php artisan make:middleware AdminAuthenticated
Cela générera deux middlewares, un pour l’utilisateur et un pour l’administrateur dans le dossier app/Http/Middleware.
Ouvrons le middleware d’administration et apportons les modifications suivantes:
namespace App\Http\Middleware;
use Auth;
use Closure;
class AdminAuthenticated
{
public function handle($request, Closure $next)
{
if( Auth::check() )
{
// if user is not admin take him to his dashboard
if ( Auth::user()->isUser() ) {
return redirect(route('user_dashboard'));
}
// allow admin to proceed with request
else if ( Auth::user()->isAdmin() ) {
return $next($request);
}
}
abort(404); // for other user throw 404 error
}
}
Fondamentalement, nous vérifions si l’utilisateur est connecté si c’est le cas, nous vérifions si l’utilisateur n’est pas un administrateur, puis le redirigeons vers son tableau de bord utilisateur ou traitons la demande.
De cette façon, même si l’utilisateur est connecté et essaie d’accéder aux pages d’administration, il sera redirigé vers son tableau de bord et ne pourra pas accéder aux pages d’administration.
Ajoutons une logique similaire à notre middleware utilisateur afin que les administrateurs ne puissent pas accéder aux pages utilisateur et être redirigés vers leur tableau de bord d’administration s’ils sont connectés.
namespace App\Http\Middleware;
use Auth;
use Closure;
class UserAuthenticated
{
public function handle($request, Closure $next)
{
if( Auth::check() )
{
// if user admin take him to his dashboard
if ( Auth::user()->isAdmin() ) {
return redirect(route('admin_dashboard'));
}
// allow user to proceed with request
else if ( Auth::user()->isUser() ) {
return $next($request);
}
}
abort(404); // for other user throw 404 error
}
}
Activez nos middlewares
Ensuite, après avoir créé nos middlewares, nous devons les activer. Par défaut, laravel n’est pas au courant de l’existence de nos nouveaux middlewares, alors activons-les.
Ouvrez le fichier app/Http/Kernel.php et ajoutez les deux lignes suivantes:
namespace App\Http;
use Illuminate\Foundation\Http\Kernel as HttpKernel;
class Kernel extends HttpKernel
{
// some other functions
protected $routeMiddleware = [
// some other middlewares
'admin' => \App\Http\Middleware\AdminAuthenticated::class,
'user' => \App\Http\Middleware\UserAuthenticated::class
];
}
Ajout de middleware aux routes
Maintenant que nos middlewares sont actifs, ils ne fonctionneront pas automatiquement. Chaque fois que nous créons de nouvelles routes pour l’utilisateur et l’administrateur, nous devons dire à laravel quelles routes doivent aller vers quel middleware.
Par exemple, toutes les routes utilisateur doivent utiliser le middleware utilisateur et toutes les routes admin doivent le middleware administrateur utilisateur avec le middleware Web.
Ouvrons le fichier routes/web.php et ajoutons ce middleware aux routes appropriées.
// user protected routes
Route::group(['middleware' => ['auth', 'user'], 'prefix' => 'user'], function () {
Route::get('/', 'HomeController@index')->name('user_dashboard');
});
// admin protected routes
Route::group(['middleware' => ['auth', 'admin'], 'prefix' => 'admin'], function () {
Route::get('/', 'HomeController@index')->name('admin_dashboard');
});
Beaucoup de changements sont corrects, mais nous voulons rendre notre application sécurisée de toute façon. Le dernier changement que nous devons apporter est dans LoginController.
Maintenant que nous avons des middlewares et que nous les avons activés, c’est cool, mais lorsque nous nous connectons, notre application ne sait pas où rediriger notre utilisateur?
Dans le contrôleur de connexion, nous devons rediriger les utilisateurs en fonction de leurs rôles vers leurs pages. Ouvrons LoginController et apportons les modifications suivantes.
namespace App\Http\Controllers\Auth;
use Illuminate\Http\Request;
use App\Http\Controllers\Controller;
use Illuminate\Foundation\Auth\AuthenticatesUsers;
class LoginController extends Controller
{
/*
|--------------------------------------------------------------------------
| Login Controller
|--------------------------------------------------------------------------
|
| This controller handles authenticating users for the application and
| redirecting them to your home screen. The controller uses a trait
| to conveniently provide its functionality to your applications.
|
*/
use AuthenticatesUsers;
// some other functions go here
protected function authenticated(Request $request, $user)
{
// to admin dashboard
if($user->isAdmin()) {
return redirect(route('admin_dashboard'));
}
// to user dashboard
else if($user->isUser()) {
return redirect(route('user_dashboard'));
}
abort(404);
}
}
C’est ça. Nous avons réussi à sécuriser notre application en fonction des rôles des utilisateurs. Notre application suivrait la structure ci-dessous:
- L’utilisateur se connecte à notre application
- LoginController redirigera l’utilisateur en fonction de son rôle vers le tableau de bord utilisateur ou administrateur
- Notre middleware protégera les frontières des utilisateurs
- Il ne permettra pas à l’administrateur de voir les pages utilisateur et empêchera les utilisateurs de voir les pages d’administration.
Conclusion
Vous avez appris à mettre en place un système d’authentification basée sur les rôles dans Laravel.
J’espère que vous avez apprécié ce tutoriel si vous avez des questions, n’hésitez pas à me les poser et à m’aider à prendre conscience de choses que je ne sais pas.
1 Comment