Doctrine et la BdD

<?php

namespace App\Entity;

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

#[ORM\Entity(repositoryClass: TagRepository::class)]
class Tag
{
    #[ORM\Id]
    #[ORM\GeneratedValue]
    #[ORM\Column(type: "integer")]
    private $id;

    #[ORM\Column(type: "string", length: 128)]
    private $name;

    #[ORM\OneToMany(targetEntity: Article::class, mappedBy: "tag")]
    private $articles;

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

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

    public function getName(): ?string
    {
        return $this->name;
    }

    public function setName(string $name): self
    {
        $this->name = $name;

        return $this;
    }

    /**
     * @return Collection|Article[]
     */
    public function getArticles(): Collection
    {
        return $this->articles;
    }

    public function addArticle(Article $article): self
    {
        if (!$this->articles->contains($article)) {
            $this->articles[] = $article;
            $article->setTag($this);
        }

        return $this;
    }

    public function removeArticle(Article $article): self
    {
        if ($this->articles->removeElement($article)) {
            // set the owning side to null (unless already changed)
            if ($article->getTag() === $this) {
                $article->setTag(null);
            }
        }

        return $this;
    }
}

<?php

namespace App\Entity;

use App\Repository\ArticleRepository;
use Doctrine\ORM\Mapping as ORM;

#[ORM\Entity(repositoryClass: ArticleRepository::class)]
class Article
{
    #[ORM\Id]
    #[ORM\GeneratedValue]
    #[ORM\Column(type: "integer")]
    private $id;

    #[ORM\Column(type: "string", length: 255)]
    private $title;

    #[ORM\Column(type: "text")]
    private $content;

    #[ORM\ManyToOne(targetEntity: Tag::class, inversedBy: "articles")]
    #[ORM\JoinColumn(nullable: false)]
    private $tag;


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

    public function getTitle(): ?string
    {
        return $this->title;
    }

    public function setTitle(string $title): self
    {
        $this->title = $title;

        return $this;
    }

    public function getContent(): ?string
    {
        return $this->content;
    }

    public function setContent(string $content): self
    {
        $this->content = $content;

        return $this;
    }

    public function getTag(): ?Tag
    {
        return $this->tag;
    }

    public function setTag(?Tag $tag): self
    {
        $this->tag = $tag;

        return $this;
    }
}

use Doctrine\ORM;

#[ORM\MappedSuperclass]
class Person
{
    #[ORM\Column(type: "integer")]
    protected $mapped1;
    #[ORM\Column(type: "string")]
    protected $mapped2;

    // ...
}

#[ORM\Entity]
class Employee extends Person
{
    #[ORM\Id] 
    #[ORM\Column(type: "integer")] 
    private $id;
    
    #[ORM\Column(type: "string")]
    private $name;

    // ...
}

#[ORM\Entity]
#[ORM\InheritanceType("SINGLE_TABLE")]
#[ORM\DiscriminatorColumn(name: "discr", type: "string")]
#[ORM\DiscriminatorMap(["person" => "Person", "employee" => "Employee"])]
class Person
{
    // ...
}

#[ORM\Entity]
class Employee extends Person
{
    // ...
}

#[ORM\Entity]
#[ORM\InheritanceType("JOINED")]
#[ORM\DiscriminatorColumn(name: "discr", type: "string")]
#[ORM\DiscriminatorMap(["person" => "Person", "employee" => "Employee"])]
class Person
{
    // ...
}

#[ORM\Entity]
class Employee extends Person
{
    // ...
}

<?php

declare(strict_types=1);

namespace DoctrineMigrations;

use Doctrine\DBAL\Schema\Schema;
use Doctrine\Migrations\AbstractMigration;

/**
 * Auto-generated Migration: Please modify to your needs!
 */
final class Version20210226082708 extends AbstractMigration
{
    public function getDescription() : string
    {
        return '';
    }

