LARAVEL

D'un point de vue scientifique, la taxonomie (taxonomy en anglais) est l'activité qui permet de regrouper les organismes biologiques présentant des caractéristiques communes (on détermine ainsi des espèces) dans des catégories dénommées taxons. Vous vous doutez bien que je ne vais pas traiter ce sujet sur mon blog ! Je n'en ai d'ailleurs pas la compétence. Toutefois, ce terme a également été choisi dans d'autres secteurs, notamment l'informatique. Il s'agit ainsi de classification, mais d'informations, dans un modèle architectural structuré et évolutif.

Les informations sont classées en fonction de leurs caractéristiques, de leurs attributs et de leurs relations. On y trouve des niveaux hiérarchiques en fonction de l'importance des informations. Cette situation se présente souvent lors du développement de sites. L'exemple le plus classique est celui de catégories qui se subdivisent ensuite en sous-catégories, et ainsi de suite. Par exemple, on a une catégorie « informatique » qui se subdivise en sous-catégories comme « smartphones », « PC » ou « imprimantes ». La question de la façon de stocker ces informations pour pouvoir les gérer de façon efficace (recherche, gestion et analyse) se pose alors.

Un package

Il est toujours possible de réinventer la roue, mais il est beaucoup plus facile d'aller en acheter une toute prête. Pour gérer les données classées et hiérarchisées, on peut procéder de multiples manières. Dans les cas simples, on se contente de tables liées par des relations, et le problème est réglé. Mais cela devient plus complexe lorsque l'on a affaire à des données diversifiées et à un nombre de niveaux hiérarchiques variable. C'est là que l'utilisation d'un package qui facilite la vie devient pertinent.

Depuis que je code, j'ai utilisé un certain nombre de ces packages fondés sur des concepts variés, mais récemment, il y en a un qui a retenu mon attention à la suite de la lecture de cet article. Il est assez récent et mérite le détour, il s'agit de Laravel Taxonomy. Il offre de nombreuses fonctionnalités intéressantes :

• gestion des taxonomies : catégories, tags, couleurs, tailles, etc
• hiérarchie avancée : prise en charge des structures imbriquées (nested set) pour des requêtes optimisées sur les données hiérarchiques
• types personnalisables : utilisation de types prédéfinis (catégorie, tag, etc.) ou création de types personnalisés (genre, saison, difficulté, etc.)
• API expressive : façade Taxonomy pour créer, rechercher et manipuler les taxonomies simplement
• possibilité d'attacher des taxonomies à n'importe quel modèle Eloquent (produits, articles, etc.)

Il convient donc à un grand nombre de situations :

• e-commerce : gestion des catégories et sous-catégories de produits, des tags et des attributs (couleur, taille)
• blog : organisation des articles par catégories, tags ou types personnalisés
• gestion de contenu : classification de médias, de documents ou de ressources

Principes de base

Comme toujours, il est important de comprendre les principes de base pour bien utiliser l'outil. je vais prendre comme exemple la gestion d'annonces.

Termes

Le terme est la brique de base. Il s'agit du mot ou de la phrase que vous utilisez pour classer quelque chose. Dans votre base de données, il s'agit de l'enregistrement qui porte le nom de l'élément et sa position dans la hiérarchie.

    Voici quelques exemples concrets (vos données) :

• Immobilier
• Voiture
• Vente
• T3
• Urgent

