Cours pour apprendre à utiliser le framework Laravel 5.5

On a déjà vu comment créer un enregistrement avec Eloquent. Comme a priori votre base de données est vide avec une installation fraîche de Laravel on va commencer par ajouter un utilisateur dans la table users à l'aide du modèle User. Pour mémoire ce modèle est le seul présent au départ :

Dans Tinker entrez cette expression :

User::create(['name' => 'Durand', 'email' => 'durand@chezlui.fr', 'password' => 'pass'])

La méthode create renvoie le modèle avec tous les attributs créés comme les dates et l'id. Tinker nous les affiche gentiment. On retrouve évidemment notre enregistrement dans la table users :

Une autre façon de créer un enregistrement avec Eloquent est de commencer par créer un modèle vide, renseigner les attributs, puis utiliser la méthode save pour enregistrer dans la table.

Entrez cette suite d'expressions :

$user = new User
$user->name = 'Dupont'
$user->email = 'dupont@chezlui.fr'
suser->password = 'pass'
$user->save()

On commence par créer le modèle, puis on renseigne ses attributs, enfin on enregistre dans la base avec save.

Entrez cette expression dans Tinker :

User::find(1)->update(['email' => 'durand@cheznous.fr'])

On commence par récupérer le premier enregistrement de la table avec find(1), ce qui a pour effet de créer un modèle avec les attributs renseignés pour Durand. Ensuite on utilise la méthode update sur ce modèle en précisant le nom et la valeur de chaque attribut qu'on veut modifier dans un tableau. Ici on a changé l'adresse email pour Durand.

On peut aussi utiliser la méthode save pour faire une modification. Entrez ces expressions dans Tinker :

$user = User::find(2)
$user->email = 'dupont@cheznous.fr'
$user->save()

Avec find(2) on crée un modèle avec les renseignements de Dupont (le deuxième enregistrement de la table), ensuite on change l'attribut email, enfin on enregistre dans la base.

On peut constater les modifications dans la table :

On a vu déjà la méthode find pour trouver un enregistrement à partir de son identifiant (on peut aussi passer plusieurs identifiants dans un tableau). On peut aussi tous les récupérer avec la méthode all :

Si vous êtes observateur vous avez remarqué que cette fois on n'obtient pas un modèle, comme c'était le cas avec find mais une collection (Illuminate\Database\Eloquent\Collection). Cette classe comporte un nombre considérable de méthodes, on peut donc effectuer de nombreux traitements à ce niveau et même les chaîner.

Par exemple ici j'extrais un modèle au hasard de la collection :

J'aurai l'occasion dans ce cours de montrer l'utilisation de plusieurs des méthodes disponibles.

En général on ne veut pas tous les enregistrements mais juste certains qui correspondent à certains critères. Eloquent est couplé à un puissant générateur de requêtes SQL (Query Builder). On peut par exemple utiliser la méthode where. Entrez cette expression dans Tinker :

User::where('name', 'Dupont')->get()

On récupère une collection qui ne contient que le modèle qui correspond à Dupont.

Ajoutez cet utilisateur :

User::create(['name' => 'Martin', 'email' => 'martin@chezlui.fr', 'password' => 'pass'])

On a maintenant trois utilisateurs :

Maintenant entrez cette expression :

User::where('name', '<', 'e')->get()

Cette fois on a sélectionné à partir des noms dont la première lettre doit être avant « e » dans l'alphabet et on obtient une collection avec deux modèles.

On dispose de la méthode first si on veut récupérer juste le premier :

On peut aussi limiter les colonnes retournées avec la méthode select :

Ici on ne retourne que les noms.

Souvent on a envie de connaître la requête générée, pour la voir il suffit d'utiliser la méthode toSql :

On dispose avec le générateur de requêtes de riches possibilités que nous verrons progressivement, par exemple on peut facilement trier les enregistrements avec la méthode orderBy :

Souvent il existe une syntaxe plus simple, par exemple on peut obtenir le même résultat avec latest :

User::select('name')->latest('name')->get()

La page d'accueil présente un résumé des articles avec une image et un texte d'introduction :