    public function up(Schema $schema) : void
    {
        // this up() migration is auto-generated, please modify it to your needs
        $this->addSql('CREATE TABLE article (id INT AUTO_INCREMENT NOT NULL, tag_id INT NOT NULL, title VARCHAR(255) NOT NULL, content LONGTEXT NOT NULL, INDEX IDX_23A0E66BAD26311 (tag_id), PRIMARY KEY(id)) DEFAULT CHARACTER SET utf8mb4 COLLATE `utf8mb4_unicode_ci` ENGINE = InnoDB');
        $this->addSql('CREATE TABLE tag (id INT AUTO_INCREMENT NOT NULL, name VARCHAR(128) NOT NULL, PRIMARY KEY(id)) DEFAULT CHARACTER SET utf8mb4 COLLATE `utf8mb4_unicode_ci` ENGINE = InnoDB');
        $this->addSql('ALTER TABLE article ADD CONSTRAINT FK_23A0E66BAD26311 FOREIGN KEY (tag_id) REFERENCES tag (id)');
    }

    public function down(Schema $schema) : void
    {
        // this down() migration is auto-generated, please modify it to your needs
        $this->addSql('ALTER TABLE article DROP FOREIGN KEY FK_23A0E66BAD26311');
        $this->addSql('DROP TABLE article');
        $this->addSql('DROP TABLE tag');
    }
}

<?php

namespace App\Controller;

use App\Entity\Article;
use App\Entity\Tag;
use Doctrine\ORM\EntityManagerInterface;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\Annotation\Route;

#[Route("/blog", name: "blog_"]
class BlogController extends AbstractController
{
    // ...

