Comment configurer l'authentification multiple dans Laravel 5.6

Dans cet article, nous aborderons l'authentification multiple dans Laravel 5.6. L'authentification multiple n'est ici que le processus d'authentification par rapport à plusieurs modèles d'utilisateurs.

Dans les sections suivantes, nous démontrerons la fonctionnalité d'authentification intégrée de Laravel. Plus précisément, je vais vous montrer comment authentifier à la fois un utilisateur administrateur et un utilisateur régulier.

Étape 1 : Configuration de Laravel

Configurer un projet Laravel à l'aide de Composer.

composer create-project --prefer-dist laravel/laravel project-name

Étape 2 : Configuration de la base de données

Ouvrez le fichier .env et définissez les informations d'identification de la base de données dans le fichier.

DB_DATABASE= database-name
DB_USERNAME= root
DB_PASSWORD= database-password

Étape 3 : Authentification

Pour vous inscrire et vous connecter à l'aide du système d'authentification intégré de Laravel, exécutez simplement la commande suivante :

php artisan make:auth

Étape 4 : Configurer les modèles et les migrations

Pour créer et configurer des modèles et des migrations pour l'administrateur :

php artisan make:model Admin -m

Pour configurer des modèles pour l'administrateur, veuillez allez dans app/Admin.php et mettez à jour le code avec le code suivant :

/**
 * Remove 'use Illuminate\Database\Eloquent\Model;'
 */
