netig/slim-blog
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

first commit

Browse Source
This commit is contained in:
julien
2026-03-16 01:47:07 +01:00
commit 8f7e61bda0
185 changed files with 27731 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

252
src/Post/Post.php Normal file
View File

@@ -0,0 +1,252 @@
<?php
declare(strict_types=1);
namespace App\Post;
use App\Shared\Util\DateParser;
use App\Shared\Util\SlugHelper;
use DateTime;
/**
* Modèle représentant un article de blog.
*
* Encapsule les données et la validation d'un article.
* Ce modèle est immuable après construction.
* Le nom d'auteur est dénormalisé (chargé par JOIN dans PostRepository)
* pour éviter des requêtes supplémentaires à l'affichage.
* La logique de présentation (excerpt, formatage) est déléguée à PostExtension.
*
* Distinction slug :
* - getStoredSlug() : slug lu depuis la base de données (canonique, peut comporter
* un suffixe numérique pour lever les collisions, ex: "mon-article-2")
* - generateSlug() : slug calculé dynamiquement depuis le titre, utilisé uniquement
* par PostService lors de la création/modification pour produire le slug à stocker
*/
final class Post
{
/**
* @var DateTime Date de création — toujours non nulle après construction
* (le constructeur accepte ?DateTime mais affecte `new DateTime()` si null)
*/
private readonly DateTime $createdAt;
/**
* @var DateTime Date de dernière modification — toujours non nulle après construction
*/
private readonly DateTime $updatedAt;
/**
* @param int $id Identifiant en base (0 pour un nouvel article)
* @param string $title Titre de l'article (1–255 caractères)
* @param string $content Contenu HTML de l'article (1–65 535 caractères)
* @param string $slug Slug URL canonique, tel que stocké en base
* @param int|null $authorId Identifiant de l'auteur (null si le compte a été supprimé)
* @param string|null $authorUsername Nom de l'auteur dénormalisé (null si le compte a été supprimé)
* @param int|null $categoryId Identifiant de la catégorie (null si sans catégorie)
* @param string|null $categoryName Nom de la catégorie dénormalisé (null si sans catégorie)
* @param string|null $categorySlug Slug de la catégorie dénormalisé (null si sans catégorie)
* @param DateTime|null $createdAt Date de création (défaut : maintenant)
* @param DateTime|null $updatedAt Date de dernière modification (défaut : maintenant)
*
* @throws \InvalidArgumentException Si les données ne passent pas la validation
*/
public function __construct(
private readonly int $id,
private readonly string $title,
private readonly string $content,
private readonly string $slug = '',
private readonly ?int $authorId = null,
private readonly ?string $authorUsername = null,
private readonly ?int $categoryId = null,
private readonly ?string $categoryName = null,
private readonly ?string $categorySlug = null,
?DateTime $createdAt = null,
?DateTime $updatedAt = null,
) {
$this->createdAt = $createdAt ?? new DateTime();
$this->updatedAt = $updatedAt ?? new DateTime();
$this->validate();
}
/**
* Crée une instance depuis un tableau associatif (ligne de base de données).
*
* @param array<string, mixed> $data Données issues de la base de données (avec JOIN users)
*
* @return self L'instance hydratée
*/
public static function fromArray(array $data): self
{
return new self(
id: (int) ($data['id'] ?? 0),
title: (string) ($data['title'] ?? ''),
content: (string) ($data['content'] ?? ''),
slug: (string) ($data['slug'] ?? ''),
authorId: isset($data['author_id']) ? (int) $data['author_id'] : null,
authorUsername: isset($data['author_username']) ? (string) $data['author_username'] : null,
categoryId: isset($data['category_id']) ? (int) $data['category_id'] : null,
categoryName: isset($data['category_name']) ? (string) $data['category_name'] : null,
categorySlug: isset($data['category_slug']) ? (string) $data['category_slug'] : null,
createdAt: DateParser::parse($data['created_at'] ?? null),
updatedAt: DateParser::parse($data['updated_at'] ?? null),
);
}
/**
* Retourne l'identifiant de l'article.
*
* @return int L'identifiant en base (0 si non encore persisté)
*/
public function getId(): int
{
return $this->id;
}
/**
* Retourne le titre de l'article.
*
* @return string Le titre
*/
public function getTitle(): string
{
return $this->title;
}
/**
* Retourne le contenu HTML de l'article.
*
* @return string Le contenu HTML sanitisé (purifié par HTMLPurifier à l'écriture)
*/
public function getContent(): string
{
return $this->content;
}
/**
* Retourne le slug canonique tel que stocké en base de données.
*
* Ce slug peut différer du résultat de generateSlug() si un suffixe numérique
* a été ajouté lors de la création pour lever une collision
* (ex: titre "Mon article" → slug en DB "mon-article-2").
* C'est cette valeur qu'il faut utiliser pour construire les URLs publiques.
*
* @return string Le slug canonique (vide si l'article n'a pas encore été persisté)
*/
public function getStoredSlug(): string
{
return $this->slug;
}
/**
* Retourne l'identifiant de l'auteur.
*
* @return int|null L'identifiant de l'auteur, ou null si le compte a été supprimé
*/
public function getAuthorId(): ?int
{
return $this->authorId;
}
/**
* Retourne le nom d'utilisateur de l'auteur.
*
* @return string|null Le nom d'utilisateur, ou null si le compte a été supprimé
*/
public function getAuthorUsername(): ?string
{
return $this->authorUsername;
}
/**
* Retourne l'identifiant de la catégorie de l'article.
*
* @return int|null L'identifiant de la catégorie, ou null si l'article est sans catégorie
*/
public function getCategoryId(): ?int
{
return $this->categoryId;
}
/**
* Retourne le nom de la catégorie de l'article.
*
* @return string|null Le nom de la catégorie, ou null si l'article est sans catégorie
*/
public function getCategoryName(): ?string
{
return $this->categoryName;
}
/**
* Retourne le slug de la catégorie de l'article.
*
* @return string|null Le slug de la catégorie, ou null si l'article est sans catégorie
*/
public function getCategorySlug(): ?string
{
return $this->categorySlug;
}
/**
* Retourne la date de création de l'article.
*
* @return DateTime La date de création
*/
public function getCreatedAt(): DateTime
{
return $this->createdAt;
}
/**
* Retourne la date de dernière modification de l'article.
*
* @return DateTime La date de dernière modification
*/
public function getUpdatedAt(): DateTime
{
return $this->updatedAt;
}
/**
* Génère un slug URL-friendly calculé à partir du titre courant.
*
* Cette méthode est réservée à PostService pour produire le slug à stocker
* lors de la création ou de la modification d'un article.
* Pour construire une URL publique, utiliser getStoredSlug() qui retourne
* le slug canonique tel qu'il est enregistré en base de données.
*
* La génération est déléguée à SlugHelper::generate() — voir sa documentation
* pour le détail de l'algorithme (translittération ASCII, minuscules, tirets).
*
* @return string Le slug en minuscules avec tirets (ex: "ete-en-foret")
*/
public function generateSlug(): string
{
return SlugHelper::generate($this->title);
}
/**
* Valide les données de l'article.
*
* @throws \InvalidArgumentException Si le titre est vide ou dépasse 255 caractères
* @throws \InvalidArgumentException Si le contenu est vide ou dépasse 65 535 caractères
*/
private function validate(): void
{
if ($this->title === '') {
throw new \InvalidArgumentException('Le titre ne peut pas être vide');
}
if (mb_strlen($this->title) > 255) {
throw new \InvalidArgumentException('Le titre ne peut pas dépasser 255 caractères');
}
if ($this->content === '') {
throw new \InvalidArgumentException('Le contenu ne peut pas être vide');
}
if (mb_strlen($this->content) > 65535) {
throw new \InvalidArgumentException('Le contenu ne peut pas dépasser 65 535 caractères');
}
}
}