    #[Route("/fixtures", name: "fixtures"]
    public function fixtures(EntityManagerInterface $entityManager): Response
    {
        // On crée un objet Tag (nous n'en avons actuellement aucun)
        $tag = new Tag();
        $tag->setName('animaux');

        // On crée un premier article et on donne des valeurs à ses différents champs
        $article = new Article();
        $article->setTitle('Les animaux fantastiques');
        $article->setContent('Un contenu fabuleux pour un article fantastique');
        // Ici, on fait le lien entre notre article et le tag que nous avons défini plus haut.
        // Doctrine se chargera de retranscrire ce lien dans la BdD.
        // Dans les faits, il mettra l'id de notre tag dans la colonne tag_id de notre article.
        $article->setTag($tag);

        // Ici, on dit à l'entity manager qu'il devra sauvegarder nos deux entités. Vous pouvez voir ce persist que le add de Git
        // Noter qu'il faut appeler la méthode persist sur chacun de nos objets
        // Il est possible de ne le faire qu'une fois, mais c'est une astuce que vous verrez plus tard ;)
        $entityManager->persist($tag);
        $entityManager->persist($article);

        // Noter que les entrées n'existent pas encore en base.
        // Elles n'existent qu'une fois que nous appelons la méthode flush de l'entity manager.
        // Vous pouvez voir la méthode persist comme le commit de Git.
        $entityManager->flush();

        // Ici, j'ai choisi de rediriger vers l'accueil du blog
        return $this->redirectToRoute('blog_index');
    }
}

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

    #[Route("/{id}", name: "show")]
    public function show(Article $article): Response
    {
        return $this->render('blog/show.html.twig', [
            'article' => $article,
        ]);
    }

    /**
     * On récupère le paramètre title de notre route
     * et on injecte le repository dont nous allons avoir besoin.
     * 
     * Noter que l'on aurait pu utiliser le ParamConverter de Doctrine pour récupérer plus simplement l'article par son titre
     */
    #[Route("/{title}", name: "blog_show")]
    public function show(string $title, ArticleRepository $repository): Response
    {
        // On récupère plusieurs articles
        $article = $repository->findOneBy([
            // On passe un tableau de critères, ne contenant qu'une entrée :
            // on cherche dans la colonne title de la table, avec la valeur $title
            // Ce qui revient à faire en SQL : WHERE title = '$title'
            'title' => $title,
        ]
        );
        return $this->render('blog/index.html.twig', [
            'article' => $article,
        ]);
    }

    /**
     * On récupère le paramètre title de notre route
     * et on injecte le repository dont nous allons avoir besoin.
     * 
     * Noter que l'on aurait pu utiliser le ParamConverter de Doctrine pour récupérer plus simplement l'article par son titre
     */
    #[Route("/{tag}", name: "blog_index")]
    public function index(string $tag, ArticleRepository $repository): Response
    {
        // On récupère plusieurs articles
        $articles = $repository->findBy([
            // On passe un tableau de critères, ne contenant qu'une entrée :
            // on cherche dans la colonne tag de la table, avec la valeur $tag
            // Ce qui revient à faire en SQL : WHERE tag = '$tag'
            'tag' => $tag,  
        ], [
            // On précise comment trier les résultats
            // Ce qui revient à faire en SQL : ORDER BY id DESC
            'id' => 'DESC',
        ],
        5, // On veut récupérer 5 résultats maximum
        0 // On commence au premier enregistrement, nous avons donc l'équivalent de LIMIT 0,5
        );
        return $this->render('blog/index.html.twig', [
            'articles' => $articles,
        ]);
    }

    public function findByExampleField($value)
    {
        // On crée un objet QueryBuilder, en mettant "a" comme alias de notre table article
        return $this->createQueryBuilder('a') 
            // On ajoute un WHERE, avec un paramètre ":val"
            // (voir le cours sur PDO et les paramètres nommés)
            ->andWhere('a.exampleField = :val') 
            // On donne une valeur au paramètre. 
            ->setParameter('val', $value) 
            // On trie nos éléments par "id" croissant
            ->orderBy('a.id', 'ASC')
            // On ne veut que 10 résultats maximum 
            ->setMaxResults(10) 
            // On récupère la requête générée, qui va correspondre à quelque chose comme
            // "SELECT * FROM article a WHERE a.exampleField = '$value' ORDER BY a.id LIMIT 10"
            ->getQuery() 
            // On exécute la requête et on récupère les résultats.
            // On les retourne sous la forme d'un tableau (qui contient des objets Article)
            ->getResult() 
        ;
    }

    // On ajoute un paramètre $inverseOrder : s'il vaut true, nous allons trier par ordre décroissant
    public function findByExampleField($value, $inverseOrder = false)
    {
        // On crée un objet QueryBuilder, en mettant "a" comme alias de notre table article
        $qb = $this->createQueryBuilder('a')
            // On ajoute un WHERE, avec un paramètre ":val" (voir le cours sur PDO et les paramètres nommés)
            ->andWhere('a.exampleField = :val')
            // On donne une valeur au paramètre. 
            ->setParameter('val', $value)
            // On ne veut que 10 résultats maximum
            ->setMaxResults(10)
        ;
        if ($inverseOrder === true) {
            // On tri nos éléments par "id" décroissant
            $qb->orderBy('a.id', 'DESC');
        } else {
            // On tri nos éléments par "id" croissant
            $qb->orderBy('a.id', 'ASC');
        }
        return $qb
            // On récupère la requête générée, qui va correspondre à quelque chose comme
            // "SELECT * FROM article a WHERE a.exampleField = '$value' ORDER BY a.id LIMIT 10"
            ->getQuery()
            // On exécute la requête et on récupère les résultats.
            // On les retourne sous la forme d'un tableau (qui contient des objets Article)
            ->getResult()
        ;
    }

    public function search(string $text)
    {
        // On crée un objet QueryBuilder, en mettant "a" comme alias de notre table article
        return $this->createQueryBuilder('a') 
            // Ici, on suit les propriétés de notre entité :
            // on demande à Doctrine une jointure sur la propriété tag de notre article
            // (il se débrouille ensuite pour faire la correspondance par id),
            // et on lui dit de l'appeler t dans la suite de la requête
            ->join('a.tag', 't') 
            // On ajoute un WHERE, avec un paramètre ":val"
            // (voir le cours sur PDO et les paramètres nommés)
            ->where('a.content LIKE :val') 
            ->orWhere('a.title LIKE :val')
            // On peut ensuite utiliser notre table t (les tags) pour regarder le champ name
            ->orWhere('t.name LIKE :val')
            // On donne une valeur au paramètre.
            ->setParameter('val', '%'.$text.'%') 
            // On récupère la requête générée
            ->getQuery()
            // On exécute la requête et on récupère les résultats.
            // On les retourne sous la forme d'un tableau (qui contient des objets Article)
            ->getResult() 
        ;
    }

// src/Controller/BlogController.php
namespace App\Controller;

use App\Repository\ArticleRepository;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\Annotation\Route;

class BlogController extends AbstractController 
{
    #[Route("/blog/search/{text}", name: "blog_search")]
    public function search(ArticleRepository $repo, string $text): Response
    {
        $articles = $repo->search($text);
        // Cette fonction va afficher la variable $articles et son contenu
        // (un peu comme un var_dump(), mais en plus beau et plus pratique) dans le profiler de Symfony
        dump($articles); 
        // Cette fonction va afficher la variable $articles et son contenu,
        // mais aussi arrêter le programme (dump and die) (comme un exit(var_dump()))
        dd($articles); 
        
        return $this->render('blog/search.html.twig', [
            'results' => $articles,
        ]);
    }
    
