DEV Community

Cover image for Utilisation des Pipelines pour structurer le flux de traitement en Laravel(Partie 2)
Dieudonne Gwet Bikoun
Dieudonne Gwet Bikoun

Posted on

Utilisation des Pipelines pour structurer le flux de traitement en Laravel(Partie 2)

Dans la partie 1, nous avons exploré les concepts théoriques des Pipelines dans Laravel. Maintenant, passons à la pratique avec une étude de cas concrète : la création d’un système de modération de contenu pour des articles. Ce système devra vérifier plusieurs critères avant de publier un article, comme la détection de spam, le filtrage de mots interdits et la validation du formatage.


Étude de Cas : Modération d’Articles

Objectif

Nous voulons créer un workflow de modération qui :

  • Vérifie si le contenu contient du spam.
  • Filtre les mots interdits.
  • Formate le contenu correctement.
  • Publie l’article si tout est valide.

Étape 1 : Créer les Classes pour chaque Étape

Chaque étape du pipeline sera représentée par une classe dédiée. Ces classes doivent implémenter une méthode handle($passable, $next).

1. CheckForSpam : Détection de spam

<?php

namespace App\Pipelines\Moderation;

class CheckForSpam
{
    public function handle($article, $next)
    {
        if ($this->isSpam($article->content)) {
            throw new \Exception("Le contenu est considéré comme du spam.");
        }
        return $next($article);
    }

    private function isSpam($content)
    {
        // Exemple simple : détection de mots-clés de spam
        $spamKeywords = ['viagra', 'casino', 'lottery'];
        foreach ($spamKeywords as $keyword) {
            if (stripos($content, $keyword) !== false) {
                return true;
            }
        }
        return false;
    }
}
Enter fullscreen mode Exit fullscreen mode

2. FilterForbiddenWords : Filtrage de mots interdits

<?php

namespace App\Pipelines\Moderation;

class FilterForbiddenWords
{
    public function handle($article, $next)
    {
        $article->content = $this->filter($article->content);
        return $next($article);
    }

    private function filter($content)
    {
        $forbiddenWords = ['hate', 'violence', 'drugs'];
        return str_ireplace($forbiddenWords, '****', $content);
    }
}
Enter fullscreen mode Exit fullscreen mode

3. FormatContent : Formatage du contenu

<?php

namespace App\Pipelines\Moderation;

class FormatContent
{
    public function handle($article, $next)
    {
        $article->content = $this->format($article->content);
        return $next($article);
    }

    private function format($content)
    {
        // Exemple : mettre en majuscule la première lettre de chaque phrase
        return ucfirst(strtolower($content));
    }
}
Enter fullscreen mode Exit fullscreen mode

Étape 2 : Créer le Pipeline

Maintenant que nous avons nos classes, nous pouvons les enchaîner dans un pipeline.

use Illuminate\Pipeline\Pipeline;
use App\Pipelines\Moderation\CheckForSpam;
use App\Pipelines\Moderation\FilterForbiddenWords;
use App\Pipelines\Moderation\FormatContent;

class ArticleModeration
{
    public function moderate($article)
    {
        return app(Pipeline::class)
            ->send($article)
            ->through([
                CheckForSpam::class,
                FilterForbiddenWords::class,
                FormatContent::class,
            ])
            ->then(function ($article) {
                // Si tout est valide, publier l'article
                $article->status = 'published';
                $article->save();
                return $article;
            });
    }
}
Enter fullscreen mode Exit fullscreen mode

Étape 3 : Utiliser le Pipeline

Voici comment utiliser notre système de modération dans un contrôleur ou une commande :

use App\Models\Article;
use App\Services\ArticleModeration;

class ArticleController extends Controller
{
    public function publish(ArticleModeration $moderation)
    {
        $article = Article::find(1); // Récupérer l'article à modérer

        try {
            $moderatedArticle = $moderation->moderate($article);
            return response()->json(['message' => 'Article publié !', 'article' => $moderatedArticle]);
        } catch (\Exception $e) {
            return response()->json(['error' => $e->getMessage()], 400);
        }
    }
}
Enter fullscreen mode Exit fullscreen mode

Exemple de Résultat

Avant la modération

$article = Article::create([
    'content' => 'This is a VIAGRA ad with some hate speech.',
    'status' => 'draft',
]);
Enter fullscreen mode Exit fullscreen mode

Après la modération

$moderatedArticle = $moderation->moderate($article);

// Résultat :
// - "VIAGRA" est détecté comme spam : une exception est levée.
// - Si le spam est absent, "hate" est remplacé par "****".
// - Le contenu est formaté : "This is a **** ad with some **** speech."
// - Le statut est passé à "published".
Enter fullscreen mode Exit fullscreen mode

Avantages de cette Approche

Modularité : Chaque étape est isolée et peut être modifiée indépendamment.

Testabilité : Chaque classe peut être testée unitairement.

Extensibilité : Ajouter une nouvelle étape (ex: vérification de plagiat) est trivial.

Lisibilité : Le flux de traitement est clair et facile à comprendre.


Conclusion

Avec ce cas pratique, vous avez vu comment les Pipelines peuvent structurer un workflow complexe en étapes simples et réutilisables. Que ce soit pour la modération de contenu, la validation de données ou l’orchestration de workflows métier, les Pipelines sont un outil puissant pour garder votre code propre et maintenable.


Et vous, avez-vous déjà utilisé les Pipelines pour structurer vos workflows ? Partagez vos retours en commentaire !
Si cet article vous a aidé, n’hésitez pas à le partager avec votre réseau. 👇

Top comments (0)

Billboard image

The Next Generation Developer Platform

Coherence is the first Platform-as-a-Service you can control. Unlike "black-box" platforms that are opinionated about the infra you can deploy, Coherence is powered by CNC, the open-source IaC framework, which offers limitless customization.

Learn more