TP n°1 - Prise en main de PHP et de la boîte à outils Symfony
Application PHP en ligne de commande « gestionnaire de tâches Todo »

On considère que vous avez acquis les notions de base sur la syntaxe du langage PHP, dans la séquence de Travail en Autonomie qui précède cette séance.

Du point de vue théorique, cette séance revisite principalement les acquis des cours d’informatique de l’année passée, sur le modèle objet et les bases de données relationnelles.

Dans cette séance, on utilisera les outils suivants :

• la ligne de commande dans un terminal
• l’outil Symfony en ligne de commande
• l’environnement d’exécution PHP 8
• Composer
• SQlite
• l’IDE Eclipse (ou un équivalent) pour PHP
• le navigateur Web

Le présent support de séance de TP est consultable via une mise en forme avec l’habillage org-html-themes, qui permet de masquer/révéler les différentes sections du support¹.

Dans le présent support de TP, les copies d’écrans et autres spécificités reflètent autant que possible l’état des versions installées sur les machines DISI des salles de TP en environnement GNU/Linux Ubuntu.

Il est probable que sur les machines individuelles, le support de PHP et de Symfony sera parfois différent.

Même si les technologies utilisées pour les séquences d’apprentissage actif (programmation PHP avec le framework Symfony) sont théoriquement portables et utilisables sur différents systèmes d’exploitation, des différences existent qui rendent parfois difficile le support au vu des différentes variantes possibles, et pour un module enseigné en promo entière.

Pour cette séance, on supposera que vous travaillez sur la machine que vous allez utiliser pour le reste des séances de TP et de travail hors-présentiel (y compris le projet).

Vous aurez besoin d’un terminal en ligne de commande, mais aussi de l’environnement graphique pour utiliser l’IDE.

Nous vous suggérons de travailler, pour chaque séance, dans un répertoire spécifique.

• $HOME/CSC4101/
  • tp-01/
  • tp-02/
  • …

1. Configurez un répertoire de travail $HOME/CSC4101/ dans votre compte.

   mkdir $HOME/CSC4101/
   cd $HOME/CSC4101/
   

2. Pour l’instant, on crée un nouveau répertoire spécifique à cette séance :

   mkdir tp-01/
   cd tp-01/
   

Exécutez les commandes suivantes :

cd $HOME/CSC4101/tp-01/
symfony composer create-project oberger/tspcsc4101-todo-skeleton todo-app "v2.*" -n

Comme vous le voyez, Composer télécharge une version spécifique (2.x) de l’application ToDo à partir du projet « oberger/tspcsc4101-todo-skeleton », qui a été préparé pour les besoins du cours.

Le code de ce projet Symfony est extrait dans le répertoire ~/CSC4101/tp-01/todo-app/.

Explications de la signification des différents éléments de cette invocation :

composer

invocation de Composer, l’outil de gestion de paquetages PHP

create-project

commande create-project de composer qui crée un projet à partir d’un squelette existant (cf. documentation composer)

oberger/tspcsc4101-todo-skeleton

référence du squelette d’application qui a été préparé pour le cours

todo-app

répertoire du projet à créer

v2.*

version particuilère à télécharger : 2.x (la dernière version de la branche 2 ayant été publiée via packagist.org)

-n

option --no-interaction de composer create-project permettant de répondre avec les valeurs par défaut en cas de confirmations demandées pour l’exécution de recettes flex (configuration et génération de fichiers utiles)

Vérifiez le contenu du répertoire todo du projet Symfony qui vient d’être créé.

ls todo-app/

Pour l’instant, repérez les éléments principaux qui vont nous intéresser :

bin  composer.json  composer.lock  config  public  src  symfony.lock  todo.sqlite  var  vendor

composer.json

descriptif du projet Composer de l’application. Il référence notamment les bibliothèques PHP utilisées dans ce projet basé sur Symfony;

Vous pouvez consulter son contenu (format JSON) dans un éditeur de texte.

Au fur et à mesure de la vie d’un projet Symfony on pourra utiliser Composer à nouveau, pour y ajouter des dépendances, les bibliothèques de développement dont on aura besoin au cours de l’ajout des fonctionnalités.

bin/console

script exécutable PHP présent dans le sous-répertoire bin/, utilisé en ligne de commande pour le développement Symfony, chaque fois qu’on va invoquer symfony console en ligne de commande;

src/

coeur du squelette d’application Symfony. Il contient le code source PHP de l’application, sur lequel vous travaillerez principalement par la suite;

templates/

