Lors du développement d’un site web, l’utilisation d’un framework est aujourd’hui essentiel. Un framework étant un environnement de travail, c’est à dire un ensemble de dossiers et fichiers qui vont régir notre projet et nous permettre de travailler dans une logique fixée, un ensemble de règles et algorithmes prédéfinis. Cela va nous permettre d’organiser efficacement notre projet et profiter des ressources qu’il nous procure.
Nous verrons dans cet article le processus de création d’un formulaire simple sous les frameworks PHP Symfony et CakePHP étape par étape. Il conviendra de mettre en évidence les différences entre ces deux technologies.
Prérequis
● Symfony
- Version : 3.4
- Commande d’installation du projet : composer create-project symfony/framework-standard-edition symfony-form « 3.4 »
● CakePHP
- Version : 3.7
- Commande d’installation du projet : composer self-update && composer create-project –prefer-dist cakephp/app cakephp-form
Nous utiliserons la console de commandes à la racine du projet pour ces deux technologies.
Mise en place de la base de données
Symfony
Lors de la création du projet on détermine les accès et le nom de la base de données. Ainsi pour la créer il suffit d’utiliser la commande :
php bin/console doctrine:database:create
Elle prendra automatiquement le nom attribué. Il est également possible de créer la base de données manuellement mais pour cet article nous privilégions les lignes de commandes.
CakePHP
Il est nécessaire de créer manuellement la base de données et de configurer les accès dans le fichier config/app.php :
'username' => 'root',
'password' => 'root',
'database' => 'cakephp-form',Création de l’entité
Symfony
On génère l’entité à l’aide de la commande :
php bin/console doctrine:generate:entity
On nomme l’entité Article et on la place dans le bundle AppBundle comme ceci :
AppBundle:Article
On lui attribue les champs suivants :
- title de type string, de longueur 255, non null et non unique.
- author de type string, de longueur 255, non null et non unique.
- content de type text, non null et non unique.
- created_at de type datetime, non null et non unique.
- modified_at de type datetime, non null et non unique.
Ces commandes permettent ainsi de créer la table Article dans la base de données et de générer entre autres le fichier Article.php dans le dossier src/AppBundle/Entity qui permet de paramétrer l’entité.
Nous pouvons désormais créer la table article dans la base de données en utilisant la commande suivante :
php bin/console doctrine:schema:update –force
Afin de visualiser la ou les requêtes sql qui seront exécutées vous pouvez utiliser la commande :
php bin/console doctrine:schema:update –dump-sql
Nous allons ensuite nous assurer que les champs created_at et modified_at se mettent à jour automatiquement. Pour cela on ajoute ces fonctions dans le fichier src/AppBundle/Entity/Article.php :
/**
* Constructor
*/
public function __construct()
{
$dateTimeNow = new \DateTime();
$this->setCreatedAt($dateTimeNow);
$this->setModifiedAt($dateTimeNow);
}
/**
* @ORM\PreUpdate()
*/
public function onPreUpdate()
{
$this->setModifiedAt(new \DateTime());
} On ajoute également cette notation à notre classe :
@ORM\HasLifecycleCallbacksCakePHP
Nous allons reprendre l’exemple de la table Article que nous ajouterons manuellement en base de données avec les mêmes champs et leurs paramètres et que nous nommerons articles.
- id (clé primaire) de type int, de longueur 11, non null
- title de type string, de longueur 255, non null
- author de type string, de longueur 255, non null
- content de type text, non null
- created de type datetime, non null
- modified de type datetime, non null
À noter que les champs des dates ne sont pas identiques. En effet nous respectons ici les conventions de CakePHP sur les noms des champs de date. Nous verrons à quoi cela servira.
À l’aide de la commande suivante, nous allons générer les fichiers Article.php dans le dossier src/Model/Entity et ArticlesTable.php dans le dossier src/Model/Table.
bin/cake bake model articles
Ces fichiers vont nous permettre de configurer l’entité. Nous pouvons remarquer dans le fichier ArticlesTable.php la présence de la ligne de code :
$this->addBehavior('Timestamp');Cela va permettre de mettre à jour automatiquement les champs created et modified.
Création du controller
Symfony
Nous pouvons générer le controller à l’aide de la commande :
php bin/console generate:controller
Puis le nom de notre entité se situant dans le répertoire AppBundle :
AppBundle:Article
Enfin nous créons l’action d’ajout :
addAction
avec l’url : /articles/add
Il vous sera demandé :
Ce à quoi vous pouvez répondre yes et ainsi générer le fichier de vue pour cette action.
On obtient ainsi le controller ArticleController.php qui nous permettra de manipuler nos articles. On développe ensuite le processus d’ajout d’un article.
<?php
namespace AppBundle\Controller;
use AppBundle\Entity\Article;
use AppBundle\Form\ArticleType;
use Symfony\Bundle\FrameworkBundle\Controller\Controller;
use Sensio\Bundle\FrameworkExtraBundle\Configuration\Route;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\BrowserKit\Response;
class ArticleController extends Controller
{
/**
* @Route("/article/add")
*/
public function addAction(Request $request)
{
// Créé un article
$article = new Article();
// Créé le formulaire de l'article
$form = $this->createForm(ArticleType::class, $article);
// Créé la vue du formulaire
$formView = $form->createView();
// Récupère les données du formulaire
$form->handleRequest($request);
// Si le formulaire a été soumis
if($form->isSubmitted()) {
// Si le formulaire est valide
if($form->isValid()) {
// Récupère l'entity manager
$em = $this->getDoctrine()->getManager();
// Persiste l'article
$em->persist($article);
// Met à jour la base de données et donc ajoute l'article
$em->flush();
}
}
// Retourne la vue
return $this->render(
'@App/Article/add.html.twig',
[
'form' => $formView
]
);
}
} Symfony
De même nous utilisons une commande afin de générer notre controller :
bin/cake bake controller articles
Cette dernière va créer le fichier ArticlesController.php dans le dossier src/Controller. Sont générées automatiquement les méthodes index, view, add, edit et delete. Celle qui nous intéressera sera l’action d’ajout :
/**
* Add method
*
* @return \Cake\Http\Response|null Redirects on successful add, renders view otherwise.
*/
public function add()
{
$article = $this->Articles->newEntity();
if ($this->request->is('post')) {
$article = $this->Articles->patchEntity($article, $this->request->getData());
if ($this->Articles->save($article)) {
$this->Flash->success(__('The article has been saved.'));
return $this->redirect(['action' => 'index']);
}
$this->Flash->error(__('The article could not be saved. Please, try again.'));
}
$this->set(compact('article'));
}Création de la vue et du formulaire
Symfony
Nous allons dans un premier temps générer le formulaire nous permettant de créer des articles à l’aide de la commande :
php bin/console doctrine:generate:form AppBundle:Article
Cette action va créer le fichier ArticleType.php dans le dossier src/AppBundle/Form. Il va nous permettre de configurer le formulaire d’ajout d’articles. Il s’agit de la fonction buildForm.
On y remplace :
$builder->add('titre')->add('contenu')->add('auteur')->add('createdAt')->add('modifiedAt'); par
$builder
->add('title', TextType::class, [
'label' => 'Titre'
])
->add('author', TextType::class, [
'label' => 'Auteur'
])
->add('content', TextareaType::class, [
'label' => 'Contenu'
]); afin d’obtenir un meilleur formulaire avec un label pour chaque champ que nous souhaitons. On ajoute également les librairies suivantes :
use Symfony\Component\Form\Extension\Core\Type\TextType;
use Symfony\Component\Form\Extension\Core\Type\TextareaType;Nous avons précédemment généré la vue lors de la création du controller et de l’action d’ajout dans src/AppBundle/Resources/views/Article/add.html.twig. On peut ainsi y implémenter le code suivant pour intégrer le formulaire :
<h1>Ajout d'un article</h1>
{{ form_start(form) }}
{{ form_widget(form) }}
<button type="submit">Créer l'article</button>
{{ form_end(form) }}
La variable Form provient de la méthode addAction que nous avons créé précédemment.
Vous pouvez désormais créer un article.
Url : /articles/add
CakePHP
On crée la vue add.ctp dans le dossier src/Template/Articles et on y intègre directement notre formulaire :
<?php
/**
* @var \App\View\AppView $this
* @var \App\Model\Entity\Article $article
*/
?>
<nav class="large-3 medium-4 columns" id="actions-sidebar">
<ul class="side-nav">
<li class="heading"><?= __('Actions') ?></li>
<li><?= $this->Html->link(__('List Articles'), ['action' => 'index']) ?></li>
</ul>
</nav>
<div class="articles form large-9 medium-8 columns content">
<?= $this->Form->create($article) ?>
<fieldset>
<legend><?= __('Add Article') ?></legend>
<?php
echo $this->Form->control('title');
echo $this->Form->control('author');
echo $this->Form->control('content');
?>
</fieldset>
<?= $this->Form->button(__('Submit')) ?>
<?= $this->Form->end() ?>
</div> Il est également possible d’utiliser la commande :
bin/cake bake template articles
Afin de générer les pages de vue index, view, add et edit et leurs formulaires associés. C’est cette méthode que nous utiliserons.
Il vous est ainsi possible de créer des articles.
Url : /articles/add
Conclusion
Lignes de commandes
L’utilisation des lignes de commandes est assez équivalente pour les deux frameworks.
Nous pouvons noter comme vu dans cet article la possibilité de créer une entité et ses champs directement en lignes de commandes sur Symfony.
Sur CakePHP nous avons vu qu’il est possible de générer l’ensemble des fichiers de vue et des algorithmes dans le controller afin développer un CRUD. Qu’est ce qu’un CRUD ?
Entity Manager
Il est nécessaire sur Symfony de faire appel manuellement à l’ORM Doctrine, c’est à dire l’outil qui va nous permettre de manipuler nos entités. On persiste notre entité puis on flush. Sur CakePHP nous pouvons directement manipuler nos entités en utilisant $this->{nom_entite}->{fonction}.
Création de formulaire
Sur Symfony on paramètre les formulaires dans le dossier Form. On y fait appel dans le controller d’où on l’envoie vers la vue. Sur CakePHP il n’y a pas d’emplacement destiné mais nous pouvons utiliser un helper qui permet de plus facilement utiliser des formulaires dans nos vues.
Routage
CakePHP nous permet de ne pas avoir à configurer les routes si on respectent ses conventions. En effet pour une méthode appelée add si sa vue se nomme également add alors l’association du routage s’effectue automatiquement. On peut également personnaliser les routes dans le fichier de config routes.php.
Sur Symfony la configuration des routes peut se faire ou bien dans le fichier de config routing.yml ou bien directement dans le controller en annotations par exemple.
Mon avis
CakePHP a une notoriété bien plus faible que Symfony, cependant je trouve ce dernier plus agréable à manipuler tant sa prise en main est accessible et moins complexe que Symfony. De même ses spécificités nous permettent de grandement réduire notre temps de travail notamment si on suit ses conventions ce qui permet également de maintenir une certaine rigueur tout au long du développement d’un projet.