379
src/Post/PostController.php Normal file
View File

@@ -0,0 +1,379 @@
<?php
declare(strict_types=1);
namespace App\Post;
use App\Category\CategoryServiceInterface;
use App\Shared\Exception\NotFoundException;
use App\Shared\Http\FlashServiceInterface;
use App\Shared\Http\SessionManagerInterface;
use Psr\Http\Message\ResponseInterface as Response;
use Psr\Http\Message\ServerRequestInterface as Request;
use Slim\Exception\HttpNotFoundException;
use Slim\Views\Twig;
/**
* Contrôleur pour les articles.
*
* Gère les actions HTTP liées aux articles : affichage public et administration
* (liste, formulaire, création, modification, suppression).
* Délègue toute la logique métier à PostService et utilise FlashService
* pour transmettre les messages d'erreur entre redirections.
* L'identifiant de l'auteur est lu depuis SessionManager lors de la création.
* Les droits de modification et suppression sont vérifiés via canEditPost().
* CategoryService est injecté pour résoudre les slugs de catégorie
* en identifiants et fournir la liste des catégories aux vues.
*/
final class PostController
{
/**
* @param Twig $view Moteur de templates Twig
* @param PostServiceInterface $postService Service métier des articles
* @param CategoryServiceInterface $categoryService Service de gestion des catégories
* @param FlashServiceInterface $flash Service de messages flash
* @param SessionManagerInterface $sessionManager Gestionnaire de session
*/
public function __construct(
private readonly Twig $view,
private readonly PostServiceInterface $postService,
private readonly CategoryServiceInterface $categoryService,
private readonly FlashServiceInterface $flash,
private readonly SessionManagerInterface $sessionManager,
) {
}
/**
* Affiche la page d'accueil avec la liste des articles.
*
* Accepte deux paramètres de requête cumulables :
* - `q` (string) : recherche plein texte FTS5 sur titre, contenu et auteur
* - `categorie` (string) : filtre par slug de catégorie
*
* Si `q` est fourni, les résultats sont triés par pertinence BM25.
* Sans `q`, les articles sont triés du plus récent au plus ancien.
*
* @param Request $req La requête HTTP
* @param Response $res La réponse HTTP
*
* @return Response La vue de la page d'accueil
*/
public function index(Request $req, Response $res): Response
{
$params = $req->getQueryParams();
$searchQuery = trim((string) ($params['q'] ?? ''));
$categorySlug = (string) ($params['categorie'] ?? '');
$activeCategory = null;
$categoryId = null;
if ($categorySlug !== '') {
$activeCategory = $this->categoryService->findBySlug($categorySlug);
$categoryId = $activeCategory?->getId();
}
$posts = $searchQuery !== ''
? $this->postService->searchPosts($searchQuery, $categoryId)
: $this->postService->getAllPosts($categoryId);
return $this->view->render($res, 'pages/home.twig', [
'posts' => $posts,
'categories' => $this->categoryService->findAll(),
'activeCategory' => $activeCategory,
'searchQuery' => $searchQuery,
]);
}
/**
* Affiche le détail d'un article par son slug.
*
* Le contenu HTML est déjà sanitisé lors de la création/modification
* (via HtmlSanitizerInterface dans PostService) : aucun nettoyage supplémentaire
* n'est nécessaire à la lecture.
*
* @param Request $req La requête HTTP
* @param Response $res La réponse HTTP
* @param array<string, string> $args Les paramètres de route (slug)
*
* @return Response La vue de détail de l'article
*
* @throws HttpNotFoundException Si aucun article ne correspond au slug
*/
public function show(Request $req, Response $res, array $args): Response
{
try {
$post = $this->postService->getPostBySlug((string) ($args['slug'] ?? ''));
} catch (NotFoundException) {
throw new HttpNotFoundException($req);
}
return $this->view->render($res, 'pages/post/detail.twig', ['post' => $post]);
}
/**
* Affiche la liste des articles dans l'interface d'administration.
*
* Un administrateur ou un éditeur voit tous les articles.
* Un utilisateur normal voit uniquement ses propres articles.
*
* Accepte deux paramètres de requête cumulables :
* - `q` (string) : recherche plein texte FTS5 sur titre, contenu et auteur
* - `categorie` (string) : filtre par slug de catégorie
*
* Si `q` est fourni, les résultats sont triés par pertinence BM25.
* Sans `q`, les articles sont triés du plus récent au plus ancien.
*
* @param Request $req La requête HTTP
* @param Response $res La réponse HTTP
*
* @return Response La vue d'administration des posts
*/
public function admin(Request $req, Response $res): Response
{
$isAdmin = $this->sessionManager->isAdmin() || $this->sessionManager->isEditor();
$userId = $this->sessionManager->getUserId();
$params = $req->getQueryParams();
$searchQuery = trim((string) ($params['q'] ?? ''));
$categorySlug = (string) ($params['categorie'] ?? '');
$activeCategory = null;
$categoryId = null;
if ($categorySlug !== '') {
$activeCategory = $this->categoryService->findBySlug($categorySlug);
$categoryId = $activeCategory?->getId();
}
if ($searchQuery !== '') {
$authorId = $isAdmin ? null : (int) $userId;
$posts = $this->postService->searchPosts($searchQuery, $categoryId, $authorId);
} else {
$posts = $isAdmin
? $this->postService->getAllPosts($categoryId)
: $this->postService->getPostsByUserId((int) $userId, $categoryId);
}
return $this->view->render($res, 'admin/posts/index.twig', [
'posts' => $posts,
'categories' => $this->categoryService->findAll(),
'activeCategory' => $activeCategory,
'searchQuery' => $searchQuery,
'error' => $this->flash->get('post_error'),
'success' => $this->flash->get('post_success'),
]);
}
/**
* Affiche le formulaire de création (id=0) ou d'édition d'un article.
*
* L'accès en édition est refusé si l'utilisateur n'est pas l'auteur
* de l'article et n'a pas le rôle admin.
*
* @param Request $req La requête HTTP
* @param Response $res La réponse HTTP
* @param array<string, string> $args Les paramètres de route (id)
*
* @return Response Le formulaire ou une redirection
*
* @throws HttpNotFoundException Si l'article demandé n'existe pas
*/
public function form(Request $req, Response $res, array $args): Response
{
$id = (int) ($args['id'] ?? 0);
$post = null;
if ($id > 0) {
try {
$post = $this->postService->getPostById($id);
} catch (NotFoundException) {
throw new HttpNotFoundException($req);
}
// Vérification des droits avant affichage du formulaire
if (!$this->canEditPost($post)) {
$this->flash->set('post_error', "Vous ne pouvez pas modifier un article dont vous n'êtes pas l'auteur");
return $res->withHeader('Location', '/admin/posts')->withStatus(302);
}
}
return $this->view->render($res, 'admin/posts/form.twig', [
'post' => $post,
'categories' => $this->categoryService->findAll(),
'action' => $id > 0 ? "/admin/posts/edit/{$id}" : '/admin/posts/create',
'error' => $this->flash->get('post_error'),
]);
}
/**
* Traite la soumission du formulaire de création d'article.
*
* L'auteur est l'utilisateur connecté, lu depuis la session.
* Le slug est généré automatiquement depuis le titre par PostService —
* la valeur éventuellement saisie dans le formulaire est ignorée à la création
* (elle n'est prise en compte qu'à la modification via update()).
* En cas d'erreur de validation, redirige vers le formulaire avec un message flash.
*
* @param Request $req La requête HTTP
* @param Response $res La réponse HTTP
*
* @return Response Une redirection vers /admin/posts ou /admin/posts/edit/0
*/
public function create(Request $req, Response $res): Response
{
['title' => $title, 'content' => $content, 'category_id' => $categoryId] =
$this->extractPostData($req);
try {
$this->postService->createPost($title, $content, $this->sessionManager->getUserId() ?? 0, $categoryId);
$this->flash->set('post_success', 'L\'article a été créé avec succès');
} catch (\InvalidArgumentException $e) {
$this->flash->set('post_error', $e->getMessage());
return $res->withHeader('Location', '/admin/posts/edit/0')->withStatus(302);
} catch (\Throwable) {
$this->flash->set('post_error', 'Une erreur inattendue s\'est produite');
return $res->withHeader('Location', '/admin/posts/edit/0')->withStatus(302);
}
return $res->withHeader('Location', '/admin/posts')->withStatus(302);
}
/**
* Traite la soumission du formulaire de modification d'article.
*
* Vérifie les droits avant modification : seul l'auteur ou un admin peut modifier.
* Un second 404 est possible si l'article est supprimé entre la vérification
* des droits et l'UPDATE (race condition).
*
* @param Request $req La requête HTTP
* @param Response $res La réponse HTTP
* @param array<string, string> $args Les paramètres de route (id)
*
* @return Response Une redirection vers /admin/posts ou vers le formulaire
*
* @throws HttpNotFoundException Si l'article n'existe pas ou a disparu (race condition)
*/
public function update(Request $req, Response $res, array $args): Response
{
$id = (int) $args['id'];
['title' => $title, 'content' => $content, 'slug' => $slug, 'category_id' => $categoryId] =
$this->extractPostData($req);
// Récupération de l'article pour vérification des droits avant modification
try {
$post = $this->postService->getPostById($id);
} catch (NotFoundException) {
throw new HttpNotFoundException($req);
}
if (!$this->canEditPost($post)) {
$this->flash->set('post_error', "Vous ne pouvez pas modifier un article dont vous n'êtes pas l'auteur");
return $res->withHeader('Location', '/admin/posts')->withStatus(302);
}
try {
$this->postService->updatePost($id, $title, $content, $slug, $categoryId);
$this->flash->set('post_success', 'L\'article a été modifié avec succès');
} catch (NotFoundException) {
// L'article a disparu entre la vérification des droits et l'UPDATE (race condition)
throw new HttpNotFoundException($req);
} catch (\InvalidArgumentException $e) {
$this->flash->set('post_error', $e->getMessage());
return $res->withHeader('Location', "/admin/posts/edit/{$id}")->withStatus(302);
} catch (\Throwable) {
$this->flash->set('post_error', 'Une erreur inattendue s\'est produite');
return $res->withHeader('Location', "/admin/posts/edit/{$id}")->withStatus(302);
}
return $res->withHeader('Location', '/admin/posts')->withStatus(302);
}
/**
* Supprime un article.
*
* Vérifie les droits avant suppression : seul l'auteur ou un admin peut supprimer.
* Un second 404 est possible si l'article est supprimé entre la vérification
* des droits et le DELETE (race condition — cohérent avec update()).
*
* @param Request $req La requête HTTP
* @param Response $res La réponse HTTP
* @param array<string, string> $args Les paramètres de route (id)
*
* @return Response Une redirection vers /admin/posts
*
* @throws HttpNotFoundException Si l'article n'existe pas ou a disparu (race condition)
*/
public function delete(Request $req, Response $res, array $args): Response
{
// Récupération de l'article pour vérification des droits avant suppression
try {
$post = $this->postService->getPostById((int) $args['id']);
} catch (NotFoundException) {
throw new HttpNotFoundException($req);
}
if (!$this->canEditPost($post)) {
$this->flash->set('post_error', "Vous ne pouvez pas supprimer un article dont vous n'êtes pas l'auteur");
return $res->withHeader('Location', '/admin/posts')->withStatus(302);
}
try {
$this->postService->deletePost($post->getId());
} catch (NotFoundException) {
// L'article a disparu entre la vérification des droits et le DELETE (race condition)
throw new HttpNotFoundException($req);
}
$this->flash->set('post_success', "L'article « {$post->getTitle()} » a été supprimé avec succès");
return $res->withHeader('Location', '/admin/posts')->withStatus(302);
}
/**
* Vérifie si l'utilisateur connecté est autorisé à modifier ou supprimer un article.
*
* L'accès est accordé si l'utilisateur est l'auteur de l'article
* ou s'il a le rôle administrateur.
*
* @param Post $post L'article concerné
*
* @return bool True si l'action est autorisée
*/
private function canEditPost(Post $post): bool
{
// Un administrateur ou un éditeur a tous les droits sur tous les articles
if ($this->sessionManager->isAdmin() || $this->sessionManager->isEditor()) {
return true;
}
// Un utilisateur standard ne peut agir que sur ses propres articles
return $post->getAuthorId() === $this->sessionManager->getUserId();
}
/**
* Extrait et normalise les données d'article depuis le corps de la requête.
*
* @param Request $req La requête HTTP
*
* @return array{title: string, content: string, slug: string, category_id: int|null} Les données nettoyées
*/
private function extractPostData(Request $req): array
{
/** @var array<string, mixed> $data */
$data = (array) $req->getParsedBody();
$categoryId = ($data['category_id'] ?? '') !== ''
? (int) $data['category_id']
: null;
return [
'title' => trim((string) ($data['title'] ?? '')),
'content' => trim((string) ($data['content'] ?? '')),
'slug' => trim((string) ($data['slug'] ?? '')),
'category_id' => $categoryId,
];
}
}

