Symfony 6: ORM Doctrine

# IMPORTANT: Vous devez configurer votre version de serveur ici ou dans onfig/packages/doctrine.yaml
DATABASE_URL="mysql://username:password@127.0.0.1:3306/basededonnees?serverVersion=8.0.32&charset=utf8mb4"

php bin/console doctrine:database:create

symfony console doctrine:database:create

composer require --dev symfony/maker-bundle

php bin/console make:migration

php bin/console doctrine:migrations:migrate

<?php
// src/Repository/FilmRepository.php

class FilmRepository extends ServiceEntityRepository {

  // ... Code précédent

  // 1. Méthode pour ajouter une Film dans la base de donnée
  public function save(Film $nouveauFilm, ?bool $flush = false) {

    // 1.1. Persiste l'entité Film dans le gestionnaire d'entités (Doctrine)
    $this->getEntityManager()->persist($nouveauFilm);

    // 1.2. Tester si nous devons executer la transaction
    if($flush){
      // 1.2.2. Effectue les opérations de base de données (INSERT/UPDATE)
      $this->getEntityManager()->flush();
    }

    // 1.3. Retourner l'instance du nouveau film 
    return $nouveauFilm;
  }
}

<?php
// /src/Controller/FilmController.php

namespace App\Controller;

use App\Entity\Film;
use App\Repository\FilmRepository;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\Annotation\Route;

class FilmController extends AbstractController {

  // 1. Route associé a l'url '/films' pour ajouter un film
  #[Route('/films', name: 'films.ajout', methods: ['POST'])]
  // 2. Action pour ajouter une film dans la base données en utilisant le repository
  function ajout(Request $req, FilmRepository $repository) {

    // 2.1 Vérifier si le corps de la requête est vide ou si la clé titre n'existe pas
    if (!$req->getContent() || !$req->getPayload()->has('titre')) {
      return $this->json(
        ['erreur' => 'Il manque le titre!'],
        Response::HTTP_BAD_REQUEST
      );
    }

    // 2.2. Récuperer les données du corps de la requête
    $titre = $req->getPayload()->get('titre');

    // 2.3. Créer une instance de l'entité et la peupler
    $film = (new Film())->setTitre($titre);

    // 2.5 utiliser le repository pour enregistrer le nouveau film dans la base de données
    $nouveauFilm = $repository->save($film, true);

    return $this->json(
      ['film' => $nouveauFilm->getTitre() . ' ajouté. ID: ' . $nouveauFilm->getId()],
    );
  }
}

// Code précédent...

// 1. Route dynamique avec paramètre id pour récuperer un film
#[Route('/films/{id}', name: 'films.film', methods: ['GET'])]
function getById(FilmRepository $repository, int $id): Response {
    
  // 2. Récupérer une entité Film avec son identifiant
  $film = $repository->find($id);

  // 3. Vérifier si elle n'existe pas
  if (!$film) {
    return $this->json(
      ['erreur' => 'Film introuvable'], 
      Response::HTTP_NOT_FOUND);
  }

  // 4. Retourner le film en tableau associatifs
  return $this->json(
    ['film' => ['id' => $film->getId(), 'titre' => $film->getTitre()]]
  );
}

findOneBy(['propriété1' => 'critère1', 'propriété2' => 'critère2']) : Entity

findBy(['propriété1' => 'critère1', 'propriété2' => 'critère2']): Entity[]

// Code précédent...

//1. Route dynamique pour récuperer un film avec son titre acceptant les methode HTTP GET
#[Route('/films/titre/{titre}', name: 'films.film.titre', methods: ['GET'])]
function getByTitre(Request $req, FilmRepository $repository, string $titre): Response {
  
  // 2. Récupérer une entité Film avec son titre
  $film = $repository->findOneBy(['titre' => $titre]);

  // 3. Vérifier si elle n'existe pas
  if (!$film) {
    return $this->json(
      ['erreur' => 'Film introuvable'], 
      Response::HTTP_NOT_FOUND
    );
  }

  // 4. renvoyer une réponse JSON contenant les id et titre du film.
  return $this->json(
    ['film' => ['id' => $film->getId(), 'titre' => $film->getTitre()]],
  );
}

