Tutoriel pour apprendre à utiliser le framework Laravel 5.3

À partir d'un Laravel vierge, on va commencer par configurer la base comme on l'a vu au chapitre précédent et par installer la migration pour créer la table des migrations dans la base.

Lorsqu'on installe Laravel, on se retrouve avec deux migrations déjà présentes :

Pour le moment on va garder seulement la première qui concerne la création de la table des utilisateurs :

En voici le code :

<?php
 
use Illuminate\Support\Facades\Schema;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Database\Migrations\Migration;
 
class CreateUsersTable extends Migration
{
    /**
     * Run the migrations.
     *
     * @return void
     */
    public function up()
    {
        Schema::create('users', function (Blueprint $table) {
            $table->increments('id');
            $table->string('name');
            $table->string('email')->unique();
            $table->string('password');
            $table->rememberToken();
            $table->timestamps();
        });
    }
 
    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down()
    {
        Schema::drop('users');
    }
}

On a les champs :

• id : entier auto-incrémenté qui sera la clé primaire de la table ;
• name : texte pour le nom ;
• email : texte pour l'email (unique) ;
• password : texte pour le mot de passe (en fait une version cryptée du mot de passe) ;
• remember_token : généré par la méthode rememberToken qui sert pour l'authentification que nous verrons dans un chapitre ultérieur ;
• created_at et updated_at créés par la méthode timestamps.

Ensuite on lance la migration :

On doit se retrouver avec la table users créée :

Remarquez que le modèle User est déjà présent dans le dossier app quand vous installez Laravel parce qu'il est un peu particulier comme nous le verrons lorsque nous parlerons de l'authentification. Pour le moment nous allons nous satisfaire du fait qu'il existe déjà sans nous soucier de son contenu.

On va maintenant créer une ressource avec Artisan :

<samp>php artisan make:controller UserController --resource</samp>

C'est la commande qu'on a déjà vue pour créer un contrôleur avec en plus l'option -resource.

Vous trouvez comme résultat le contrôleur app/Http/Controllers/UserController :

<?php
 
namespace App\Http\Controllers;
 
use Illuminate\Http\Request;
 
use App\Http\Requests;
 
class UserController extends Controller
{
    /**
     * Display a listing of the resource.
     *
     * @return \Illuminate\Http\Response
     */
    public function index()
    {
        //
    }
 
    /**
     * Show the form for creating a new resource.
     *
     * @return \Illuminate\Http\Response
     */
    public function create()
    {
        //
    }
 
    /**
     * Store a newly created resource in storage.
     *
     * @param  \Illuminate\Http\Request  $request
     * @return \Illuminate\Http\Response
     */
    public function store(Request $request)
    {
        //
    }
 
    /**
     * Display the specified resource.
     *
     * @param  int  $id
     * @return \Illuminate\Http\Response
     */
    public function show($id)
    {
        //
    }
 
    /**
     * Show the form for editing the specified resource.
     *
     * @param  int  $id
     * @return \Illuminate\Http\Response
     */
    public function edit($id)
    {
        //
    }
 
    /**
     * Update the specified resource in storage.
     *
     * @param  \Illuminate\Http\Request  $request
     * @param  int  $id
     * @return \Illuminate\Http\Response
     */
    public function update(Request $request, $id)
    {
        //
    }
 
    /**
     * Remove the specified resource from storage.
     *
     * @param  int  $id
     * @return \Illuminate\Http\Response
     */
    public function destroy($id)
    {
        //
    }
}

Les sept méthodes créées couvrent la gestion complète des utilisateurs :

• index : pour afficher la liste des utilisateurs ;
• create : pour envoyer le formulaire pour la création d'un nouvel utilisateur ;
• store : pour créer un nouvel utilisateur ;
• show : pour afficher les données d'un utilisateur ;
• edit : pour envoyer le formulaire pour la modification d'un utilisateur ;
• update : pour modifier les données d'un utilisateur ;
• destroy : pour supprimer un utilisateur.

Il me faut toutefois préciser déjà un point important. Dans la version du contrôleur générée par défaut, on voit que l'utilisateur au niveau des arguments des fonctions est référencé par son identifiant, par exemple :

public function show($id)

La variable id contient la valeur passée dans l'URL. Par exemple …/user/8 indique qu'on veut voir les informations de l'utilisateur d'identifiant 8. Il suffit donc ensuite d'aller chercher dans la base l'utilisateur correspondant.

Si vous regardez la signature dans le contrôleur définitif, vous avez ceci :

public function show(User $user)

L'argument cette fois est une instance du modèle App\User. Étant donné qu'il rencontre ce type Laravel va automatiquement livrer une instance du modèle pour l'utilisateur concerné ! C'est ce qu'on appelle liaison implicite (Implicit Bindind). Vous voyez encore là à quel point Laravel nous simplifie la vie.

On va créer une requête de formulaire pour la création d'un utilisateur. Je ne vous réitère pas la démarche de création avec Artisan parce que nous l'avons déjà vue plusieurs fois. Voici le code de la classe :

<?php
 
namespace App\Http\Requests;
 
use Illuminate\Foundation\Http\FormRequest;
 
class UserCreateRequest extends FormRequest
{
    /**
     * Determine if the user is authorized to make this request.
     *
     * @return bool
     */
    public function authorize()
    {
        return true;
    }
 
    /**
     * Get the validation rules that apply to the request.
     *
     * @return array
     */
    public function rules()
    {
        return [
            'name' => 'bail|required|max:255',
            'email' => 'bail|required|email|max:255|unique:users',
            'password' => 'bail|required|confirmed|min:8'
        ];
    }
}

Avec ces règles :

• bail : on s'arrête à la première erreur ;
• name : requis, longueur maximale de 255 caractères ;
• email : requis, adresse valide, longueur maximale de 255 caractères, et unique dans la table users ;
• password : requis, longueur minimale de 8 caractères et doit correspondre à ce qui est entré dans le champ de confirmation du mot de passe (confirmed).

Pour la modification d'un utilisateur, nous allons avoir un petit souci. En effet on veut conserver l'unicité de l'email dans la base, il est donc judicieux de prévoir une règle « unique ». Mais comme la valeur de l'email existant est déjà dans la base, on va avoir un échec de la validation en cas de non-modification de cette valeur, ce qui est probable.

Comment nous en sortir ?

Étant donné que nous disposons d'une fonction, on peut effectuer tous les traitements que l'on veut. Voici alors la requête de formulaire pour la modification d'un utilisateur :

<?php
 
namespace App\Http\Requests;
 
use Illuminate\Foundation\Http\FormRequest;
 
class UserUpdateRequest extends FormRequest
{
    /**
     * Determine if the user is authorized to make this request.
     *
     * @return bool
     */
    public function authorize()
    {
        return true;
    }
 
    /**
     * Get the validation rules that apply to the request.
     *
     * @return array
     */
    public function rules()
    {
        return [
            'name' => 'bail|required|max:255',
            'email' => 'bail|required|email|max:255|unique:users,email,' . $this->user->id,
        ];
    }
}

On récupère l'instance du modèle pour l'utilisateur dans l'URL (on sait qu'il y a une liaison implicite). Ensuite on utilise une possibilité d'exclusion de la règle « unique ».

Vous devez donc avoir ces deux fichiers pour la validation :

Dans le prochain chapitre nous poursuivrons l'étude de cette ressource avec la gestion des données et les vues.‌