205
src/Post/PostExtension.php Normal file
View File

@@ -0,0 +1,205 @@
<?php
declare(strict_types=1);
namespace App\Post;
use Twig\Extension\AbstractExtension;
use Twig\TwigFunction;
/**
* Extension Twig pour la présentation des articles.
*
* Expose des fonctions utilitaires dans les templates Twig
* afin d'éviter d'appeler de la logique de présentation directement
* sur le modèle Post depuis les vues.
*
* Fonctions disponibles dans les templates :
*
* @example {{ post_excerpt(post) }} — extrait de 400 caractères par défaut
* @example {{ post_excerpt(post, 600) }} — extrait personnalisé de 600 caractères
* @example {{ post_url(post) }} — URL publique de l'article (/article/{slug})
* @example {{ post_thumbnail(post) }} — URL de la première image, ou null si aucune image
* @example {{ post_initials(post) }} — initiales du titre (ex: "AB" pour "Article de Blog")
*/
final class PostExtension extends AbstractExtension
{
/**
* Déclare les fonctions Twig exposées aux templates.
*
* @return TwigFunction[] Les fonctions enregistrées dans l'environnement Twig
*/
public function getFunctions(): array
{
return [
new TwigFunction(
'post_excerpt',
fn (Post $post, int $length = 400) => self::excerpt($post, $length),
['is_safe' => ['html']]
),
new TwigFunction(
'post_url',
fn (Post $post) => '/article/'.$post->getStoredSlug()
),
new TwigFunction(
'post_thumbnail',
fn (Post $post) => self::thumbnail($post)
),
new TwigFunction(
'post_initials',
fn (Post $post) => self::initials($post)
),
];
}
/**
* Génère un extrait HTML formaté du contenu de l'article.
*
* Conserve uniquement les balises sûres et porteuses de sens visuel
* (<ul>, <ol>, <li>, <strong>, <em>, <b>, <i>) afin que le formatage
* soit perceptible dans l'aperçu (listes à puces, gras, italique…).
* Toutes les autres balises sont supprimées par strip_tags().
*
* La hauteur de l'aperçu est contrainte côté CSS (max-height sur .card__body +
* dégradé de fondu sur .card__excerpt) — c'est CSS qui tronque visuellement,
* pas cette méthode. Le paramètre $length sert uniquement de garde-fou serveur :
* il évite d'envoyer l'intégralité d'un long article au navigateur. La valeur
* par défaut de 400 caractères est volontairement généreuse pour ne jamais
* couper un contenu que CSS aurait affiché en entier.
*
* La troncature opère sur le HTML filtré (pas sur le texte brut) afin de
* conserver le formatage de façon cohérente, quelle que soit la longueur
* du contenu. Le comptage de caractères ignore les balises.
*
* Le HTML retourné provient de HTMLPurifier (appliqué à l'écriture) —
* strip_tags() avec liste blanche élimine tout balisage résiduel non désiré.
* La fonction est déclarée is_safe => ['html'] : Twig ne l'échappe pas
* automatiquement, le |raw est inutile dans les templates.
*
* @param Post $post L'article dont générer l'extrait
* @param int $length Longueur maximale en caractères visibles (défaut : 400)
*
* @return string L'extrait en HTML partiel, tronqué si nécessaire
*/
private static function excerpt(Post $post, int $length): string
{
// Balises conservées : structurantes pour les listes, sémantiques pour le gras/italique.
// Toutes les autres (p, div, h1-h6, img, a, table…) sont supprimées pour
// garder un aperçu compact.
$allowed = '<ul><ol><li><strong><em><b><i>';
$html = strip_tags($post->getContent(), $allowed);
// Mesurer sur le texte brut : les balises ne comptent pas dans la limite visible
if (mb_strlen(strip_tags($html)) <= $length) {
return $html;
}
// Tronquer en avançant caractère par caractère dans le HTML, en ignorant
// les balises dans le comptage — le formatage est ainsi conservé dans la
// portion visible, de façon cohérente avec les articles courts.
$truncated = '';
$count = 0;
$inTag = false;
for ($i = 0, $len = mb_strlen($html); $i < $len && $count < $length; $i++) {
$char = mb_substr($html, $i, 1);
if ($char === '<') {
$inTag = true;
}
$truncated .= $char;
if ($inTag) {
if ($char === '>') {
$inTag = false;
}
} else {
$count++;
}
}
// Fermer proprement les balises laissées ouvertes par la troncature
foreach (['li', 'ul', 'ol', 'em', 'strong', 'b', 'i'] as $tag) {
$opens = substr_count($truncated, "<{$tag}>") + substr_count($truncated, "<{$tag} ");
$closes = substr_count($truncated, "</{$tag}>");
for ($j = $closes; $j < $opens; $j++) {
$truncated .= "</{$tag}>";
}
}
return $truncated . '…';
}
/**
* Extrait l'URL de la première image présente dans le contenu de l'article.
*
* Utilise une regex sur l'attribut src de la première balise <img> trouvée.
* Le contenu étant sanitisé par HTMLPurifier, seuls les schémas http/https
* sont présents — aucun risque XSS via cet attribut.
* L'échappement de l'URL est délégué à Twig (auto-escape activé).
*
* @param Post $post L'article dont extraire la vignette
*
* @return string|null L'URL de la première image, ou null si aucune image
*/
private static function thumbnail(Post $post): ?string
{
if (preg_match('/<img[^>]+src=["\']([^"\']+)["\']/', $post->getContent(), $matches)) {
return $matches[1];
}
return null;
}
/**
* Génère les initiales du titre de l'article (1 à 2 caractères).
*
* Extrait la première lettre de chaque mot, conserve les deux premières,
* et retourne le résultat en majuscules. Les mots vides (articles, prépositions
* d'une lettre) sont ignorés pour favoriser les mots porteurs de sens.
*
* Exemples :
* "Article de Blog" → "AB"
* "Été en forêt" → "EF"
* "PHP" → "P"
* "" → "?"
*
* L'échappement HTML est délégué à Twig (auto-escape activé).
*
* @param Post $post L'article dont générer les initiales
*
* @return string Les initiales en majuscules (1–2 caractères), ou "?" si le titre est vide
*/
private static function initials(Post $post): string
{
// Filtrer les mots vides fréquents (articles, prépositions, coordinations)
// pour favoriser les mots porteurs de sens : "Article de Blog" → ["Article", "Blog"] → "AB"
$stopWords = ['a', 'au', 'aux', 'd', 'de', 'des', 'du', 'en', 'et', 'l', 'la', 'le', 'les', 'of', 'the', 'un', 'une'];
$words = array_filter(
preg_split('/\s+/', trim($post->getTitle())) ?: [],
static function (string $w) use ($stopWords): bool {
$normalized = mb_strtolower(trim($w, " \t\n\r\0\x0B'\"’`.-_"));
return $normalized !== ''
&& mb_strlen($normalized) > 1
&& !in_array($normalized, $stopWords, true);
}
);
if (empty($words)) {
// Repli sur le premier caractère du titre brut si tous les mots font 1 lettre
$first = mb_substr(trim($post->getTitle()), 0, 1);
return $first !== '' ? mb_strtoupper($first) : '?';
}
$words = array_values($words);
$initials = mb_strtoupper(mb_substr($words[0], 0, 1));
if (isset($words[1])) {
$initials .= mb_strtoupper(mb_substr($words[1], 0, 1));
}
return $initials;
}
}