Un terme possède des propriétés telles qu'un nom, un slug et surtout un parent_id, ce qui lui permet de s'organiser en arborescence (liste d'adjacence).

Vocabulaire

Le vocabulaire est le conteneur logique qui définit le type de classification d'un ensemble de termes. Il permet de regrouper les termes qui ont la même fonction ou le même objectif.

Voici quelques exemples concrets :

• vocabulaire « Catégories » : regroupe les termes « Immobilier », « Véhicules » et « Emploi »
• vocabulaire « Tags » : regroupe les termes « Urgent », « Négociable », « Neuf »
• vocabulaire « État » : regroupe les termes « Très bon état », « Bon état » et « Pour pièces ».

Vous pouvez ainsi créer une catégorie principale « Véhicules » et un tag « Urgent », qui sont tous deux des termes stockés dans la même table, mais qui sont distingués et gérés séparément par leur vocabulaire respectif.

Entité ou modèle taxonomiable

Il s'agit de votre modèle principal, celui qui utilise la classification. Par exemple un modèle Ad (Annonce).

Pour que votre modèle Ad puisse utiliser le système de taxonomie, vous devez lui ajouter un trait fourni par le package.

use Aliziodev\LaravelTaxonomy\Traits\HasTaxonomy;

class Ad extends Model
{
    use HasTaxonomy;

Ce trait ajoute des méthodes puissantes pour lier les termes :

• $ad->attachTerm(25) : lie l'annonce au terme dont l'ID est 25 (par exemple « Voiture »)
• $ad->tags() : récupère tous les termes liés à cette annonce qui appartiennent au vocabulaire « Tags »
• $ad->syncTerms( [1, 2, 3] ) : met à jour l'ensemble des termes liés à l'annonce.

Installer et configurer

L'installation du package est tout à fait classique :

composer require aliziodev/laravel-taxonomy

On peut publier les migrations et la configuration :

php artisan taxonomy:install

Dans tous les cas il faut lancer les migrations :

php artisan migrate

La migration crée deux tables. La table taxonomies qui mémorise les termes :

Et la table taxonomables qui sert à la liaison avec les modèles :

Au niveau de la configuration, ce sont surtout les types qui peuvent être adaptés selon les besoins :

'types' => [
    'category',
    'tag',
    'brand',
    'collection',
    'custom_type',
],

On se lance

Il est facile de créer des termes en utilisant la façade Taxonomy :

// 1. Création de la catégorie racine
$immobilier = Taxonomy::create([
    'name' => 'Immobilier',
    'type' => TaxonomyType::Category->value,
]);

// 2. Création des sous-catégories
$ventesImmobilieres = Taxonomy::create([
    'name' => 'Ventes immobilières',
    'type' => TaxonomyType::Category->value,
    'parent_id' => $immobilier->id,
]);

$locations = Taxonomy::create([
    'name' => 'Locations',
    'type' => TaxonomyType::Category->value,
    'parent_id' => $immobilier->id,
]);

// 3. Création d'une sous-sous-catégorie
$maison = Taxonomy::create([
    'name' => 'Maison',
    'type' => TaxonomyType::Category->value,
    'parent_id' => $ventesImmobilieres->id,
]);

// 4. Création d'une autre sous-sous-catégorie pour illustrer la hiérarchie
$appartement = Taxonomy::create([
    'name' => 'Appartement',
    'type' => TaxonomyType::Category->value,
    'parent_id' => $ventesImmobilieres->id,
]);

Pour chaque terme, on peut ajouter une description et des données supplémentaires dans un champ en JSON (meta).

Une fois que les termes ont été créés, il faut les attacher à un modèle :

$annonce = Ad::create([
    'name' => 'Maison à vendre',
    'price' => 230000,
]);

// On attache les termes
$annonce->attachTaxonomies([$immobilier->id, $ventes-immobilieres->id]);

// On peut aussi utiliser les slugs
$annonce->attachTaxonomies(['immobilier', 'ventes-immobilieres']);

Il est ensuite possible d'effectuer des recherches :

// Trouver des annonces
$annonces = Ad::withTaxonomyType(TaxonomyType::Category)
    ->withTaxonomySlug('immobilier')
    ->get();

Vous trouverez bien d'autres possibilités dans la documentation du package.

Données hiérarchiques

Le package utilise le nested set model. Voyons ça d'un peu plus près...

Le nested set model est une méthode qui permet de stocker et de gérer des données hiérarchiques (telles que des arbres ou des catégories imbriquées) dans une base de données relationnelle. Il utilise trois colonnes principales pour chaque nœud (ou élément) de l’arbre :

• lft (gauche) : un nombre entier représentant la position « gauche » du nœud
• rgt (droite) : un nombre entier représentant la position « droite » du nœud
• depth (profondeur) : le niveau de profondeur du nœud dans l’arbre (0 pour la racine, 1 pour ses enfants, etc.)

Avec les termes qu'on a créés précédemment, on a ces valeurs dans la table :

Chaque nœud « encadre » ses enfants : le lft du parent est toujours inférieur au lft de ses enfants, et le rgt du parent est toujours supérieur au rgt de ses enfants.

La profondeur (ou « depth ») indique le niveau dans l’arbre.

Les requêtes sont rapides : pour récupérer tous les descendants ou ancêtres d’un nœud, il suffit de comparer les valeurs lft et rgt, sans avoir à effectuer de parcours récursif coûteux. Par exemple, tous les descendants de « ventes immobilières » ont un lft supérieur à 2 et un rgt inférieur à 7.

Le package propose de nombreuses méthodes : getDescendants, getAncestors, isAncestorOf, isDescendantOf, getLevel, moveToParent, flatTree...

Conclusion

Nous avons vu qu'il s'agit d'un outil efficace pour gérer des données hiérarchisées. J'ai simplement présenté les éléments fondamentaux, mais je vous conseille d'aller lire la documentation, qui est vraiment très riche. Ce package peut s'avérer très utile pour de nombreuses applications : catalogue, e-commerce, apprentissage, etc. N'hésitez pas à me faire part de vos expériences si vous l'utilisez !