sources des gabarits Twig de l’application, sur lesquels vous serez amenés à travailler également, quand vous concevrez les pages Web;

vendor/

contient le code de toutes les bibliothèques PHP du framework Symfony qui seront utilisées. Elles ont été téléchargées par Composer, et y seront mises à jour en cas d’évolutions (correction de bugs, etc.).

Interdiction de modifier manuellement le contenu de ce répertoire, sous peine de malédiction. On ne touche qu’au code qui est dans src/.

Le script bin/console fourni dans le projet permet d’accéder en ligne de commande (dans un terminal) à différentes fonctionnalités du cadriciel Symfony, notamment des utilitaires intéressants pour les phases de développement et de tests.

On lancera les commandes via l’invocation symfony console de l’outil Symfony en ligne de commande préalablement installé.

Essayez les commandes suivantes dans un terminal, depuis l’intérieur du répertoire du projet Symfony :

1. Vérifiez la version de Symfony utilisée dans le projet

   cd $HOME/CSC4101/tp-01/todo-app/
   symfony console -V
   

   Symfony 6.3.3 (env: dev, debug: true) [...]
   

   Vous êtes bien en environnement de développement dev (pas encore prêts pour la production !)

2. Affichez la liste des sous-commandes disponibles (avec la sous-commande list, ou directement sans argument passé à symfony console) :

   symfony console list
   

3. Consultez l’aide en ligne avec la sous-commande help. Par exemple :

   symfony console help about
   

4. Et consultez donc également la sortie fournie par cette sous-commande about :

   symfony console about
   

   Cette commande donne différentes informations sur l’environnement de développement et de mise au point.

On va re-créer la base de données de l’application, qui nous sert à effectuer des tests en local pendant le développement et la mise au point du code.

Effectuez les opérations suivantes dans un terminal en ligne de commande :

1. Supprimez le fichier de base de données SQLite existant :

   symfony console doctrine:database:drop --force
   

2. Créez un fichier de base de données SQLite (vide), en exécutant la commande suivante :

   symfony console doctrine:database:create
   ls -l *.sqlite
   

   En fait, il se trouve que cette commande se contente de créer un fichier vide, ce qui correspond au comportement nécessaire pour une base de données légère comme SQLite. Mais dans le cas où on utiliserait un autre SGBD, ceci peut s’avérer nécessaire.

3. Créez le schéma de la base SQLite (tables, index, etc.), en utilisant la sous-commande doctrine:schema:create :

   1. Commencez-donc par vérifier ce qui serait fait :

      symfony console doctrine:schema:create --dump-sql
      

      CREATE TABLE todo (id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
      title VARCHAR(255) DEFAULT NULL,
      completed BOOLEAN NOT NULL,
      created DATETIME DEFAULT NULL,
      updated DATETIME DEFAULT NULL);
      

      Le code SQL affiché devrait vous sembler assez clair, pour l’instant.

   2. Puis créez le schéma pour de bon, avec :

      symfony console doctrine:schema:create
      

Dans le squelette fourni, les développeurs de ToDo on codé une interface en ligne de commande.

1. Appelez la première commande de l’application list-todos :

   symfony console app:list-todos
   

2. Sans surprise, cette commande affiche la liste des tâches connues dans la base de données de l’application : [ERROR] no todos found!.

   Ça fonctionne nominalement… mais la base de données est vide, vu qu’on vient de la recréer dans l’étape précédente.

Heureusement pour nous, les développeurs ont aussi préparé un jeu de données de test, qu’on peut utiliser.

Chargez enfin les données de tests qui ont été préparées dans le squelette fourni :

1. Utilisez la commande Symfony du module Doctrine pour charger des données de tests (fixtures) :

   symfony console doctrine:fixtures:load -n
   
      > purging database
      > loading App\DataFixtures\AppFixtures
   
   

   la base de données doit maintenant contenir ces données de tests.

2. Vérifiez en relançant la commande app:list-todos

1. Vous avez déjà découvert la première fonction de l’application, disponible en ligne de commande pour les développeurs :

   cd $HOME/CSC4101/tp-01/todo-app/
   symfony console app:list-todos
   

   Sans surprise, cette commande affiche la liste des tâches connues dans la base de données de l’application.

2. Vérifiez les autres sous-commande app:* présentes :

   symfony console list app
   

3. Utilisez maintenant la commande app:show-todo pour afficher les détails d’une tâche.

Comme vous pouvez le constater, notre application se présente, pour l’instant, de façon très rudimentaire, en ligne de commande.

Pour naviguer dans le code, on va utiliser un IDE (Integrated Development Environment) compatible avec PHP et Symfony