use Illuminate\Notifications\Notifiable;
use Illuminate\Foundation\Auth\User as Authenticatable;
class Admin extends Authenticatable
{
    use Notifiable;
// The authentication guard for admin
    protected $guard = 'admin';
     /**
      * The attributes that are mass assignable.
      *
      * @var array
      */
    protected $fillable = [
        'email', 'password',
    ];
     /**
      * The attributes that should be hidden for arrays.
      *
      * @var array
      */
    protected $hidden = [
        'password', 'remember_token',
    ];

Pour configurer la table de migration pour l'administrateur, allez dans database/migration/***_create_admins_table.php et utilisez ce qui suit code Code mis à jour :

//
{
    Schema::create('admins', function (Blueprint $table) {
            $table->increments('id');
            $table->string('email')->unique();
            $table->string('password');
            $table->rememberToken();
            $table->timestamps();
    });
 }
//

Étape 5 : Configurer le contrôleur d'administration

Pour créer un contrôleur pour l'administrateur, exécutez la commande suivante :

php artisan make:controller AdminController

Pour configurer le contrôleur, accédez à app/Http/Controllers/AdminController.php et mettez à jour le code avec le code suivant :

class AdminController extends Controller{    /**
     * Create a new controller instance.
     *
     * @return void
     */
    public function __construct()
    {        $this->middleware('auth:admin');
    }
    /**
     * Show the application dashboard.
     *
     * @return \Illuminate\Http\Response
     */
    public function index()
    {        return view('admin');
    }}

Étape 6 : Configurer la connexion pour l'administrateur Contrôleurs utilisateur

Pour créer un contrôleur de connexion, exécutez la commande suivante :

php artisan make:controller Auth/AdminLoginController

Pour configurer un contrôleur de connexion, accédez à app/Http/Controllers/Auth/AdminLoginController. php et mettez à jour le code avec le code suivant :

use Illuminate\Http\Request;use App\Http\Controllers\Controller;use Illuminate\Foundation\Auth\AuthenticatesUsers;use Illuminate\Support\Facades\Auth;class AdminLoginController extends Controller{    /**
     * Show the application’s login form.
     *
     * @return \Illuminate\Http\Response
     */
    public function showLoginForm()
    {        return view(’auth.admin-login’);
    }
    protected function guard(){        return Auth::guard('admin');
    }
    
    use AuthenticatesUsers;    /**
     * Where to redirect users after login.
     *
     * @var string
     */
    protected $redirectTo = '/admin/dashboard';    /**
     * Create a new controller instance.
     *
     * @return void
     */
    public function __construct()
    {        $this->middleware('guest:admin')->except('logout');
    }}

Étape 7 : Configurer le contrôleur de connexion pour les utilisateurs normaux

Pour configurer le contrôleur de connexion pour les utilisateurs normaux, veuillez accéder à app/Http/Controllers/Auth/LoginController.php et mettre à jour le code avec le code suivant :

///**
 * Show the application's login form.
 *
 * @return \Illuminate\Http\Response
 */public function showLoginForm(){    return view('auth.login');}//

Étape 8 : Définir la vue de connexion pour l'administrateur

Pour créer et configurer une vue de connexion pour l'administrateur, accédez à resources/views/auth/ et créez un nouveau fichier admin-login.blade.php. Copiez le code depuis resources/views/auth/login.blade.php et collez-le dans un nouveau fichier.

Maintenant, mettez à jour le nouveau fichier avec le contenu suivant :

// 
<div class="card-header">{{ __(&#39;Admin Login&#39;) }}</div>
<div class="card-body">
  <form method="POST" action="{{ route(&#39;admin.login.submit&#39;) }}">
//

Étape 9 : Configurez la vue principale pour l'administrateur

Pour créer et Pour configurer la vue d'accueil, accédez à resources/views/ et créez un nouveau fichier admin-home.blade.php. Copiez le code dans resources/views/home.blade.php et collez-le dans un nouveau fichier.

Mettez maintenant à jour le nouveau fichier avec le contenu suivant :

// 
<div class="card">
   <div class="card-header">Admin Dashboard</div>
//

Étape 10 : Configurez le routage de l'application Web

à acheminer pour votre application Pour configurer une route Web, accédez à routes/web.php et mettez à jour le code avec le code suivant :

//
Route::get('/', function () {
    return view('layouts.app');
});
Route::prefix('admin')->group(function() {
    Route::get('/login', 'Auth\AdminLoginController@showLoginForm')->name('admin.login');
    Route::post('/login', 'Auth\AdminLoginController@login')->name('admin.login.submit');
    Route::get('/home', 'AdminController@index')->name('admin.home');
});
//

Étape 11 : Configurez le gestionnaire d'exceptions

Pour définir le gestionnaire d'exceptions, veuillez accéder à app/Exceptions/Hanler.php et mettre à jour le code avec le code suivant :

//
use Illuminate\Auth\AuthenticationException;
//
//
protected $dontReport = [
     \Illuminate\Auth\AuthenticationException::class,
     \Illuminate\Auth\Access\AuthorizationException::class,
     \Symfony\Component\HttpKernel\Exception\HttpException::class,
     \Illuminate\Database\Eloquent\ModelNotFoundException::class,
     \Illuminate\Session\TokenMismatchException::class,
     \Illuminate\Validation\ValidationException::class,
];
//
//
public function render($request, Exception $exception)
{
    return parent::render($request, $exception);
}
    /**
     * Convert an authentication exception into an unauthenticated response.
     *
     * @param  \Illuminate\Http\Request  $request
     * @param  \Illuminate\Auth\AuthenticationException  $exception
     * @return \Illuminate\Http\Response
     */
 protected function unauthenticated($request, AuthenticationException $exception)
 {
    if ($request->expectsJson()) {
     return response()->json(['error' => 'Unauthenticated.'],401);
    }
     $guard = array_get($exception->guards(), 0);
      switch ($guard) {
        case 'admin': $login = 'admin.login';
        break;
        default: $login = 'login';
        break;
      }
        return redirect()->guest(route($login));
  }

Étape 12 : Configurer le middleware de redirection

Pour configurer le middleware de redirection après authentification, rendez-vous sur app/Http/Middleware/RedirectIfAuthenticated.php et mettez à jour le code avec le code suivant :

//
public function handle($request, Closure $next, $guard = null)
{
        switch ($guard) {
            case 'admin' :
                if (Auth::guard($guard)->check()) {
                    return redirect()->route('admin.home');
                }
                break;
            default:
                if (Auth::guard($guard)->check()) {
                    return redirect()->route('home');
                }
                break;
        }
     return $next($request);
}
//

Étape 13 : Configurer la configuration de l'authentification

Pour configurer la configuration de l'authentification, rendez-vous sur config/auth.php et mettez à jour le code avec le code suivant :

//
'defaults' => [
        'guard' => 'web',
        'passwords' => 'users',
    ],
'admins' => [
        'driver' => 'eloquent',
        'model' => App\Admin::class,
    ],
//
//
'guards' => [
        'web' => [
            'driver' => 'session',
            'provider' => 'users',
        ],
        'api' => [
            'driver' => 'token',
            'provider' => 'users',
        ],
        'admin' => [
            'driver' => 'session',
            'provider' => 'admins',
        ],
        'admin-api' => [
            'driver' => 'token',
            'provider' => 'admins',
        ],
    ],
//
//
'providers' => [
        'users' => [
            'driver' => 'eloquent',
            'model' => App\User::class,
        ],
       'admins' => [
            'driver' => 'eloquent',
            'model' => App\Admin::class,
        ],
    ],
//
//
'passwords' => [
        'users' => [
            'provider' => 'users',
            'table' => 'password_resets',
            'expire' => 60,
        ],
        'admins' => [
            'provider' => 'admins',
            'table' => 'password_resets',
            'expire' => 15,
        ],
    ],

Étape 14 : Configurer la longueur de chaîne par défaut pour la migration de base de données

Pour définir la longueur de chaîne par défaut pour les migrations de bases de données, accédez à app/Providers/AppServiceProvider.php et mettez à jour votre code avec :

use Illuminate\Support\ServiceProvider;
use Illuminate\Support\Facades\Schema;

//

public function boot(){
    Schema::defaultStringLength(191);
}

Étape 15 : Exécuter la migration

Pour exécuter la migration, entrez la commande suivante :

php artisan migrate

Entrez les identifiants de connexion de l'administrateur à l'aide du patcher :

php artisan tinker

$admin = new App\Admin
$admin->email = 'admin@app.com'
$admin->password = Hash::make(’admin-password’)
$admin->save()

J'espère que vous pourrez désormais facilement configurer plusieurs authentifications dans votre projet Laravel.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!