Tutoriel pour apprendre à utiliser le framework Laravel 5.3

Par défaut Laravel considère que cette table existe et il s'en sert comme référence pour l'authentification. On a déjà créé et utilisé cette table dans le chapitre précédent.

Lors des précédents chapitres, je vous ai fait supprimer la migration pour cette table parce qu'on avait juste besoin de la table des utilisateurs. Pour ce chapitre on va avoir besoin de la seconde table qui va nous servir pour la réinitialisation des mots de passe.

Le middleware auth permet de n'autoriser l'accès qu'aux utilisateurs authentifiés. Ce middleware est déjà présent et déclaré dans app\Http\Kernel.php :

protected $routeMiddleware = [
    'auth' => \Illuminate\Auth\Middleware\Authenticate::class,
    ...
];

On voit que la classe se trouve dans le framework et on ne va donc pas pouvoir le modifier directement si on veut changer son fonctionnement.

On peut utiliser ce middleware directement sur une route :

Route::get('comptes', function() {
    // Réservé aux utilisateurs authentifiés
})->middleware('auth');

Ou un groupe de routes :

Route::group(['middleware' => 'auth'], function () {
    Route::get('/', function () {
        // Réservé aux utilisateurs authentifiés
    });
    Route::get('comptes', function () {
        // Réservé aux utilisateurs authentifiés
    });
});

Ou dans le constructeur d'un contrôleur :

public function __construct()
{
    $this->middleware('auth');
}

Dans ce cas on peut désigner les méthodes concernées avec only ou non concernées avec except :

public function __construct()
{
    $this->middleware('auth')->only(['create', 'update']);
}

Ce middleware est exactement l'inverse du précédent : il permet de n'autoriser l'accès qu'aux utilisateurs non authentifiés. Ce middleware est aussi déjà présent et déclaré dans app\Http\Kernel.php :

protected $routeMiddleware = [
    ...
    'guest' => \App\Http\Middleware\RedirectIfAuthenticated::class,
    ...
];

Cette fois la classe se trouve dans l'application :

Pourquoi celui-ci est-il dans l'application ?

Pour comprendre pourquoi c'est le cas, regardez le code :

<?php
 
namespace App\Http\Middleware;
 
use Closure;
use Illuminate\Support\Facades\Auth;
 
class RedirectIfAuthenticated
{
    /**
     * Handle an incoming request.
     *
     * @param  \Illuminate\Http\Request  $request
     * @param  \Closure  $next
     * @param  string|null  $guard
     * @return mixed
     */
    public function handle($request, Closure $next, $guard = null)
    {
        if (Auth::guard($guard)->check()) {
            return redirect('/home');
        }
 
        return $next($request);
    }
}

Si l'utilisateur est authentifié, on fait une redirection vers la route « /home ». Si la classe était dans le framework, on aurait du mal à changer cette URL ! Alors que là c'est accessible et modifiable.

De la même manière que auth, le middleware guest peut s'utiliser sur une route, un groupe de routes ou dans le constructeur d'un contrôleur, avec la même syntaxe.

On va donc chercher cette vue :

Elle a cet aspect :

Cette vue utilise le template resources/views/layouts/app.blade.php. Je ne vais pas entrer dans le détail de tout le code, mais il y a des points intéressants :

Dans le template on trouve ces lignes de code :

@if (Auth::guest())
    <li><a href="{{ URL('/login') }}">Login</a></li>
    <li><a href="{{ URL('/register') }}">Register</a></li>
@else
    <li class="dropdown">
        <a href="#" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-expanded="false">
            {{ Auth::user()->name }} <span class="caret"></span>
        </a>
        ...
    </li>
@endif

On utilise la façade Auth pour vérifier avec la méthode guest qu'on a affaire à un utilisateur non authentifié :

@if (Auth::guest())

En effet dans ce cas on génère les liens pour le login et l'enregistrement. On pourrait tout aussi bien utiliser l'helper auth :