Symfony gère la notion d’environnements ayant différentes configurations au sein d’un même projet : développement, tests, production.

Nous sommes actuellement en phase de développement, en local sur notre machine, avec déjà pas mal d’outils pour tester notre code fournis par le cadriciel Symfony.

Notez l’existence du fichier « .env » à la racine du projet Symfony :

ls -a
cat .env

Ce fichier .env définit les valeurs de certaines variables de configuration du projet Symfony, dans le répertoire courant. Ces valeurs définissent les spécificités de l’« environnement Symfony » dev (utilisé en phase de développement).

Ces valeurs diffèrent des valeurs cibles pour le déploiement futur de l’application une fois qu’elle sera mise en production (cf. les valeurs par défaut du fichier « .env.dist »).

Les données affichées par l’application proviennent d’une base de données relationnelle

SQLite stocke la base de données relationnelle dans un fichier présent dans le répertoire du projet Symfony.

Vérifiez le contenu du fichier (caché) .env présent à la racine du projet, qui définit des variables d’environnement, comme les paramètres d’accès à la base de données :

1. Chargez le le fichier .env dans l’IDE

   Attention, c’est un fichier caché… il faut éventuellement le faire apparaître dans l’IDE.

   Pour cela, dans Eclipse :

   • cliquez sur le bouton avec trois petits points verticaux, en haut à droite de la colonne du « Project Explorer »;
   • puis sur « Filters and Customizations »;
   • dans la liste des « Pre-Set filters », dé-cochez « .* ressources », puis « OK ».

   Les fichiers cachés apparaissent dans le projet, dont le fichier .env.

2. Ouvrez .env, et vérifiez la valeur de la variable DATABASE_URL, présente dans la section doctrine/doctrine-bundle.

   Elle doit typiquement prendre la valeur sqlite:///%kernel.project_dir%/todo.sqlite, afin d’utiliser SQLite pour les besoins du développeur qui teste en local :

   DATABASE_URL=sqlite:///%kernel.project_dir%/todo.sqlite
   

   Ainsi, la base de données SQLite utilisée pour les tests sera créée dans $HOME/CSC4101/tp-01/todo-app/todo.sqlite.

La base de données avait été peuplée pour la première exécution de l’application qu’on a faite plus haut.

Examinez son contenu via les opérations suivantes :

1. Vérifiez que la base de données est présente

   ls -l todo.sqlite
   sqlite3 todo.sqlite ".tables"
   

   Elle doit contenir la table : todo

   Vous pouvez aussi utiliser l’outil GUI sqlitebrowser pour consulter le contenu de la base de données, s’il est installé : sqlitebrowser todo.sqlite.

2. Consultez les détails du contenu de la table todo :

   symfony console dbal:run-sql "select * from todo"
   

   ou bien directement :

   sqlite3 todo.sqlite "select * from todo"
   

3. Affichez le schéma de cette table :

   sqlite3 todo.sqlite ".schema todo"
   

Cette base de données semble bien correspondre au modèle de données de notre application au vu de ce qu’on en a compris jusqu’ici.

C’est logique, puisqu’elle a été créée via l’outil Doctrine inclus dans l’environnement de développement de Symfony lors de l’appel à symfony console doctrine:schema:create.

Vérifions maintenant où est spécifié ce modèle de données, dans le code des classes PHP de notre application.

On souhaite gérer des tâches (« to dos ») dans notre application.

Dans notre application Symfony, on va gérer ces éléments aussi bien :

• en mémoire durant l’exécution du programme PHP;
• dans la base de données relationnelle, qui stockera les données entre deux exécutions de notre programme,

On va gérer les structures de données correspondantes avec deux approches conjointes :

• le modèle objet, pour la représentation en mémoire et les traitements à l’exécution;
• le modèle relationnel, pour le stockage (persistence) dans la base de données.

En base de données, on aura donc la relation todo, stockée sous forme de table, accessible avec SQL, qu’on a vue plus haut.

Du côté objets, on utilisera la bibliothèque PHP Doctrine, qui est un ORM (Object Relational Mapper). Son rôle est de permettre la gestion de collections d’objets, d’associations entre entités, et de fournir le chargement/sauvegarde des objets depuis la base de données.

Pour faire court, le principe de l’ORM est de convertir chaque instance d’une relation (chaque ligne d’une table de la base de données) en instance d’une classe PHP en mémoire, et inversement. Doctrine appelle Entité ces classes d’objets.