    // ...
}

<?php

namespace App\DataFixtures;

use App\Entity\Tag;
use Doctrine\Bundle\FixturesBundle\Fixture;
use Doctrine\Persistence\ObjectManager;

class TagFixtures extends Fixture
{
    /**
     * @inheritDoc
     */
    public function load(ObjectManager $manager)
    {
        // C'est dans cette méthode que nous allons créer nos données
        // et les sauvegarder avec l'ObjetManager (un parent de EntityManager)
        
        // Je veux utiliser des noms de tags qui sonnent un peu réels
        // Même si j'utilise des mots au hasard
        $tagNames = [
            'informatiques',
            'chiens',
            'navigateurs',
            'statistiques',
            'promenades',
            'archerie',
        ];
        
        foreach ($tagNames as $tagName) {
            // Je crée des objets tags et les remplie
            // avant d'en demander l'enregistrement à l'ObjectManager
            $tag = new Tag();
            $tag->setName($tagName);
            
            $manager->persist($tag);
        }

        // On sauvegarde effectivement tout en base
        $manager->flush();
    }
}

<?php

namespace App\DataFixtures;

use App\Entity\Article;
use App\Repository\TagRepository;
use Doctrine\Bundle\FixturesBundle\Fixture;
use Doctrine\Common\DataFixtures\DependentFixtureInterface;
use Doctrine\Persistence\ObjectManager;

// Implémenter DependentFixtureInterface permet au bundle de savoir
// qu'il va devoir charger d'autres fixtures avant, ce qui va définir 
// un ordre de priorité
class TagFixtures extends Fixture implements DependentFixtureInterface
{
    /**
     * @var TagRepository 
     */
    protected $tagRepository;
    
    // Ici, on va se servir des tags qu'on a déjà inséré en base (pas obligatoire ;) )
    public function __construct(TagRepository $tagRepository)
    {
        $this->tagRepository = $tagRepository;
    }
    /**
     * @inheritDoc
     */
    public function load(ObjectManager $manager)
    {
        // C'est dans cette méthode que nous allons créer nos données
        // et les sauvegarder avec l'ObjetManager (un parent de EntityManager)
        
        // Les titres et contenus des articles va être identiques, on les prépare avant la boucle
        
        $title = ' : Neque porro quisquam est qui dolorem ipsum quia dolor sit amet, consectetur, adipisci velit...';
        $content = "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Fusce luctus neque justo, id vulputate velit malesuada in. Donec vulputate ipsum vitae orci vestibulum, et tempus orci hendrerit. Vestibulum mattis sit amet eros sodales accumsan. Proin auctor tellus vitae hendrerit viverra. Aliquam erat volutpat. Duis suscipit lacus tortor, non hendrerit sapien dapibus vel. Phasellus urna orci, porta vel arcu vitae, posuere efficitur diam. Phasellus convallis ante enim, a lobortis tortor fermentum et. Aenean hendrerit congue nulla quis interdum. Nullam quis magna sem. Duis quis pulvinar ante, ac posuere velit.";
        
        
        // Pour les utiliser dans les articles, on récupère la liste complète de nos tags
        $tags = $this->tagRepository->findAll();
        
        // On crée une dizaine d'articles
        for ($i = 0; $i < 10; $i++) {
            $article = new Article();
            $article->setTitle($i.$title);
            $article->setContent($content);
            
            // On récupère un tag aléatoire dans la liste $tags, qu'on va associer à notre article
            $randomNumber = mt_rand(0, count($tags) - 1);
            $article->setTag($tags[$randomNumber]);// Si $randomNumber contient 0, on récupère notre 1er tag
            
            // On prépare l'article à l'insertion en base
            $manager->persist($article);
        }

        // On sauvegarde effectivement tout en base
        $manager->flush();
    }

    // Cette méthode sert à dire au bundle quelles fixtures
    // doivent être appliquées avant celles-ci
    public function getDependencies()
    {
        return [
            TagFixtures::class,
        ];
    }
}