@if (auth()->guest())

On dispose de la méthode auth pour vérifier l'inverse : qu'un utilisateur est authentifié.

On trouve aussi dans le template ce code :

Auth::user()->name

La méthode user permet de disposer d'une instance du modèle pour l'utilisateur authentifié, ici du coup on peut connaître son nom. Ici aussi on pourrait utiliser l'helper :

auth()->user()->name

Comme la vue n'utilise pas le composant laravelcollective/html le jeton (token)pour la protection CSRF est généré avec cet helper :

{{ csrf_field() }}

La validation pour l'enregistrement est présente dans le contrôleur RegisterController :

protected function validator(array $data)
{
    return Validator::make($data, [
        'name' => 'required|max:255',
        'email' => 'required|email|max:255|unique:users',
        'password' => 'required|min:6|confirmed',
    ]);
}

De cette manière elle est facile à modifier si vous devez changer des règles ou ajouter un champ.

On peut vérifier que tout fonctionne :

La création de l'utilisateur se fait dans le contrôleur RegisterController :

protected function create(array $data)
{
    return User::create([
        'name' => $data['name'],
        'email' => $data['email'],
        'password' => bcrypt($data['password']),
    ]);
}

Donc là encore il est facile d'apporter des modifications si nécessaire.

Une fois que l'utilisateur est créé dans la base, il est automatiquement connecté et est redirigé sur « home » :

On va donc chercher cette vue :

Elle a cet aspect :

Cette vue utilise aussi le template resources/views/layouts/app.blade.php. Il n'y a rien de particulier dans cette vue.

La validation pour la connexion est présente dans le trait AuthenticatesUsers :

protected function validateLogin(Request $request)
{
    $this->validate($request, [
        $this->username() => 'required', 'password' => 'required',
    ]);
}

On peut surcharger cette méthode dans le contrôleur pour la modifier. Pour changer seulement le premier élément (username) il y a la méthode dans le trait :

public function username()
{
    return 'email';
}

Par défaut c'est l'email. Pour changer ça, il faut surcharger cette méthode dans le contrôleur.

On peut vérifier que tout fonctionne :

Il est ensuite effectué une vérification de la présence du couple email/password (credentials) dans la base de données :

Dans le formulaire de connexion il y a une case à cocher « se rappeler de moi » (remember me) :

Si on coche cette case, on reste connecté indéfiniment jusqu'à ce qu'on se déconnecte intentionnellement. Pour que ça fonctionne, il faut une colonne remember_token dans la table users :

Il se trouve que cette colonne est prévue dans la migration de base pour la table.

Lorsque l'utilisateur est bien authentifié, il est redirigé par la méthode redirectPath du trait Illuminate\Foundation\Auth\RedirectsUsers :

public function redirectPath()
{
    return property_exists($this, 'redirectTo') ? $this->redirectTo : '/home';
}

Par défaut on redirige sur « home » ou sur la valeur de la propriété redirectTo si elle existe. Donc pour changer la redirection par défaut, il suffit de créer cette propriété avec la valeur voulue.

En fait ce que j'ai écrit ci-dessus est incomplet, il faut préciser quelque chose. On peut arriver sur le formulaire de connexion parce qu'on clique sur le lien correspondant, mais on peut aussi y arriver par l'action du middleware auth. En effet si on veut atteindre une page pour laquelle il faut être authentifié, le middleware auth va nous bloquer et nous rediriger sur le formulaire de connexion. Dans ce cas ce qui serait bien serait, à l'issue de la connexion, d'aller directement sur la page qu'on désirait atteindre au départ.

Sans entrer dans les détails la route désirée est mémorisée dans la session et voici le code pour la redirection :

redirect()->intended($this->redirectPath())

La méthode intended va vérifier si on a mémorisé une route dans la session et l'utiliser si c'est le cas, sinon on utilise la méthode redirectPath qu'on a vue ci-dessus.