Le programmeur peut ainsi écrire des classes PHP utilisant les fonctionnalités de Doctrine, et ainsi gérer des instances des entités, ou des collections d’entités. Quand deux entités sont liées (association 1-n, par exemple), des fonctions permettent de gérer cette association « OneToMany » et d’accéder à la collection des entités liées facilement.

Le code PHP qui exécute le traitement de la commande app:list-todos se trouve dans le fichier src/Command/ListTodosCommand.php du projet.

1. Consultez le fichier src/Command/ListTodosCommand.php dans l’IDE

2. Consultez la déclaration de la classe avec ses attributs :

   #[AsCommand(
       name: 'app:list-todos',
       description: 'List the todos',
       )]
   class ListTodosCommand extends Command
   {
   

   Les attributs PHP 8 définissent des méta-données utiles au framework Symfony. Ici, AsCommand permet de décrire la commande, en définissant son nom, et la description qui sera affichée dans la liste des commandes (symfony console list app).

   On a donc une nouvelle commande appelable depuis la console via symfony console app:list-todos.

1. Consultez maintenant le coeur du sujet, dans le code de la méthode execute(). Comprenez-vous le rôle de cette méthode ?

   $io = new SymfonyStyle($input, $output);
   
   // fetches all instances of class Todo from the DB
   $todos = $this->todoRepository->findAll();
   //dump($todos);
   
   if(!empty($todos)) {
       $io->title('list of todos:');
       $io->listing($todos);
   } else {
       $io->error('no todos found!');
       return Command::FAILURE;
   }
   
   return Command::SUCCESS;
   

   Quelques commentaires :

   • l’utilitaire SymfonyStyle fourni par Symfony permet de mettre en forme des affichages sur la sortie standard dans la console :

     title()

     affiche un message de titre (colorisé)

     listing()

     affiche une liste d’éléments sous forme de liste à puces

     error()

     affiche un message d’erreur (colorisé)

   • $todoRepository est une propriété de notre classe ListTodosCommand, qui est un Repository d’objets (TodoRepository) pour accéder à la base de données qui stocke les instances de tâches.

     On peut charger une collection de toutes les instances de tâches de la base de données, avec l’appel à findAll() sur ce Repository. Elle renvoie une « liste/tableau » d’instances de la classe Todo, une pour chaque ligne de la table todo de la base de données.

     Remarque : il faudrait aller voir le code de TodoRepository (présent dans src/Repository/TodoRepository.php) pour voir comment cette classe est liée à la classe Todo, qui n’apparaît pas ici par magie.

     Mais ce serait aller explorer des éléments un peu trop complexes pour le moment. On y reviendra dans les séquences du cours ultérieures.

     Pour l’instant, on peut se contenter de voir l’aide fournie par l’IDE qui montre le prototype de la méthode findAll() si on laisse le pointeur fixe sur son appel dans l’instruction $todos = $this->todoRepository->findAll(); :

     App\Repository\TodoRepository::findAll() : Todo[] 
     
     Returns:
      Todo[]
     

     Même si on ne connaît pas tous les détails du rôle d’un repository on sait désormais que cette méthode renvoie un tableau d’instances de Todo. De l’utilité d’avoir un IDE comprenant les projets Composer, le PHP objet, etc.

   Ce code suffit donc à afficher toutes les tâches présentes dans la base de données, mises en forme de façon agréable sur la sortie standard en ligne de commande.

   Regardons à présent à quoi ressemblent ces « tâches » dans le code, avec cette fameuse classe Todo.

Les objets manipulés par notre application constituent le modèle de données. Ici, un ensemble de tâches codées grâce à la classe PHP Todo.

Dans un projet Symfony utilisant Doctrine, les classes du modèle de données sont définies dans les fichiers source présents dans src/Entity/ (complétés par les classes de src/Repository/).

Voyons ce que les développeurs de Todo y ont codé en PHP objet :

1. Consultez src/Entity/Todo.php dans l’IDE, pour consulter le code de la classe Todo.

   Notez la convention de structuration du projet utilisée, pour faciliter la correspondance entre les noms des classes, avec les espaces de noms (namespaces) PHP, et leur emplacement dans la structure de répertoires du code source :

   • Namespace : App\Entity
   • Classe : Todo (convention : toute classe commence par une capitale)
   • Répertoire : src/Entity

   • Fichier source : Todo.php (une seule classe par fichier source PHP)

     L’auto-loader PHP utilisé dans les projets Symfony basés sur Composer, parcourt automatiquement les répertoires de sources du projet (principalement src/ et de ses bibliothèques, en dessous de vendor/) pour charger les fichiers sources, et détecter les déclarations de namespace permettant de résoudre ultérieurement les imports via l’instruction use.

     Exemple :

     Programme 1 : déclaration de classe dans son namespace (dans src/Entity/Todo.php)

     namespace App\Entity;
     
     ...
     
     class Todo {
     
         ...
     

     Programme 2 : utilisation dans src/Command/ListTodosCommand.php

     use App\Entity\Todo;
     
     ...
     
         $this->todoRepository = $doctrineManager->getRepository(Todo::class);
     
     ...
     
     

2. Pouvez-vous identifier les propriétés (variables d’instances) définies dans la classe Todo ?

   Vous remarquez que chacune de ces propriétés est décorée avec un attribut ORM\Column qui permet à Doctrine de savoir comment en gérer la persistence.

   On retrouve la correspondance avec les éléments renvoyés par sqlite3 todo.sqlite ".schema todo" ou symfony console doctrine:schema:create --dump-sql :

   propriété de classe	type PHP	attribut Doctrine	colonne en base
   Todo::id	int	ORM\Id, ORM\GeneratedValue	INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL
   Todo::title	string	ORM\Column(length: 255, nullable: true)	VARCHAR(255) DEFAULT NULL
   Todo::completed	bool	ORM\Column	BOOLEAN NOT NULL
   Todo::created	Datetime	ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)	DATETIME DEFAULT NULL
   Todo::updated	Datetime	ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)	DATETIME DEFAULT NULL

   Vous savez donc maintenant où et comment on peut programmer ces attributs ORM destinés à Doctrine pour la persistence en base de données, qui définissent les conversions de type, les contraintes de stockage, de valeurs non-nulles, etc. On y reviendra en détails ultérieurement.

