TP n°2 - Manipuler les données avec Doctrine
Programmer en PHP des modifications dans la base de données

Sur le modèle des portions de code précédentes, ajoutez une commande app:add-tag prenant en entrée deux arguments :

1. Utilisez make:command à nouveau pour générer le squelette de code dans src/Command/AddTagCommand.php

2. Adaptez ce squelette de base de la commande, pour qu’elle recoive deux arguments, et pour cabler l’utilisation de Doctrine :

   <?php
   
   namespace App\Command;
   
   use Symfony\Component\Console\Attribute\AsCommand;
   use Symfony\Component\Console\Command\Command;
   use Symfony\Component\Console\Input\InputArgument;
   use Symfony\Component\Console\Input\InputInterface;
   use Symfony\Component\Console\Input\InputOption;
   use Symfony\Component\Console\Output\OutputInterface;
   use Symfony\Component\Console\Style\SymfonyStyle;
   use App\Entity\Tag;
   use App\Entity\Todo;
   use Doctrine\Persistence\ManagerRegistry;
   
   #[AsCommand(
           name: 'app:add-tag',
           description: 'Add a tag to a todo (both must exist already)',
   )]
   class AddTagCommand extends Command
   {
           /**
            *  @var ManagerRegistry data access repository
            */
           private $doctrineManager;
   
           /**
            * Plugs the database to the command
            *
            * @param ManagerRegistry $doctrineManager
            */
           public function __construct(ManagerRegistry $doctrineManager)
           {
                   $this->doctrineManager = $doctrineManager;
   
                   parent::__construct();
           }
   
           protected function configure(): void
           {
                   $this
                           ->addArgument('tagName', InputArgument::REQUIRED, 'Tag name')
                           ->addArgument('todoId', InputArgument::REQUIRED, 'Id of the todo')
                           ;
           }
   
           protected function execute(InputInterface $input, OutputInterface $output): int
           {
                   $io = new SymfonyStyle($input, $output);
                   $tagName = $input->getArgument('tagName');
                   $todoId = $input->getArgument('todoId');
   
                   dump($tagName);
                   dump($todoId);
   
                   // Do the work here :
                   // TODO 1. load tag and todo
                   // TODO 2. add tag to todo
                   // TODO 3. save changes to the database
   
                   return Command::SUCCESS;
           }
   }
   
   

   Contrairement aux codes des commandes précédentes, ici, on a gardé dans une propriété de la classe ($doctrineManager) la référence au gestionnaire doctrine, pour pouvoir accéder plus tard aux deux repositories respectifs des tâches et des étiquettes.

Ajoutons le chargement des données correspondant aux arguments reçus.

Modifiez le code de execute() :