// Code précédent...

// Route Dynamique pour mettre à jour le titre d'un film
#[Route('/films/{id}', name: 'films.update.titre', methods: ['PUT'])]
function updateTitre(Request $req, FilmRepository $repository, int $id): Response {
    
  // 2. Tester et Retourner une erreur si le  corps est vide ou pas de clé titre
  if (!$req->getContent() || !$req->getPayload()->has('titre')) {
    return $this->json(['erreur' => 'Titre obligatoire'], Response::HTTP_NOT_FOUND);
  }

  // 3. Récupérer une entité Film avec son identifiant
  $film = $repository->find($id);

  // 4. Retourner une erreur si le film n'existe pas
  if (!$film) {
    return $this->json(['erreur' => 'Film introuvable'], Response::HTTP_NOT_FOUND);
  }

  // 5. Mettre à jour le titre
  $film->setTitre($req->getPayload()->get('titre'));
  
  // 5. Effectuer une sauvegarde
  $filmAjour = $repository->save($film);

  // 6. Retourner le film mis à jour
  return $this->json(
    ['film' => [
      'id' => $filmAjour->getId(), 
      'titre' => $filmAjour->getTitre()
    ]],
  );
}

<?php
// src/Repository/FilmRepository.php

class FilmRepository extends ServiceEntityRepository {

  // ... Code précédent

  // 1. Méthode pour supprimer une Film dans la base de donnée
  public function remove(Film $film) : void {

    // 1.1. AJouter la suppression de l'entité Filmpour la prochaine transaction
    $this->getEntityManager()->remove($film);

    // 1.2. Effectue les opérations de base de données (DELETE) pour supprimer le film
    $this->getEntityManager()->flush();
  }
}

// Code précédent...

#[Route('/films/{id}', name: 'films.supprimer', methods: ['DELETE'])]
function supprimer(Request $req, FilmRepository $repository, int $id): Response {
    
  // 1. Récupérer une entité Film avec son identifiant
  $film = $repository->find($id);

  // 2. Retourner une erreur si le film n'existe pas
  if (!$film) {
    return $this->json(['erreur' => 'Film introuvable'], Response::HTTP_NOT_FOUND);
  }

  // 3. Supprimer le film
  $statusSuppression = $repository->supprimer($film);

  // 4. Retourner un message de réussite
  return $this->json(
    ['message' => 'Le film ' . $film->getTitre() . ' est supprimé'],
    Response::HTTP_OK
  );
}

<?php
// /src/Entity/Commentaire.php

namespace App\Entity;

use App\Repository\CommentaireRepository;
use App\Entity\Film;
use Doctrine\ORM\Mapping as ORM;

#[ORM\Entity(repositoryClass: CommentaireRepository::class)]
class Commentaire {
  #[ORM\Id]
  #[ORM\GeneratedValue]
  #[ORM\Column]
  private ?int $id = null;

  #[ORM\Column(length: 255)]
  private ?string $auteur = null;

  #[ORM\Column(type: "text")]
  private ?string $message = null;

  #[ORM\Column(type: "date")]
  private ?string $date = null;

  #[ORM\ManyToOne(targetEntity: Film::class, inversedBy: 'commentaires')]
  private $film;

  public function getId(): ?int {
    return $this->id;
  }

  public function getAuteur(): ?string {
    return $this->auteur;
  }

  public function setAuteur(string $auteur): static {
    $this->auteur = $auteur;

    return $this;
  }
  public function getMessage(): ?string {
    return $this->message;
  }

  public function setMessage(string $message): static {
    $this->message = $message;

    return $this;
  }
  public function getDate(): ?string {
    return $this->date;
  }