3. Observez la méthode __toString() qui réalise la conversion en chaîne de caractères (pour l’affichage sur la console, entre autres).

Examinons un exemple de code de mise à jour du contenu de la base de données, celui qui s’exécute lors de l’invocation de symfony console doctrine:fixtures:load pour charger les données de tests dans la base locale.

Examinez le code dans src/DataFixtures/AppFixtures.php

Le code de la méthode AppFixtures::loadTodos() va appeler autant que nécessaire getTodosData(), pour récupérer des couples (titre, complété), et les sauvegarder comme autant de tâches, dans la base de données.

On fonctionne en deux temps :

1. création d’une instance de tâche en mémoire, pour chaque couple, en utilisant des instructions standard en PHP objets (appel au constructeur, puis aux setters):

   $todo = new Todo();
   $todo->setTitle($title);
   $todo->setCompleted($completed);
   

2. sauvegarde des données via les appels à persist() et flush() de Doctrine, qui vont générer la requête (INSERT) en base de données.

   Inutile d’en savoir beaucoup plus pour l’instant.

Depuis la ligne de commande, vous aller lancez le serveur HTTP intégré à l’outil Symfony en ligne de commande.

Le serveur rend accessible via HTTP des ressources disponibles dans le répertoire du projet Symfony d’où il a été lancé. Quand ces ressources correspondent à des programmes PHP, il les exécute pour faire interpréter les requêtes HTTP par ces programmes.

Lancez la commande suivante :

cd $HOME/CSC4101/tp-01/todo-app/
symfony server:start

Le serveur se lance et affiche quelque chose du genre :

 [OK] Web server listening                                                                                              
      The Web server is using PHP CLI 8.2.7                                                                             
      http://127.0.0.1:8000                                                                                             
