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;
}
}
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);
}
}
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));
}
}
É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;
});
}
}
É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);
}
}
}
Exemple de Résultat
Avant la modération
$article = Article::create([
'content' => 'This is a VIAGRA ad with some hate speech.',
'status' => 'draft',
]);
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".
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)