Symfony : – Les Formulaires Réutilisables

Les formulaires configurés directement dans les contrôleurs sont utiles pour des cas simples, mais cette méthode devient rapidement inefficace pour des applications complexes. Symfony permet de définir des formulaires dans des classes dédiées, ce qui facilite leur réutilisation, leur maintenance, et leur clarté.

Définir un Formulaire avec la Classe AbstractType

Pour définir un formulaire, Symfony fournit la classe AbstractType, qui simplifie la configuration des formulaires en offrant des méthodes préconfigurées. Vous pouvez l’utiliser pour créer des formulaires personnalisés ou étendre les types existants.

Exemple de Formulaire : ClientType

Voici un exemple de formulaire destiné à la gestion des coordonnées d’un client :

namespace App\Form\Type;

use Symfony\Component\Form\AbstractType;
use Symfony\Component\Form\FormBuilderInterface;
use Symfony\Component\OptionsResolver\OptionsResolver;
use Symfony\Component\Form\Extension\Core\Type\TextType;
use Symfony\Component\Form\Extension\Core\Type\TextareaType;
use Symfony\Component\Form\Extension\Core\Type\BirthdayType;

class ClientType extends AbstractType
{
    public function buildForm(FormBuilderInterface $builder, array $options)
    {
        $builder
            ->add('nom', TextType::class)
            ->add('prenom', TextType::class)
            ->add('adresse', TextareaType::class)
            ->add('date_de_naissance', BirthdayType::class, [
                'required' => false,
            ]);
    }

    public function configureOptions(OptionsResolver $resolver)
    {
        $resolver->setDefaults([
            'validation_groups' => 'Coordonnées',
        ]);
    }
}
  • buildForm() : Configure les champs du formulaire.
  • configureOptions() : Définit les options par défaut du formulaire.

Héritage de Types avec getParent()

Vous pouvez créer des types personnalisés en héritant des types existants grâce à la méthode getParent(). Cela est utile pour adapter les types Symfony à vos besoins.

namespace App\Form\Type;

use Symfony\Component\Form\AbstractType;

class MaDateType extends AbstractType
{
    public function getParent()
    {
        return 'date'; // Le type parent
    }
}

Options Avancées avec OptionsResolver

La méthode configureOptions() utilise le composant OptionsResolver pour définir, modifier ou créer des options de formulaire.

Exemple d’Options Personnalisées :

namespace App\Form\Type;

use Symfony\Component\Form\AbstractType;
use Symfony\Component\OptionsResolver\OptionsResolver;

class MaDateType extends AbstractType
{
    public function configureOptions(OptionsResolver $resolver)
    {
        $resolver->setDefaults([
            'years' => range(date('Y') - 1, date('Y') + 1), // Années restreintes
            'use_jquery' => false, // Option personnalisée
        ]);
    }
}

Normalisation d’Options :

Vous pouvez transformer ou valider dynamiquement les options avec setNormalizer() :

$resolver->setNormalizer('widget', function (Options $options, $value) {
    return $options['use_jquery'] ? 'single_text' : $value;
});

Utilisation d’un Formulaire Déclaré

Une fois votre formulaire défini dans une classe, vous pouvez l’utiliser dans vos contrôleurs.

a. Définition Manuelle

Vous spécifiez directement le type de formulaire dans le contrôleur :

use App\Form\Type\ClientType;

#[Route("/")]
public function index(Request $request)
{
    $client = new Client();
    $form = $this->createForm(ClientType::class, $client);

    $form->handleRequest($request);

    if ($form->isSubmitted() && $form->isValid()) {
        return new Response('Le formulaire est valide.');
    }

    return $this->render('default/index.html.twig', [
        'form' => $form->createView()
    ]);
}

b. Utilisation avec l’Injection de Dépendances

Pour les types réutilisables (CAPTCHA, plugins spécifiques, etc.), vous pouvez les enregistrer comme services dans services.yaml :

# config/services.yaml
services:
    app.form.type.ma_date:
        class: App\Form\Type\MaDateType
        tags:
            - { name: form.type, alias: ma_date }

Dans le contrôleur, utilisez l’alias pour inclure le type dans un formulaire :

$form = $this->createFormBuilder($client)
    ->add('date_de_naissance', 'ma_date', ['use_jquery' => true])
    ->getForm();

Personnalisation Avancée avec buildView()

La méthode buildView() permet de modifier les données transmises aux templates via FormView. Par exemple, vous pouvez personnaliser un type pour utiliser un plugin jQuery tout en désactivant le calendrier natif des navigateurs HTML5 :

namespace App\Form\Type;

use Symfony\Component\Form\AbstractType;
use Symfony\Component\Form\FormView;
use Symfony\Component\Form\FormInterface;

class MaDateType extends AbstractType
{
    public function buildView(FormView $view, FormInterface $form, array $options)
    {
        if ('single_text' === $options['widget'] && $options['use_jquery']) {
            $view->vars['type'] = 'text'; // Forcer un champ texte
        }
    }
}

  1. Clarté et Maintenance : Le code des contrôleurs est simplifié et les formulaires sont clairement définis.
  2. Réutilisation : Les types peuvent être partagés entre plusieurs contrôleurs ou projets.
  3. Personnalisation : Les options et comportements peuvent être ajustés dynamiquement via OptionsResolver.
  4. Consistance : Garantit un style et une structure uniformes pour tous les formulaires d’une application.

Les formulaires réutilisables avec AbstractType sont une des meilleures pratiques pour organiser le code d’une application Symfony. Ils permettent d’obtenir un code modulaire, flexible et facile à maintenir, tout en favorisant la réutilisation des types à travers différents projets.

Sites Ressources e-Plus Pour Laravel 11

1. Packagist Description : Le principal dépôt de packages PHP, avec une catégorie spécifique pour Laravel. Lien : https://packagist.org Ressources :...