1. Dans un premier temps, on récupère les deux références aux repositories Doctrine de nos deux entités, grâce à la propriété $doctrineManager qu’on a gardé en mémoire dans le constructeur :

   protected function execute(InputInterface $input, OutputInterface $output): int
   {
   
           //...
   
           // Do the work here :
           // 1. load tag and todo
           $todoRepository = $this->doctrineManager->getRepository(Todo::class);
           $tagRepository = $this->doctrineManager->getRepository(Tag::class);
   
           // ...
   
   

2. On peut donc maintenant ajouter le chargement de la tâche choisie :

   1. On charge la tâche (qui doit exister en base de données pour que la commande réussisse), avec la méthode find() du repository, qui charge une instance à partir de son identifiant (unique) :

      protected function execute(InputInterface $input, OutputInterface $output): int
      {
      
              //...
              $todo = $todoRepository->find($todoId);
              if(! $todo){
                      $io->error('could not find todo!');
                      return Command::FAILURE;
              }
      
              // ...
      
      

   2. Pour le chargement de l’étiquette (qui doit elle-aussi exister préalablement), on n’a pas passé en argument de la commande un identifiant (numéro), mais une chaîne de caractères correspondant à une propriété de notre entité (name).

      On ne peut donc pas utiliser directement find(), mais on peut utiliser la méthode findOneBy() pour effectuer une requête de sélection par critère (SELECT ... WHERE ...).

      Elle effectue une requête de chargement d’une instance (findOne…) via une sélection, selon des couples clé-valeur passés en argument (un tableau associatif ['NOM_PROPRIETE1' => VALEUR_PROPRIETE1, ...], qui se traduit par les clauses WHERE correspondantes) :

      $tag = $tagRepository->findOneBy(['name' => $tagName]);
      

      Mais notez qu’on peut aussi utiliser une version alternative, en utilisant une méthode « magique » qui contient le nom de la propriété recherchée (écriture plus limpide sans tableau en argument) :

      $tag = $tagRepository->findOneByName($tagName);
      

Examinons maintenant ce qui se passe en mémoire dans l’exécution de notre code basé sur Doctrine.

On peut utiliser ici l’outil dump() de Symfony, qui sera très puissant pour vous aider dans la mise au point de votre code.

Maintenant qu’on a les données en mémoire, complétez =execute() pour afficher notre tâche et notre étiquette :

dump($todo);
dump($tag);

Vous remarquez que notre tâche « apprendre les bases de PHP » (/instance #359 de App\Entity\Todo/) a une propriété tags qui est une PersistentCollection, qui ne semble rien contenir pour l’instant. De façon réciproque, notre étiquette « facile » a une collection de tâches todos pas beaucoup plus conséquente :

^ App\Entity\Todo^ {#359
  -id: 1
  -title: "apprendre les bases de PHP"
  -completed: true
  [...]
  -tags: Doctrine\ORM\PersistentCollection^ {#363
    #collection: Doctrine\Common\Collections\ArrayCollection^ {#442
      -elements: []
    }
    #initialized: false
    -snapshot: []
    -owner: App\Entity\Todo^ {#359}
    -association: array:20 [ …20]
    -em: ContainerOeMwtvh\EntityManagerGhostEbeb667^ {#267 …12}
    -backRefFieldName: "todos"
    -typeClass: Doctrine\ORM\Mapping\ClassMetadata {#357 …}
    -isDirty: false
  }
}
^ App\Entity\Tag^ {#1359
  -id: 2
  -name: "facile"
  -todos: Doctrine\ORM\PersistentCollection^ {#1368
    #collection: Doctrine\Common\Collections\ArrayCollection^ {#1369
      -elements: []
    }
    #initialized: false
    -snapshot: []
    -owner: App\Entity\Tag^ {#1359}
    -association: array:16 [ …16]
    -em: ContainerOeMwtvh\EntityManagerGhostEbeb667^ {#267 …12}
    -backRefFieldName: "tags"
    -typeClass: Doctrine\ORM\Mapping\ClassMetadata {#403 …}
    -isDirty: false
  }
}

Il est temps d’ajouter l’étiquette à la tâche, en mémoire.

Plus précisément, on va ajouter l’étiquette qu’on a chargée depuis la base de donnée, dans la collection des étiquettes de la tâche.

Rien de plus compliqué qu’utiliser la méthode Todo::addTag(), qui est là pour cela.

Notez que Todo::addTag() a été ajoutée à notre code par make:entity, lors de l’ajout de l’association entre tâches et étiquettes.

1. Modifiez execute() en ajoutant ce code :

   //...
   
   // 2. add tag to todo
   $todo->addTag($tag);
   
   dump($todo);
   dump($tag);
   

2. Testez l’appel de la commande, et vérifiez le contenu avant/après de nos instances en mémoire dans l’affichage fait par dump().

   Cette fois, l’affichage des collections tags dans la Todo nous laisse bien apparaître le lien entre nos deux entités :

   ^ App\Entity\Todo^ {#359
     -id: 1
     -title: "apprendre les bases de PHP"
     -completed: true
     [...]
     -tags: Doctrine\ORM\PersistentCollection^ {#363
       #collection: Doctrine\Common\Collections\ArrayCollection^ {#442
         -elements: array:1 [
           0 => App\Entity\Tag^ {#1359
             -id: 2
             -name: "facile"
             [...]
           }
         ]
       }
       #initialized: true
       -snapshot: []
       -owner: App\Entity\Todo^ {#359}
       -association: array:20 [ …20]
       -em: ContainerOeMwtvh\EntityManagerGhostEbeb667^ {#267 …12}
       -backRefFieldName: "todos"
       -typeClass: Doctrine\ORM\Mapping\ClassMetadata {#357 …}
       -isDirty: true
     }
   }
   ^ App\Entity\Tag^ {#1359
     -id: 2
     -name: "facile"
     -todos: Doctrine\ORM\PersistentCollection^ {#1368
       #collection: Doctrine\Common\Collections\ArrayCollection^ {#1369
       -elements: []
       }
       #initialized: true
       -snapshot: []
       -owner: App\Entity\Tag^ {#1359}
       -association: array:16 [ …16]
       -em: ContainerOeMwtvh\EntityManagerGhostEbeb667^ {#267 …12}
       -backRefFieldName: "tags"
       -typeClass: Doctrine\ORM\Mapping\ClassMetadata {#403 …}
       -isDirty: false
     }
   }
   

3. Vous voyez également qu’en mémoire, si notre tâche a son étiquette, par contre, l’étiquette semble ne pas connaître la tâche (dans la collection de sa propriété Tag::todos, qui ne contient pas d’éléments).

4. Modifions cela dans Todo::addTag(), en ajoutant $tag->addTodo($this);, pour obtenir :

   public function addTag(Tag $tag): static
   {
                   if (!$this->tags->contains($tag)) {
                                   $this->tags->add($tag);
                                   // make sure the reverse reference is set too
                                   $tag->addTodo($this);
                   }
   
                   return $this;
   }
   

   La tâche ajoute l’étiquette dans sa collection d’étiquette tags, mais elle informe ensuite l’étiquette en question qu’elle a une nouvelle tâche associée (en lui passant sa propre référence $this).

5. Vérifiez dans l’affichage de dump() à l’exécution après cette dernière modification.

   Le modèle en mémoire est cohérent : nos deux entités se référencent mutuellement :

   ^ App\Entity\Todo^ {#359
     -id: 1
     -title: "apprendre les bases de PHP"
     -completed: true
     [...]
     -tags: Doctrine\ORM\PersistentCollection^ {#363
       #collection: Doctrine\Common\Collections\ArrayCollection^ {#442
         -elements: array:1 [
           0 => App\Entity\Tag^ {#1359
             -id: 2
             -name: "facile"
             [...]
           }
         ]
       }
       #initialized: true
       -snapshot: []
       -owner: App\Entity\Todo^ {#359}
       -association: array:20 [ …20]
       -em: ContainerOeMwtvh\EntityManagerGhostEbeb667^ {#267 …12}
       -backRefFieldName: "todos"
       -typeClass: Doctrine\ORM\Mapping\ClassMetadata {#357 …}
       -isDirty: true
     }
   }
   ^ App\Entity\Tag^ {#1359
     -id: 2
     -name: "facile"
     -todos: Doctrine\ORM\PersistentCollection^ {#1368
       #collection: Doctrine\Common\Collections\ArrayCollection^ {#1369
         -elements: array:1 [
           0 => App\Entity\Todo^ {#359
             -id: 1
             -title: "apprendre les bases de PHP"
             -completed: true
             [...]
             }
           }
         ]
       }
       #initialized: true
       -snapshot: []
       -owner: App\Entity\Tag^ {#1359}
       -association: array:16 [ …16]
       -em: ContainerOeMwtvh\EntityManagerGhostEbeb667^ {#267 …12}
       -backRefFieldName: "tags"
       -typeClass: Doctrine\ORM\Mapping\ClassMetadata {#403 …}
       -isDirty: true
     }
   }
   

   En plus d’afficher de jolies couleurs, bien qu’il y ait un cycle dans nos données, dump() fait du bon boulot et ne part pas dans une boucle infinie ! Nice :-)

6. Lancez plusieurs fois de suite la même commande app:add-tag. Vous constatez que les modifications sont bien effectuez en mémoire, mais quand on recharge les données, les collections restent désespérément vides.

   Il manque finalement la persistence en base de données.

Dernier élément à coder dans execute(), faire en sorte que ces modifications soit sauvegardées en base de données.

On va devoir sauvegarder explicitement, dans notre code, en ajoutant l’appel à save() pour l’une des entités, par exemple $todo.

1. Modifiez enfin execute() pour ajouter la sauvegarde :

   protected function execute(InputInterface $input, OutputInterface $output): int
   {
                   //...
   
                   // 3. save changes to the database
                   $todoRepository->save($todo, true);
   
                   return Command::SUCCESS;
   }
   

2. Testez une nouvelle fois l’invocation de la même commande symfony console app:add-tag facile 1, en regardant les logs, et vérifiez que cela fonctionne bien : la requête SQL INSERT est bien transmise à la base SQLite.

   Les messages de traces de débug de Doctrine (doctrine.DEBUG) ressemblent à :

   Executing statement: SELECT t0.id AS id_1, t0.title AS title_2, t0.completed AS completed_3, t0.created AS created_4, t0.updated AS updated_5
                        FROM todo t0
                        WHERE t0.id = ?
                        (parameters: array{"1":"1"}, types: array{"1":1})
   Executing statement: SELECT t0.id AS id_1, t0.name AS name_2
                        FROM tag t0
                        WHERE t0.name = ? LIMIT 1
                        (parameters: array{"1":"facile"}, types: array{"1":2})
   Executing statement: SELECT t0.id AS id_1, t0.name AS name_2
                        FROM tag t0
                        INNER JOIN todo_tag
                              ON t0.id = todo_tag.tag_id
                              WHERE todo_tag.todo_id = ?
                        (parameters: array{"1":1}, types: array{"1":1})
   Executing statement: SELECT t0.id AS id_1, t0.title AS title_2, t0.completed AS completed_3, t0.created AS created_4, t0.updated AS updated_5
                        FROM todo t0
                        INNER JOIN todo_tag
                              ON t0.id = todo_tag.todo_id
                              WHERE todo_tag.tag_id = ? (parameters: array{"1":2}, types: array{"1":1})
   Beginning transaction 
   Executing statement: INSERT INTO todo_tag (todo_id, tag_id)
                        VALUES (?, ?) (parameters: array{"1":1,"2":2}, types: array{"1":1,"2":1})
   Committing transaction
   
   

   Explications des différentes instructions :

   1. chargement de la tâche par son numéro « 1 » (appel à find(), qui charge ici notre tâche d’id 1)
   2. chargement de l’étiquette par son nom « facile » (appel à findOneByName(), qui charge notre étiquette d’id 2, comme on l’avait vu dans les dumps)
   3. ensuite vient l’impact du addTag(), qui implique le chargement des étiquettes existantes de notre tâche (if (!$this->tags->contains($tag))), qui génère une jointure pour charger les étiquettes de la tâche (premier INNER JOIN avec la table de jointure créée dans la base pour gérer l’association M-N : todo_tag)
   4. de façon réciproque, chargement des tâches de l’étiquette (deuxième INNER JOIN sur la table d’association)
   5. enfin, il est temps de sauvegarder les données (persist() et flush() générés par l’appel à save()) :
      1. Doctrine crée une transaction pour assurer que les contraintes d’intégrité sont bien respectées (une application Symfony est typiquement multi-utilisateur, et il ne faut pas que les modifications concurrentes occasionnent des bugs)
      2. si tout va bien et qu’aucune autre exécution du code ne modifie la même table d’association, on peut alors créer le couple des identifiant de nos deux entités, via un INSERT dans la table d’association todo_tag.

On verra ultérieurement d’autres strcutures de données par exemple avec les associations 1-N OneToMany