334
src/Post/PostRepository.php Normal file
View File

@@ -0,0 +1,334 @@
<?php
declare(strict_types=1);
namespace App\Post;
use PDO;
/**
* Dépôt pour la persistance des articles.
*
* Responsabilité unique : exécuter les requêtes SQL liées à la table `posts`
* et retourner des instances de Post hydratées.
* Chaque requête de lecture effectue un LEFT JOIN sur `users` pour charger
* le nom d'auteur, et un LEFT JOIN sur `categories` pour charger le nom et
* le slug de catégorie — sans requête supplémentaire.
*/
final class PostRepository implements PostRepositoryInterface
{
/**
* Fragment SELECT commun à toutes les requêtes de lecture (avec JOINs).
*/
private const SELECT = '
SELECT posts.id, posts.title, posts.content, posts.slug,
posts.author_id, posts.category_id, posts.created_at, posts.updated_at,
users.username AS author_username,
categories.name AS category_name,
categories.slug AS category_slug
FROM posts
LEFT JOIN users ON users.id = posts.author_id
LEFT JOIN categories ON categories.id = posts.category_id
';
/**
* @param PDO $db Instance de connexion à la base de données
*/
public function __construct(private readonly PDO $db)
{
}
/**
* Retourne tous les articles triés du plus récent au plus ancien.
*
* @param int|null $categoryId Filtre optionnel par identifiant de catégorie
*
* @return Post[] La liste des articles
*/
public function findAll(?int $categoryId = null): array
{
if ($categoryId !== null) {
$stmt = $this->db->prepare(self::SELECT . ' WHERE posts.category_id = :category_id ORDER BY posts.id DESC');
$stmt->execute([':category_id' => $categoryId]);
} else {
$stmt = $this->db->query(self::SELECT . ' ORDER BY posts.id DESC');
if ($stmt === false) {
throw new \RuntimeException('La requête SELECT sur posts a échoué.');
}
}
$rows = $stmt->fetchAll(PDO::FETCH_ASSOC);
return array_map(fn ($row) => Post::fromArray($row), $rows);
}
/**
* Retourne les N articles les plus récents, tous auteurs confondus.
*
* @param int $limit Nombre maximum d'articles à retourner
*
* @return Post[] Les articles les plus récents
*/
public function findRecent(int $limit): array
{
$stmt = $this->db->prepare(self::SELECT . ' ORDER BY posts.id DESC LIMIT :limit');
$stmt->bindValue(':limit', $limit, PDO::PARAM_INT);
$stmt->execute();
$rows = $stmt->fetchAll(PDO::FETCH_ASSOC);
return array_map(fn ($row) => Post::fromArray($row), $rows);
}
/**
* Retourne tous les articles d'un utilisateur donné, triés du plus récent au plus ancien.
*
* @param int $userId Identifiant de l'auteur
* @param int|null $categoryId Filtre optionnel par identifiant de catégorie
*
* @return Post[] La liste des articles de cet utilisateur
*/
public function findByUserId(int $userId, ?int $categoryId = null): array
{
if ($categoryId !== null) {
$stmt = $this->db->prepare(
self::SELECT . ' WHERE posts.author_id = :author_id AND posts.category_id = :category_id ORDER BY posts.id DESC'
);
$stmt->execute([':author_id' => $userId, ':category_id' => $categoryId]);
} else {
$stmt = $this->db->prepare(self::SELECT . ' WHERE posts.author_id = :author_id ORDER BY posts.id DESC');
$stmt->execute([':author_id' => $userId]);
}
$rows = $stmt->fetchAll(PDO::FETCH_ASSOC);
return array_map(fn ($row) => Post::fromArray($row), $rows);
}
/**
* Trouve un article par son slug URL.
*
* @param string $slug Le slug URL de l'article
*
* @return Post|null L'article trouvé, ou null s'il n'existe pas
*/
public function findBySlug(string $slug): ?Post
{
$stmt = $this->db->prepare(self::SELECT . ' WHERE posts.slug = :slug');
$stmt->execute([':slug' => $slug]);
$row = $stmt->fetch(PDO::FETCH_ASSOC);
return $row ? Post::fromArray($row) : null;
}
/**
* Trouve un article par son identifiant.
*
* @param int $id Identifiant de l'article
*
* @return Post|null L'article trouvé, ou null s'il n'existe pas
*/
public function findById(int $id): ?Post
{
$stmt = $this->db->prepare(self::SELECT . ' WHERE posts.id = :id');
$stmt->execute([':id' => $id]);
$row = $stmt->fetch(PDO::FETCH_ASSOC);
return $row ? Post::fromArray($row) : null;
}
/**
* Persiste un nouvel article en base de données.
*
* @param Post $post L'article à créer
* @param string $slug Le slug unique généré pour cet article
* @param int $authorId Identifiant de l'auteur
* @param int|null $categoryId Identifiant de la catégorie (null si sans catégorie)
*
* @return int L'identifiant généré par la base de données
*/
public function create(Post $post, string $slug, int $authorId, ?int $categoryId): int
{
$stmt = $this->db->prepare('
INSERT INTO posts (title, content, slug, author_id, category_id, created_at, updated_at)
VALUES (:title, :content, :slug, :author_id, :category_id, :created_at, :updated_at)
');
$stmt->execute([
':title' => $post->getTitle(),
':content' => $post->getContent(),
':slug' => $slug,
':author_id' => $authorId,
':category_id' => $categoryId,
':created_at' => date('Y-m-d H:i:s'),
':updated_at' => date('Y-m-d H:i:s'),
]);
return (int) $this->db->lastInsertId();
}
/**
* Met à jour un article existant en base de données.
*
* Retourne le nombre de lignes affectées. Une valeur de 0 indique que
* l'article n'existe plus au moment de l'écriture (suppression concurrente).
*
* @param int $id Identifiant de l'article à modifier
* @param Post $post L'article avec les nouvelles données
* @param string $slug Le nouveau slug unique
* @param int|null $categoryId Identifiant de la catégorie (null si sans catégorie)
*
* @return int Nombre de lignes affectées (0 si l'article n'existe plus)
*/
public function update(int $id, Post $post, string $slug, ?int $categoryId): int
{
$stmt = $this->db->prepare('
UPDATE posts
SET title = :title, content = :content, slug = :slug,
category_id = :category_id, updated_at = :updated_at
WHERE id = :id
');
$stmt->execute([
':title' => $post->getTitle(),
':content' => $post->getContent(),
':slug' => $slug,
':category_id' => $categoryId,
':updated_at' => date('Y-m-d H:i:s'),
':id' => $id,
]);
return $stmt->rowCount();
}
/**
* Supprime un article de la base de données.
*
* @param int $id Identifiant de l'article à supprimer
*
* @return int Nombre de lignes supprimées (0 si l'article n'existe plus)
*/
public function delete(int $id): int
{
$stmt = $this->db->prepare('DELETE FROM posts WHERE id = :id');
$stmt->execute([':id' => $id]);
return $stmt->rowCount();
}
/**
* Recherche des articles en plein texte via l'index FTS5.
*
* La requête est tokenisée mot par mot : chaque terme est traité comme un
* préfixe (ex: "slim" correspond à "Slim", "Slimframework"…). Les termes
* sont combinés en AND implicite — tous doivent être présents dans le document.
* Les caractères spéciaux FTS5 sont échappés par guillemets doubles.
*
* Les résultats sont triés par pertinence BM25 (meilleur en premier).
* Filtrages optionnels disponibles : par catégorie et/ou par auteur.
*
* @param string $query La saisie utilisateur brute
* @param int|null $categoryId Filtre optionnel par identifiant de catégorie
* @param int|null $authorId Filtre optionnel par identifiant d'auteur (rôle user)
*
* @return Post[] Les articles correspondant à la recherche, triés par pertinence
*/
public function search(string $query, ?int $categoryId = null, ?int $authorId = null): array
{
$ftsQuery = $this->buildFtsQuery($query);
if ($ftsQuery === '') {
return [];
}
$sql = '
SELECT p.id, p.title, p.content, p.slug,
p.author_id, p.category_id, p.created_at, p.updated_at,
u.username AS author_username,
c.name AS category_name,
c.slug AS category_slug
FROM posts_fts f
JOIN posts p ON p.id = f.rowid
LEFT JOIN users u ON u.id = p.author_id
LEFT JOIN categories c ON c.id = p.category_id
WHERE posts_fts MATCH :query
';
$params = [':query' => $ftsQuery];
if ($categoryId !== null) {
$sql .= ' AND p.category_id = :category_id';
$params[':category_id'] = $categoryId;
}
if ($authorId !== null) {
$sql .= ' AND p.author_id = :author_id';
$params[':author_id'] = $authorId;
}
$sql .= ' ORDER BY rank';
$stmt = $this->db->prepare($sql);
$stmt->execute($params);
$rows = $stmt->fetchAll(PDO::FETCH_ASSOC);
return array_map(fn ($row) => Post::fromArray($row), $rows);
}
/**
* Construit une requête FTS5 sûre depuis la saisie utilisateur.
*
* Chaque mot est wrappé entre guillemets doubles (échappement interne
* des guillemets par doublement) et suivi d'un `*` pour la recherche
* par préfixe. Les mots sont joints par un espace (AND implicite FTS5).
*
* @param string $input La saisie brute de l'utilisateur
*
* @return string La requête FTS5 prête à l'emploi, ou '' si vide
*/
private function buildFtsQuery(string $input): string
{
$words = preg_split('/\s+/', trim($input), -1, PREG_SPLIT_NO_EMPTY) ?: [];
if (empty($words)) {
return '';
}
$terms = array_map(
fn ($w) => '"' . str_replace('"', '""', $w) . '"*',
$words
);
return implode(' ', $terms);
}
/**
* Vérifie si un slug est déjà utilisé par un autre article.
*
* @param string $slug Le slug à vérifier
* @param int|null $excludeId Identifiant à exclure de la vérification (pour les mises à jour)
*
* @return bool True si le slug est déjà pris par un autre article
*/
public function slugExists(string $slug, ?int $excludeId = null): bool
{
$stmt = $this->db->prepare('SELECT id FROM posts WHERE slug = :slug');
$stmt->execute([':slug' => $slug]);
$existingId = $stmt->fetchColumn();
if ($existingId === false) {
return false;
}
$existingId = (int) $existingId;
if ($excludeId !== null) {
return $existingId !== $excludeId;
}
return true;
}
}

113
src/Post/PostRepositoryInterface.php Normal file
View File

@@ -0,0 +1,113 @@
<?php
declare(strict_types=1);
namespace App\Post;
/**
* Contrat de persistance des articles.
*
* Découple PostService de l'implémentation concrète PDO/SQLite,
* facilitant les mocks dans les tests unitaires.
*/
interface PostRepositoryInterface
{
/**
* Retourne tous les articles triés du plus récent au plus ancien.
*
* @param int|null $categoryId Filtre optionnel par identifiant de catégorie
*
* @return Post[]
*/
public function findAll(?int $categoryId = null): array;
/**
* Retourne les N articles les plus récents (flux RSS).
*
* @param int $limit Nombre maximum d'articles à retourner
*
* @return Post[]
*/
public function findRecent(int $limit): array;
/**
* Retourne tous les articles d'un utilisateur donné.
*
* @param int $userId Identifiant de l'auteur
* @param int|null $categoryId Filtre optionnel par identifiant de catégorie
*
* @return Post[]
*/
public function findByUserId(int $userId, ?int $categoryId = null): array;
/**
* Trouve un article par son slug URL.
*
* @param string $slug Le slug URL de l'article
*
* @return Post|null L'article trouvé, ou null s'il n'existe pas
*/
public function findBySlug(string $slug): ?Post;
/**
* Trouve un article par son identifiant.
*
* @param int $id Identifiant de l'article
*
* @return Post|null L'article trouvé, ou null s'il n'existe pas
*/
public function findById(int $id): ?Post;
/**
* Persiste un nouvel article en base de données.
*
* @param Post $post L'article à créer
* @param string $slug Le slug unique généré pour cet article
* @param int $authorId Identifiant de l'auteur
* @param int|null $categoryId Identifiant de la catégorie (null si sans catégorie)
*
* @return int L'identifiant généré par la base de données
*/
public function create(Post $post, string $slug, int $authorId, ?int $categoryId): int;
/**
* Met à jour un article existant.
*
* @param int $id Identifiant de l'article à modifier
* @param Post $post L'article avec les nouvelles données
* @param string $slug Le nouveau slug unique
* @param int|null $categoryId Identifiant de la catégorie (null si sans catégorie)
*
* @return int Nombre de lignes affectées
*/
public function update(int $id, Post $post, string $slug, ?int $categoryId): int;
/**
* Supprime un article de la base de données.
*
* @param int $id Identifiant de l'article à supprimer
*
* @return int Nombre de lignes supprimées
*/
public function delete(int $id): int;
/**
* Recherche des articles en plein texte via FTS5.
*
* @param string $query La saisie utilisateur brute
* @param int|null $categoryId Filtre optionnel par identifiant de catégorie
* @param int|null $authorId Filtre optionnel par identifiant d'auteur
*
* @return Post[]
*/
public function search(string $query, ?int $categoryId = null, ?int $authorId = null): array;
/**
* Vérifie si un slug est déjà utilisé par un autre article.
*
* @param string $slug Le slug à vérifier
* @param int|null $excludeId Identifiant à exclure (mise à jour)
*
* @return bool True si le slug est déjà pris
*/
public function slugExists(string $slug, ?int $excludeId = null): bool;
}

252
src/Post/PostService.php Normal file
View File

@@ -0,0 +1,252 @@
<?php
declare(strict_types=1);
namespace App\Post;
use App\Shared\Exception\NotFoundException;
use App\Shared\Html\HtmlSanitizerInterface;
use App\Shared\Util\SlugHelper;
/**
* Service métier pour les articles.
*
* Centralise toute la logique qui ne relève ni du stockage (PostRepository)
* ni de la présentation (PostController / PostExtension) :
* - génération et unicité des slugs
* - sanitisation du contenu HTML à l'écriture
* - orchestration des opérations create / update / delete
*
* Flux de sanitisation :
* 1. L'utilisateur saisit du HTML via Trumbowyg
* 2. createPost() / updatePost() passent le contenu brut à HtmlSanitizerInterface
* 3. HtmlSanitizerInterface (implémentée par HtmlSanitizer) délègue à HTMLPurifier, configuré pour n'autoriser
* que les balises produites par Trumbowyg
* 4. Le contenu purifié est stocké en base — le filtre |raw dans Twig est sûr
*/
final class PostService implements PostServiceInterface
{
/**
* @param PostRepositoryInterface $postRepository Dépôt de persistance des articles
* @param HtmlSanitizerInterface $htmlSanitizer Service de sanitisation HTML
*/
public function __construct(
private readonly PostRepositoryInterface $postRepository,
private readonly HtmlSanitizerInterface $htmlSanitizer,
) {
}
/**
* Retourne tous les articles triés du plus récent au plus ancien.
*
* @param int|null $categoryId Filtre optionnel par identifiant de catégorie
*
* @return Post[]
*/
public function getAllPosts(?int $categoryId = null): array
{
return $this->postRepository->findAll($categoryId);
}
/**
* Retourne les N articles les plus récents pour le flux RSS.
*
* @param int $limit Nombre maximum d'articles à retourner (défaut : 20)
*
* @return Post[]
*/
public function getRecentPosts(int $limit = 20): array
{
return $this->postRepository->findRecent($limit);
}
/**
* Retourne tous les articles d'un utilisateur donné.
*
* @param int $userId Identifiant de l'auteur
* @param int|null $categoryId Filtre optionnel par identifiant de catégorie
*
* @return Post[]
*/
public function getPostsByUserId(int $userId, ?int $categoryId = null): array
{
return $this->postRepository->findByUserId($userId, $categoryId);
}
/**
* Retourne un article par son slug URL.
*
* @param string $slug Le slug URL de l'article
*
* @return Post L'article avec contenu sûr
*
* @throws NotFoundException Si aucun article ne correspond au slug
*/
public function getPostBySlug(string $slug): Post
{
$post = $this->postRepository->findBySlug($slug);
if ($post === null) {
throw new NotFoundException('Article', $slug);
}
return $post;
}
/**
* Retourne un article par son identifiant.
*
* @param int $id Identifiant de l'article
*
* @return Post L'article avec son contenu
*
* @throws NotFoundException Si aucun article ne correspond à cet identifiant
*/
public function getPostById(int $id): Post
{
$post = $this->postRepository->findById($id);
if ($post === null) {
throw new NotFoundException('Article', $id);
}
return $post;
}
/**
* Crée un nouvel article et retourne son identifiant.
*
* Un slug unique est généré à partir du titre. Si le slug existe déjà,
* un suffixe numérique est ajouté (ex: "mon-article-2").
* Le contenu HTML est sanitisé avant stockage.
*
* @param string $title Titre de l'article
* @param string $content Contenu HTML brut (sera sanitisé)
* @param int $authorId Identifiant de l'auteur
* @param int|null $categoryId Identifiant de la catégorie (null si sans catégorie)
*
* @return int L'identifiant de l'article créé
*
* @throws \InvalidArgumentException Si le titre ou le contenu sont invalides
*/
public function createPost(string $title, string $content, int $authorId, ?int $categoryId = null): int
{
$sanitizedContent = $this->htmlSanitizer->sanitize($content);
$post = new Post(0, $title, $sanitizedContent);
$slug = $this->generateUniqueSlug($post->generateSlug());
return $this->postRepository->create($post, $slug, $authorId, $categoryId);
}
/**
* Met à jour un article existant.
*
* Le slug est préservé par défaut. Si $newSlugInput est fourni et différent
* du slug actuel, il est nettoyé puis rendu unique avant d'être appliqué.
*
* @param int $id Identifiant de l'article à modifier
* @param string $title Nouveau titre
* @param string $content Nouveau contenu HTML brut (sera sanitisé)
* @param string $newSlugInput Nouveau slug souhaité (vide = conserver l'actuel)
* @param int|null $categoryId Identifiant de la catégorie (null si sans catégorie)
*
* @throws NotFoundException Si l'article n'existe plus
* @throws \InvalidArgumentException Si le titre ou le contenu sont invalides
* @return void
*/
public function updatePost(
int $id,
string $title,
string $content,
string $newSlugInput = '',
?int $categoryId = null,
): void {
$current = $this->postRepository->findById($id);
if ($current === null) {
throw new NotFoundException('Article', $id);
}
$sanitizedContent = $this->htmlSanitizer->sanitize($content);
$post = new Post($id, $title, $sanitizedContent);
$slugToUse = $current->getStoredSlug();
$newSlugInput = trim($newSlugInput);
$cleanSlugInput = $this->normalizeSlugInput($newSlugInput);
if ($cleanSlugInput !== '' && $cleanSlugInput !== $current->getStoredSlug()) {
$slugToUse = $this->generateUniqueSlug($cleanSlugInput, $id);
}
$affected = $this->postRepository->update($id, $post, $slugToUse, $categoryId);
if ($affected === 0) {
throw new NotFoundException('Article', $id);
}
}
/**
* Recherche des articles en plein texte via FTS5.
*
* @param string $query La saisie utilisateur brute
* @param int|null $categoryId Filtre optionnel par identifiant de catégorie
* @param int|null $authorId Filtre optionnel par identifiant d'auteur
*
* @return Post[]
*/
public function searchPosts(string $query, ?int $categoryId = null, ?int $authorId = null): array
{
return $this->postRepository->search($query, $categoryId, $authorId);
}
/**
* Supprime un article.
*
* @param int $id Identifiant de l'article à supprimer
*
* @throws NotFoundException Si l'article n'existe plus au moment de la suppression
*/
public function deletePost(int $id): void
{
$affected = $this->postRepository->delete($id);
if ($affected === 0) {
throw new NotFoundException('Article', $id);
}
}
/**
* Nettoie une saisie utilisateur pour en faire un slug valide.
*
* Délègue à SlugHelper::generate() — voir sa documentation pour le détail
* de l'algorithme.
*
* @param string $input La valeur brute saisie par l'utilisateur
*
* @return string Le slug nettoyé, ou '' si invalide
*/
private function normalizeSlugInput(string $input): string
{
return SlugHelper::generate($input);
}
/**
* Génère un slug unique en ajoutant un suffixe numérique si nécessaire.
*
* @param string $baseSlug Le slug de base généré depuis le titre
* @param int|null $excludeId Identifiant à exclure lors de la vérification (mise à jour)
*
* @return string Le slug garanti unique
*/
private function generateUniqueSlug(string $baseSlug, ?int $excludeId = null): string
{
$slug = $baseSlug;
$counter = 1;
while ($this->postRepository->slugExists($slug, $excludeId)) {
$slug = $baseSlug . '-' . $counter;
++$counter;
}
return $slug;
}
}

119
src/Post/PostServiceInterface.php Normal file
View File

@@ -0,0 +1,119 @@
<?php
declare(strict_types=1);
namespace App\Post;
use App\Shared\Exception\NotFoundException;
/**
* Contrat du service de gestion des articles.
*
* Permet de mocker le service dans les tests unitaires sans dépendre
* de la classe concrète finale PostService.
*/
interface PostServiceInterface
{
/**
* Retourne tous les articles publiés, avec un filtre optionnel par catégorie.
*
* @param int|null $categoryId Filtre optionnel par identifiant de catégorie
*
* @return Post[]
*/
public function getAllPosts(?int $categoryId = null): array;
/**
* Retourne les articles les plus récents.
*
* @param int $limit Nombre maximum d'articles à retourner (défaut : 20)
*
* @return Post[]
*/
public function getRecentPosts(int $limit = 20): array;
/**
* Retourne les articles d'un auteur donné.
*
* @param int $userId Identifiant de l'auteur
* @param int|null $categoryId Filtre optionnel par identifiant de catégorie
*
* @return Post[]
*/
public function getPostsByUserId(int $userId, ?int $categoryId = null): array;
/**
* Retourne un article par son slug URL.
*
* @param string $slug Le slug URL de l'article
*
* @return Post L'article avec contenu sûr
*
* @throws NotFoundException Si aucun article ne correspond au slug
*/
public function getPostBySlug(string $slug): Post;
/**
* Retourne un article par son identifiant.
*
* @param int $id Identifiant de l'article
*
* @return Post L'article avec son contenu
*
* @throws NotFoundException Si aucun article ne correspond à cet identifiant
*/
public function getPostById(int $id): Post;
/**
* Crée un nouvel article.
*
* @param string $title Titre de l'article
* @param string $content Contenu HTML brut (sera sanitisé)
* @param int $authorId Identifiant de l'auteur
* @param int|null $categoryId Identifiant de la catégorie (null si sans catégorie)
*
* @return int L'identifiant de l'article créé
*
* @throws \InvalidArgumentException Si le titre ou le contenu sont invalides
*/
public function createPost(string $title, string $content, int $authorId, ?int $categoryId = null): int;
/**
* Met à jour un article existant.
*
* @param int $id Identifiant de l'article à modifier
* @param string $title Nouveau titre
* @param string $content Nouveau contenu HTML brut (sera sanitisé)
* @param string $newSlugInput Nouveau slug souhaité (vide = conserver l'actuel)
* @param int|null $categoryId Identifiant de la catégorie (null si sans catégorie)
*
* @throws NotFoundException Si l'article n'existe plus
* @throws \InvalidArgumentException Si le titre ou le contenu sont invalides
*/
public function updatePost(
int $id,
string $title,
string $content,
string $newSlugInput = '',
?int $categoryId = null,
): void;
/**
* Recherche des articles par mots-clés dans le titre, le contenu et l'auteur.
*
* @param string $query La saisie utilisateur brute
* @param int|null $categoryId Filtre optionnel par identifiant de catégorie
* @param int|null $authorId Filtre optionnel par identifiant d'auteur
*
* @return Post[]
*/
public function searchPosts(string $query, ?int $categoryId = null, ?int $authorId = null): array;
/**
* Supprime un article.
*
* @param int $id Identifiant de l'article à supprimer
*
* @throws NotFoundException Si l'article n'existe plus au moment de la suppression
*/
public function deletePost(int $id): void;
}

94
src/Post/RssController.php Normal file
View File

@@ -0,0 +1,94 @@
<?php
declare(strict_types=1);
namespace App\Post;
use Psr\Http\Message\ResponseInterface as Response;
use Psr\Http\Message\ServerRequestInterface as Request;
/**
* Contrôleur du flux RSS.
*
* Expose un flux RSS 2.0 des 20 articles les plus récents à l'URL /rss.xml.
* Le contenu HTML des articles est strippé pour le champ <description> afin
* de produire un résumé texte brut compatible avec tous les lecteurs RSS.
*
* Pas de vue Twig — le XML est généré directement via SimpleXMLElement
* pour rester indépendant du moteur de templates.
*/
final class RssController
{
/**
* Nombre maximum d'articles inclus dans le flux RSS.
*/
private const FEED_LIMIT = 20;
/**
* @param PostServiceInterface $postService Service de récupération des articles
* @param string $appUrl URL de base de l'application (depuis APP_URL dans .env)
* @param string $appName Nom du blog affiché dans le flux
*/
public function __construct(
private readonly PostServiceInterface $postService,
private readonly string $appUrl,
private readonly string $appName,
) {
}
/**
* Génère et retourne le flux RSS 2.0.
*
* @param Request $req La requête HTTP
* @param Response $res La réponse HTTP
*
* @return Response Le flux RSS en XML (application/rss+xml; charset=utf-8)
*/
public function feed(Request $req, Response $res): Response
{
$posts = $this->postService->getRecentPosts(self::FEED_LIMIT);
$baseUrl = $this->appUrl;
$xml = new \SimpleXMLElement(
'<?xml version="1.0" encoding="UTF-8"?><rss version="2.0"></rss>'
);
$channel = $xml->addChild('channel');
$channel->addChild('title', htmlspecialchars($this->appName));
$channel->addChild('link', $baseUrl . '/');
$channel->addChild('description', htmlspecialchars($this->appName . ' — flux RSS'));
$channel->addChild('language', 'fr-FR');
$channel->addChild('lastBuildDate', (new \DateTime())->format(\DateTime::RSS));
foreach ($posts as $post) {
$item = $channel->addChild('item');
$item->addChild('title', htmlspecialchars($post->getTitle()));
$postUrl = $baseUrl . '/article/' . $post->getStoredSlug();
$item->addChild('link', $postUrl);
$item->addChild('guid', $postUrl);
// Extrait texte brut : strip_tags + truncature à 300 caractères
$excerpt = strip_tags($post->getContent());
$excerpt = mb_strlen($excerpt) > 300
? mb_substr($excerpt, 0, 300) . '…'
: $excerpt;
$item->addChild('description', htmlspecialchars($excerpt));
$item->addChild('pubDate', $post->getCreatedAt()->format(\DateTime::RSS));
if ($post->getAuthorUsername() !== null) {
$item->addChild('author', htmlspecialchars($post->getAuthorUsername()));
}
if ($post->getCategoryName() !== null) {
$item->addChild('category', htmlspecialchars($post->getCategoryName()));
}
}
$body = $xml->asXML();
$res->getBody()->write($body !== false ? $body : '');
return $res->withHeader('Content-Type', 'application/rss+xml; charset=utf-8');
}
}