  public function setDate(string $date): static {
    $this->date = $date;

    return $this;
  }

  public function getFilm(): ?Film {
    return $this->film;
  }

  public function setFilm(?Film $film): self {
    $this->film = $film;

    return $this;
  }
}

// src/Entity/Film.php

use App\Repository\FilmRepository;
use Doctrine\Common\Collections\ArrayCollection;
use Doctrine\Common\Collections\Collection;
use Doctrine\ORM\Mapping as ORM;

/**
 * @ORM\Entity
 */
class Film
{
  // Code précédent...

  #[ORM\OneToMany(
    targetEntity:"App\Entity\Commentaire", 
    mappedBy:"film", 
    cascade:['persist']
  )]
  private $commentaires;

  public function __construct()
  {
      $this->commentaires = new ArrayCollection();
  }

  // Méthode pour récuperer la liste des commentaires
  public function getCommentaires(): Collection
  {
    return $this->commentaires;
  }
  
  // Méthode pour ajouter un commentaire
  public function addCommentaire(Commentaire $commentaire): Collection {
    // Permet d'enregistrer le commentaire en enregistrant le film
    $commentaire->setFilm($this);

    // Ajouter le commentaire à la liste
    $this->commentaires->add($commentaire);

    return $this->commentaires;
  }
}

// /src/Controller/FilmController.php

// Code précédent ...

#[Route('/films/{id}/commentaires', name: 'film.commentaires.add', methods: ['POST'])]
public function ajouterCommentaire(
  Request $req,
  FilmRepository $repository,
  int $id
): Response {

  // 1. Il faut verifier si les clés auteur, message sont réçues dans le corps de la requete
  if (
    !$req->getContent() ||
    !$req->getPayload()->has('auteur') ||
    !$req->getPayload()->has('message')
  ) {
    return $this->json(
      ['erreur' => 'Veuillez fournir l\'auteur et le message!'],
      Response::HTTP_BAD_REQUEST
    );
  }

  // 2. Récuperer le film avec son id
  $film = $repository->find($id);

  // 3. Si le film n'exsite pas
  if (!$film) {
    return $this->json(
      ['erreur' => 'Film introuvable'],
      Response::HTTP_NOT_FOUND
    );
  }

  // 4. Recuperer les données du corps de la requête
  $auteur = $req->getPayload()->get('auteur');
  $message = $req->getPayload()->get('message');
  $date = date_create();

  // 5. Instancier et populer le commentaire avec les donnée réçues
  $commentaire = (new Commentaire())
    ->setAuteur($auteur)
    ->setMessage($message)
    ->setDate($date)
    ->setFilm($film);

  // 6. Ajouter le commentaire dans le film
  $film->addCommentaire($commentaire);

  // 7. Enregistrer le film et le commentaire grâce au cascade: persist
  $repository->save($film);

  return $this->json(['message' => 'Ajout du commentaire réussi!']);
}

// /src/Controller/FilmController.php

// Code précédent ...

// Récuperer tous les commentaire d'un film
#[Route('/films/{id}/commentaires', name: 'film.get.commentaires', methods: ['GET'])]
public function getCommentaires(
  FilmRepository $repository,
  int $id
): Response {

  // Récuperer le film avec son id
  $film = $repository->find($id);

  // Si le film n'exsite pas
  if (!$film) {
    return $this->json(
      ['erreur' => 'Film introuvable'],
      Response::HTTP_NOT_FOUND
    );
  }

  // récuperer les commentaires automatiquement
  $commentaires = $film->getCommentaires();

  // Les transformer en un tableau associatif
  $commantairesJson = [];
  foreach ($commentaires as $c) {
    $commantairesJson[] = [
      'id' => $c->getId(),
      'auteur' => $c->getAuteur(),
      'message' => $c->getMessage()
    ];
  }

  return $this->json(['film' => $film->getTitre(), 'commentaires' => $commantairesJson]);
}