[Web Server ] Jul 10 13:15:56 |DEBUG  | PHP    Reloading PHP versions 
[Web Server ] Jul 10 13:15:56 |DEBUG  | PHP    Using PHP version 8.2.7 (from default version in $PATH) 
[Web Server ] Jul 10 13:15:56 |INFO   | PHP    listening path="/usr/bin/php8.2" php="8.2.7" port=38555
[PHP        ] [Mon Jul 10 13:15:56 2023] PHP 8.2.7 Development Server (http://127.0.0.1:38555) started

Chargez l’URL http://localhost:8000/ (ou http://127.0.0.1:8000) dans un navigateur Web (lancé sur la même machine)

Vous constatez le comportement suivant :

• Une page Web affiche « Welcome to Symfony 6.3.x »

• dans le terminal, le serveur Web affiche quelque chose du style :

  [PHP        ] [Fri Aug 26 15:55:05 2022] ::1:33926 [404]: GET /
  

Le serveur fonctionne, et affiche les traces (logs) de fonctionnement au fur et à mesure des connexions du navigateur.

1. Comment expliquer que ce code de réponse est renvoyé, alors que le navigateur affiche une page ?

   Le serveur Web a bien effectué un traitement, en réponse à la requête du navigateur de chargement de la ressource /.

   Il a en fait démarré l’exécution de notre application PHP Symfony.

   Symfony nous renvoie une page HTML, pour habiller le message d’erreur : un code de réponse 404 (Not found).

   Par exception, comme nous sommes en environnement de développement, et qu’on est sur la ressource racine du site, Symfony nous accueille avec un tel message informatif.

   Le serveur nous dit : « 404 : il n’y a rien à la racine du site ! »

2. Essayez sur http://localhost:8000/todo/list : est-ce mieux, maintenant ?

   OK, dans cette version très basique de l’application Todo, les développeurs ont mieux géré la présentation en ligne de commande que le look des pages Web… normal, ça viendra en temps utile dans la suite du cours.

Connectez-vous sur la partie /admin de l’application avec votre navigateur.

Testez que vous pouvez visualisez le contenu de la base de données de l’application ToDo, et modifier le contenu de la base.

Est-ce qu’un tel système est suffisant pour réaliser des applications Web, sans presque écrire de code ?

Il y a des chances que les fonctionnalités ne suffisent pas (en gros on a une gestion minimale de base de donnée avec une surcouche Web).

En plus, donner les droits à tout le monde de tout modifier, ce n’est sûrement pas acceptable en production !

Dans votre IDE, consultez le contenu du répertoire src/Controller/Admin/. Vous noterez qu’il y a assez peu de code présent, qui permet de générer l’ensemble des pages du tableau de bord d’administration.

Ce code s’appuie sur le bundle EasyAdmin pour Symfony, qui met en œuvre l’essentiel du travail de façon générique, mais customisable.

Pour info, ce bundle est assez conséquent : 237 fichiers source PHP (objet), soit environ 17 500 lignes de code, et 12 Mo en tout.

$ du -sh vendor/easycorp/easyadmin-bundle/
8,9M	vendor/easycorp/easyadmin-bundle/

$ find vendor/easycorp/easyadmin-bundle/ -name '*.php' | grep -v translations | xargs cat | grep -E '\S' | wc -l
16907

Cool, c’est autant de code qu’on n’a pas besoin d’écrire, pour un résultat assez sympathique.

Vous pouvez examiner le fonctionnement de la commande app:list-active-todos permettant de lister les seules tâches pas encore terminées.

Consultez le code source dans src/Command/ListactiveTodosCommand.php, dont la méthode execute() propose un algorithme trivial pour filtrer les seules tâches qui ne sont pas encore terminées.

Vous allez utiliser la commande new de l’outil Symfony en ligne de commande (Symfony CLI), qui va créer le répertoire de développement d’une application Symfony et y télécharger le code source d’un squelette d’application.

Cette commande s’appuie sur le gestionnaire de paquetages PHP Composer, en appelant la commande create-project de composer.

Téléchargez et installez le squelette d’application sur lequel vous allez travailler :

cd $HOME/CSC4101/tp-01/
symfony new todo --version=stable

Cette commande affiche plusieurs infos intéressantes pour comprendre ce qui se passe :

* Creating a new Symfony 6.3 project with Composer
 [...]
 (running .../composer.phar create-project symfony/skeleton /.../todo 6.3.* --no-interaction)

* Setting up the project under Git version control
 (running git init /.../todo)


[OK] Your project is now ready in /.../todo                                   

• on voit ce qui a été invoqué via Composer : composer create-project symfony/skeleton todo 6.3.* --no-interaction
• Symfony initialise un référentiel Git local pour le projet, automatiquement. Il sera plus facile de faire des copies de sauvegardes des incréments pendant un projet Symfony, si l’IDE qu’on utilise gère Git.

Pour info, voici la signification des arguments de l’invocation de Composer:

create-project

commande create-project de composer (cf. documentation composer)

symfony/skeleton

référence du squelette d’application standard d’application Web pour la version de Symfony sur laquelle on se base

todo

le nom du répertoire qui va être créé pour contenir le projet Symfony

6.3.*

téléchargement du squelette pour une version précise de Symfony, ici la 6.3. C’est celle qui correspond à la version Stable de Symfony (au moment où on exécute la commande symfony new --version=stable).

Nous aurons besoin de différents modules pour permettre à l’application de fonctionner, ou pour nous aider dans le prototypage de cette application :

Doctrine

le composant d’accès à la base de données via des objets PHP

le « Maker bundle »

qui va nous permettre de générer du code PHP plutôt que d’avoir à tout coder à la main

les « DataFixtures »

qui permettent de charger automatiquement des données de test dans la base de données

Procédez à l’installation avec les commandes suivantes à l’intérieur du répertoire todo :

• Monolog :

  symfony composer require symfony/monolog-bundle
  

• ORM Doctrine :

  symfony composer require -n symfony/orm-pack
  

• « Maker bundle » :

  symfony composer require --dev -n symfony/maker-bundle
  

• DataFixtures :

  symfony composer require --dev doctrine/doctrine-fixtures-bundle
  

Composer a téléchargé et extrait les différentes bibliothèques PHP. On peut donc les utiliser.

Lancez l’assistant make:entity, dans le terminal, depuis l’intérieur du projet Symfony. Il va nous servir à générer le code de classes PHP pour gérer notre entité « Todo ».

Répondez aux questions de l’assistant pour obtenir une interaction similaire à la trace présentée ci-dessous :

symfony console make:entity

 Class name of the entity to create or update (e.g. VictoriousPuppy):
 > Todo

 created: src/Entity/Todo.php
 created: src/Repository/TodoRepository.php

 Entity generated! Now let's add some fields!
 You can always add more fields later manually or by re-running this command.

 New property name (press <return> to stop adding fields):
 > title

 Field type (enter ? to see all types) [string]:
 > 

 Field length [255]:
 > 

 Can this field be null in the database (nullable) (yes/no) [no]:
 > yes

 updated: src/Entity/Todo.php

 Add another property? Enter the property name (or press <return> to stop adding fields):
 > completed

 Field type (enter ? to see all types) [string]:
 > ?

Main Types
  * string
  * text
  * boolean
  * integer (or smallint, bigint)
  * float

Relationships/Associations
  * relation (a wizard 🧙 will help you build the relation)
  * ManyToOne
  * OneToMany
  * ManyToMany
  * OneToOne

Array/Object Types
  * array (or simple_array)
  * json
  * object
  * binary
  * blob

Date/Time Types
  * datetime (or datetime_immutable)
  * datetimetz (or datetimetz_immutable)
  * date (or date_immutable)
  * time (or time_immutable)
  * dateinterval

Other Types
  * ascii_string
  * decimal
  * guid


 Field type (enter ? to see all types) [string]:
 > boolean

 Can this field be null in the database (nullable) (yes/no) [no]:
 > 

 updated: src/Entity/Todo.php

 Add another property? Enter the property name (or press <return> to stop adding fields):
 > created

 Field type (enter ? to see all types) [string]:
 > ?

Main Types
  * string
  * text
  * boolean
  * integer (or smallint, bigint)
  * float

Relationships/Associations
  * relation (a wizard 🧙 will help you build the relation)
  * ManyToOne
  * OneToMany
  * ManyToMany
  * OneToOne

Array/Object Types
  * array (or simple_array)
  * json
  * object
  * binary
  * blob

Date/Time Types
  * datetime (or datetime_immutable)
  * datetimetz (or datetimetz_immutable)
  * date (or date_immutable)
  * time (or time_immutable)
  * dateinterval

Other Types
  * ascii_string
  * decimal
  * guid


 Field type (enter ? to see all types) [string]:
 > datetime

 Can this field be null in the database (nullable) (yes/no) [no]:
 > yes

 updated: src/Entity/Todo.php

 Add another property? Enter the property name (or press <return> to stop adding fields):
 > updated

 Field type (enter ? to see all types) [string]:
 > datetime

 Can this field be null in the database (nullable) (yes/no) [no]:
 > yes

 updated: src/Entity/Todo.php

 Add another property? Enter the property name (or press <return> to stop adding fields):
 > 



  Success! 


 Next: When you're ready, create a migration with symfony console make:migration

2023-06-28T15:57:48+00:00 [info] User Deprecated: Public access to Connection::connect() is deprecated. (Connection.php:364 called by Connection.php:450, https://github.com/doctrine/dbal/issues/4966, package doctrine/dbal)
2023-06-28T15:57:48+00:00 [info] User Deprecated: Doctrine\DBAL\Platforms\AbstractPlatform::setEventManager is deprecated. (AbstractPlatform.php:115 called by Connection.php:317, https://github.com/doctrine/dbal/issues/5784, package doctrine/dbal)
2023-06-28T15:57:48+00:00 [info] User Deprecated: SqlitePlatform::getReservedKeywordsClass() is deprecated, use SqlitePlatform::createReservedKeywordsList() instead. (SqlitePlatform.php:806 called by AbstractPlatform.php:4498, https://github.com/doctrine/dbal/issues/4510, package doctrine/dbal)

L’assistant a créé pour nous deux classes PHP qui utilisent Doctrine :

• src/Entity/Todo.php : gère les instances en mémoire des tâches
• src/Repository/TodoRepository.php : gère le chargement des tâches depuis la base de données

Rafraîchissez votre projet dans Eclipse si nécessaire pour voir apparaître ces deux classes.

Ajoutons maintenant le code permettant de charger toutes les tâches présentes dans la base de données.

On utilise la méthode findAll() du repository Doctrine des tâches TodoRepository, qui a été généré par l’asssistant, et qui renvoie un tableau de tâches. On peut manipuler ce tableau comme un tableau PHP ordinaire, par exemple avec foreach.

Modifiez la méthode execute() de ListTodosCommand :

protected function execute(InputInterface $input, OutputInterface $output): int
{
         $io = new SymfonyStyle($input, $output);

         // récupère une liste toutes les instances de la classe Todo
         $todos = $this->todoRepository->findAll();
         //dump($todos);
         if(!empty($todos)) {
                 $io->title('list of todos:');

                 $io->listing($todos);
         } else {
                 $io->error('no todos found!');
                 return Command::FAILURE;
         }
         return Command::SUCCESS;
}

Testez avec :

symfony console app:list-todos

Le programme échoue avec une erreur (attentue) du type :

symfony console app:list-todos 
list of todos:
[critical] Error thrown while running command "app:list-todos".
Message: "Symfony\Component\Console\Output\Output::writeln(): Argument #1 ($messages) must be of type Traversable|array|string, App\Entity\Todo given,
called in  /.../todo/vendor/symfony/console/Output/Output.php on line 157"

Ce genre de chose devrait vous paraître cohérent avec ce qui a été vu l’année passée en programmation orientée objet.

La méthode writeln() essaie d’afficher une chaîne de caractères sur la console… mais une instance de la classe Todo peut-elle être convertie en chaîne de caractères ? Pas de base, en PHP.

Réglons cela.

Ajoutez la méthode de conversion de tâche en chaîne de caractère qui nous manque : Todo::__toString(), par exemple :

public function __toString() {
        $s = '';
        $s .= $this->getId() .' '. $this->getTitle() .' ';
        $s .= $this->isCompleted() ? '(completed)': '(not complete)';
        return $s;
}

Réessayez le lancement de notre application…

Une fois que les développeurs on effectué les opérations de base pour ajouter EasyAdmin dans le code, il a été nécessaire de modifier certains paramètres pour « customiser » l’affichage des Todo.

On a également dû surcharger certains gabarits d’affichage (on reviendra sur cette notion plus tard).

Pour info, voici un exemple de TodoCrudController::configureFields() avec quelques commentaires pour expliciter le rôle des différents paramètres.

On trouvera également dans les sources du projet (templates/admin/) le code des gabarits qui n’a pas été reproduit ici.

public function configureFields(string $pageName): iterable
{
        return [
                // Id shouldn't be modified
                IdField::new('id')->hideOnForm(),
                // Completed will be rendered as a toggle only in edit
                BooleanField::new('completed')
                        ->onlyOnForms()
                        ->hideWhenCreating(),
                // otherwise it may be displayed on index as a string (as an Integer since Text won't be able to convert bool to string)
                IntegerField::new('completed')
                        ->onlyOnIndex()
                        ->formatValue(function ($value) {
                                return ($value ? 'COMPLETED' : 'ACTIVE');
                        }),
                // Title will be rendered so as to include a link, and be striked whenever completed
                TextField::new('title')
                        ->setTemplatePath('admin/fields/todo_index_title.html.twig'),
                DateField::new('created'),
                DateField::new('updated'),
        ];
}

public function configureActions(Actions $actions): Actions
{
        // For whatever reason show isn't in the menu, bu default
        return $actions
                ->add(Crud::PAGE_INDEX, Action::DETAIL)
        ;
}

public function configureCrud(Crud $crud): Crud
{
        // Customize the rendering of the row to grey-out the completed Todos
        return $crud
                ->overrideTemplate('crud/index', 'admin/crud/todo_index.html.twig')
        ;
}

D’autres paramétrages un peu spéciaux ont dû être faits pour éviter certains problèmes de mise au point (ou contourner des bugs) :

Dans config/packages/framework.yaml, modifier la valeur de cookie_secure à false :

framework:
    # ...
    session:
        # ...

        # make EasyAdmin happy, otherwise CSRF fails for weird reason
        cookie_secure: false