On a laissé deux problèmes en suspens : les chemins des fichiers ne sont pas enregistrés, et les livres supprimés laissent leurs fichiers sur le disque. Il y a aussi un bug caché dans notre système de dossiers « année_mois ». Ce chapitre règle les trois.

Le bug caché de notre système de chemins

Au chapitre 9, on a calculé le dossier d’upload à partir de la date du jour, directement dans configureFields() :

$path = $now->format('Y') . '_' . $now->format('m');

Ça marche pour l’upload, mais on l’a aussi utilisé pour afficher les fichiers. Résultat : en septembre, l’application cherche les fichiers d’août dans le dossier 2026_09… et ne les trouve pas. Change le mois à la main pour simuler : la couverture disparaît, et le lien du PDF est cassé.

La solution : enregistrer en base le chemin de chaque fichier au moment de l’upload (bookFilePath, coverImagePath), et s’en servir pour l’afficher.

Le plan

AbstractCrudController permet de surcharger ce qui se passe quand une entité est enregistrée :

MéthodeQuandCe qu’on fait
persistEntity()CréationRemplir les deux chemins
updateEntity()ModificationSi un fichier a changé, supprimer l’ancien et enregistrer le nouveau chemin
deleteEntity()SuppressionSupprimer le PDF et l’image du disque

Récupérer le dossier du projet

Pour supprimer des fichiers, il nous faut leur chemin absolu. On injecte donc le paramètre kernel.project_dir dans le constructeur :

public function __construct(
    #[Autowire(param: 'kernel.project_dir')]
    private readonly string $projectDir,
) {}

Deux petites méthodes utilitaires

private function currentUploadPath(): string
{
    $now = new \DateTimeImmutable();

    return $now->format('Y') . '_' . $now->format('m');
}

private function resolveFilePath(string $subDir, ?string $path, ?string $fileName): ?string
{
    if (!$path || !$fileName) {
        return null;
    }

    return $this->projectDir . '/public/uploads/' . $subDir . '/' . $path . '/' . $fileName;
}

Création : persistEntity()

public function persistEntity(EntityManagerInterface $entityManager, object $entityInstance): void
{
    if ($entityInstance instanceof Book) {
        $path = $this->currentUploadPath();
        if ($entityInstance->getBookFileName()) {
            $entityInstance->setBookFilePath($path);
        }
        if ($entityInstance->getCoverImageName()) {
            $entityInstance->setCoverImagePath($path);
        }
    }

    $entityManager->persist($entityInstance);
    $entityManager->flush();
}

Modification : updateEntity()

L’Unit of Work de Doctrine nous donne les valeurs d’origine de l’entité, ce qui permet de savoir quels fichiers ont changé :

public function updateEntity(EntityManagerInterface $entityManager, object $entityInstance): void
{
    $filesToDelete = [];

    if ($entityInstance instanceof Book) {
        $original = $entityManager->getUnitOfWork()->getOriginalEntityData($entityInstance);
        $path = $this->currentUploadPath();

        if (($original['bookFileName'] ?? null) !== $entityInstance->getBookFileName()) {
            $filesToDelete[] = $this->resolveFilePath('books/files', $original['bookFilePath'] ?? null, $original['bookFileName'] ?? null);
            $entityInstance->setBookFilePath($path);
        }
        if (($original['coverImageName'] ?? null) !== $entityInstance->getCoverImageName()) {
            $filesToDelete[] = $this->resolveFilePath('books/images', $original['coverImagePath'] ?? null, $original['coverImageName'] ?? null);
            $entityInstance->setCoverImagePath($path);
        }

        $filesToDelete = array_filter($filesToDelete);
    }

    $entityManager->persist($entityInstance);
    $entityManager->flush();

    foreach ($filesToDelete as $file) {
        if (is_file($file)) {
            @unlink($file);
        }
    }
}

Les anciens fichiers ne sont supprimés qu’après un flush() réussi : un enregistrement raté ne fait donc jamais perdre de données.

Suppression : deleteEntity()

public function deleteEntity(EntityManagerInterface $entityManager, object $entityInstance): void
{
    $filesToDelete = [];
    if ($entityInstance instanceof Book) {
        $filesToDelete = array_filter([
            $this->resolveFilePath('books/files', $entityInstance->getBookFilePath(), $entityInstance->getBookFileName()),
            $this->resolveFilePath('books/images', $entityInstance->getCoverImagePath(), $entityInstance->getCoverImageName()),
        ]);
    }

    $entityManager->remove($entityInstance);
    $entityManager->flush();

    foreach ($filesToDelete as $file) {
        if (is_file($file)) {
            @unlink($file);
        }
    }
}

Afficher avec les chemins enregistrés

Le lien « Voir le PDF » utilise maintenant getBookFilePath() au lieu du chemin calculé :

TextField::new('bookFileName', 'Livre')
    ->renderAsHtml()
    ->hideOnForm()
    ->formatValue(function ($value, $entity) {
        if (!$value) return '';
        return sprintf(
            '<a href="/uploads/books/files/%s/%s" target="_blank">📄 Voir le PDF</a>',
            $entity->getBookFilePath(),
            $value
        );
    }),

Pour la couverture, on garde l’ImageField, mais on construit nous-mêmes la miniature avec formatValue(). Comme on renvoie notre propre HTML, le template du champ doit passer de crud/field/image à crud/field/text. On garde la lightbox d’EasyAdmin : cliquer sur la miniature affiche toujours l’image en grand.

ImageField::new('coverImageName', 'Couverture')
    // ... mêmes options d'upload qu'avant ...
    ->setTemplateName('crud/field/text')
    ->formatValue(function ($value, $entity) {
        if (!$value) return '';
        $url = sprintf('/uploads/books/images/%s/%s', $entity->getCoverImagePath(), $value);
        $lightboxId = 'ea-lightbox-cover-' . $entity->getId();
        return sprintf(
            '<a href="#" class="ea-lightbox-thumbnail" data-ea-lightbox-content-selector="#%s">
                <img src="%s" class="img-fluid">
            </a>
            <div id="%s" class="ea-lightbox"><img src="%s"></div>',
            $lightboxId, $url, $lightboxId, $url
        );
    }),

Le test

  • Affichage : la couverture et le PDF s’affichent correctement.
  • Suppression : l’image et le PDF sont supprimés de public/uploads/.
  • Modification avec de nouveaux fichiers : seuls les nouveaux fichiers restent sur le disque.

Un défi pour toi

Modifie un livre, change seulement le titre, et enregistre. EasyAdmin se plaint que les champs de fichiers sont vides : sur la page de modification, ils ne savent pas que le fichier existe déjà, et ils sont marqués comme obligatoires. Réfléchis à une solution : la réponse est au prochain chapitre.

Exercice · Pourquoi après le flush ?

Dans updateEntity() et deleteEntity(), on supprime les fichiers après flush(), jamais avant. Que se passerait-il dans l’ordre inverse si l’enregistrement en base échouait ?

Voir la solution

Les fichiers seraient déjà supprimés, mais la base contiendrait toujours le livre avec ses anciens chemins. Résultat : un livre qui pointe vers un PDF et une couverture qui n’existent plus, sans aucun moyen de les récupérer.

En supprimant après un flush() réussi, le pire cas est un fichier orphelin sur le disque : un peu d’espace perdu, mais aucune donnée cassée.


Ceci est le chapitre 11 du cours Mini Bibliothèque. Suis la série pour construire de zéro une application complète de bibliothèque numérique avec Symfony 8 et EasyAdmin.