Il faut aller extraire ces informations de la base. D'autre part on a aussi une pagination pour limiter le nombre d'articles visibles sur une page mais je développerai ce point particulier dans un chapitre spécifique parce que c'est un sujet assez long.

Dans le fichier PostRepository vous trouvez ce code :

public function __construct(Post $post, Tag $tag, Comment $comment)
{
    $this->model = $post;
    ...
}


protected function queryActiveOrderByDate()
{
    return $this->model
        ->select('id', 'title', 'slug', 'excerpt', 'image')
        ->whereActive(true)
        ->latest();
}


public function getActiveOrderByDate($nbrPages)
{
    return $this->queryActiveOrderByDate()->paginate($nbrPages);
}

Dans la fonction queryActiveOrderByDate vous avez des choses qu'on a vues ci-dessus :

• select : pour ne sélectionner que les colonnes qui nous intéressent, en effet on ne veut pas toutes les informations des articles pour cette page d'accueil ;
• whereActive : on ne sélectionne que les articles « actifs », c'est la colonne active qui nous l'indique ;
• latest : on trie les articles du plus récent au plus ancien (équivalent à orderBy('created_at', desc)).

Ensuite dans la fonction getActiveOrderByDate on se contente d'appliquer la pagination.

Au niveau du contrôleur PostController le code est classique :

public function index()
{
    $posts = $this->postRepository->getActiveOrderByDate($this->nbrPages);

    return view('front.index', compact('posts'));
}

On retourne la vue front.index (qui donc se trouve en resources/views/front/index.blade.php) en lui transmettant le résultat de la requête, c'est-à-dire un tableau qui contient une collection de tous les enregistrements des articles.

Au niveau de la vue l'instruction @foreach de Blade permet d'itérer dans les collections pour toutes les récupérer :

@foreach($posts as $post)
    @include('front.brick-standard', compact('$post'))
@endforeach

Avec Blade on peut inclure une vue dans une autre vue avec l'instruction @include. C'est ce qui est réalisé ici avec l'inclusion de la vue front.brick-standard (qui donc se trouve en resources/views/front/brick-standard.blade.php) :

<article class="brick entry format-standard animate-this">

    <div class="entry-thumb">
        <a href="{{ url('posts/' . $post->slug) }}" class="thumb-link"><img src="{{ $post->image }}"></a>
    </div>

    <div class="entry-text">
        <div class="entry-header">
            <h1 class="entry-title"><a href="{{ url('posts/' . $post->slug) }}">{{ $post->title }}</a></h1>
        </div>
        <div class="entry-excerpt">
            {{ $post->excerpt }}
        </div>
    </div>

</article>

Pour chaque article ce code est généré et on voit que les propriétés sont récupérées de façon classique, par exemple pour le titre avec $post->title.

L'application utilise le package barryvdh/laravel-debugbar qui permet en particulier de surveiller les requêtes générées :

On aura de nombreuses occasions d'utiliser cette barre et n'hésitez pas à en explorer les possibilités. Elle ne fonctionne que lorsqu'on est en mode DEBUG.

Lorsqu’on se connecte en tant qu'administrateur, et qu'on essaie d’éditer un utilisateur via l'administration des utilisateurs, on a ce formulaire :

Si vous allez dans le fichier UserRepository vous trouvez ce code :

public function update($request, $user)
{
    $inputs = $request->all ();

    if (isset($inputs['confirmed'])) {
        $inputs['confirmed'] = true;
    }

    if (isset($inputs['valid'])) {
        $inputs['valid'] = true;
    }

    $user->update($inputs);

    ...
}

Voici les actions réalisées :

• on récupère toutes les entrées du formulaire $request->all() dans le tableau $inputs, ;
• si la case à cocher « Confirmé » est cochée on ajoute la colonne confirmed avec la valeur true (on sait que si une case n'est pas cochée dans un formulaire aucune information n'est envoyée) ;
• si la case à cocher « Valide » est cochée on ajoute la colonne valid avec la valeur true ;
• on met l'utilisateur à jour dans la table avec la méthode update.

On continuera à explorer cette application dans les prochains chapitres mais n'hésitez pas à fouiller dans le code !