Contao 5 Symfony Forms: Professionelle Formularverarbeitung

1<?php
2
3namespace Acme\BeachsideBundle\Form;
4
5use Acme\BeachsideBundle\Entity\Booking;
6use Symfony\Component\Form\AbstractType;
7use Symfony\Component\Form\Extension\Core\Type\DateType;
8use Symfony\Component\Form\Extension\Core\Type\SubmitType;
9use Symfony\Component\Form\Extension\Core\Type\TextType;
10use Symfony\Component\Form\FormBuilderInterface;
11use Symfony\Component\OptionsResolver\OptionsResolver;
12
13class BookingType extends AbstractType
14{
15    public function buildForm(FormBuilderInterface $builder, array $options): void
16    {
17        $builder
18            ->add('customerName', TextType::class, [
19                'label' => 'Ihr vollständiger Name',
20                'attr' => [
21                    'placeholder' => 'z.B. Max Mustermann',
22                    'class' => 'form-control'
23                ],
24                // HTML5 required Attribut
25                'required' => true, 
26            ])
27            ->add('dateStart', DateType::class, [
28                'label' => 'Anreisedatum',
29                'widget' => 'single_text', // Rendert ein modernes <input type="date">
30                // Da unsere Entity Integer-Timestamps erwartet (siehe Teil 4),
31                // transformiert Symfony das Datum hier automatisch, wenn konfiguriert, 
32                // oder wir übergeben Datetime Objekte. Für dieses Beispiel nutzen wir den Standard.
33                'input'  => 'datetime_immutable', 
34                'required' => true,
35            ])
36            ->add('dateEnd', DateType::class, [
37                'label' => 'Abreisedatum',
38                'widget' => 'single_text',
39                'input'  => 'datetime_immutable',
40                'required' => true,
41            ])
42            ->add('submit', SubmitType::class, [
43                'label' => 'Kostenpflichtig buchen',
44                'attr' => ['class' => 'btn btn-primary mt-3']
45            ])
46        ;
47    }
48
49    public function configureOptions(OptionsResolver $resolver): void
50    {
51        $resolver->setDefaults([
52            // Magic passiert hier: Wir binden das Formular an unsere Entity!
53            'data_class' => Booking::class,
54            
55            // CSRF-Schutz ist standardmäßig aktiviert, aber hier machen wir es explizit
56            'csrf_protection' => true,
57            'csrf_field_name' => '_token',
58            'csrf_token_id'   => 'booking_item',
59        ]);
60    }
61}

1<?php
2
3namespace Acme\BeachsideBundle\Controller\ContentElement;
4
5use Acme\BeachsideBundle\Entity\Booking;
6use Acme\BeachsideBundle\Form\BookingType;
7use Doctrine\ORM\EntityManagerInterface;
8use Contao\ContentModel;
9use Contao\CoreBundle\Controller\ContentElement\AbstractContentElementController;
10use Contao\CoreBundle\DependencyInjection\Attribute\AsContentElement;
11use Contao\CoreBundle\Twig\FragmentTemplate;
12use Symfony\Component\Form\FormFactoryInterface;
13use Symfony\Component\HttpFoundation\Request;
14use Symfony\Component\HttpFoundation\Response;
15
16#[AsContentElement(category: 'beachside', template: 'content_element/booking_form')]
17class BookingFormElementController extends AbstractContentElementController
18{
19    public function __construct(
20        private readonly FormFactoryInterface $formFactory,
21        private readonly EntityManagerInterface $entityManager
22    ) {
23    }
24
25    protected function getResponse(FragmentTemplate $template, ContentModel $model, Request $request): Response
26    {
27        // 1. Eine leere Booking-Entity erstellen (oder eine bestehende laden)
28        $booking = new Booking();
29
30        // Optional: Vorbelegung der Entity, z.B. den Strandkorb aus der URL oder Session holen
31        // $booking->setBeachChair($selectedChair);
32
33        // 2. Das Formular über die FormFactory generieren
34        $form = $this->formFactory->create(BookingType::class, $booking);
35
36        // 3. Den Request an das Formular übergeben (Magie passiert hier!)
37        $form->handleRequest($request);
38
39        // 4. Prüfen, ob das Formular abgeschickt UND valide ist
40        if ($form->isSubmitted() && $form->isValid()) {
41            
42            // $form->getData() liefert uns das fertig befüllte Booking-Objekt zurück!
43            /** @var Booking $bookingData */
44            $bookingData = $form->getData();
45
46            // Zusätzliche Logik: Datum der Buchungserstellung setzen
47            $bookingData->setTstamp(time());
48
49            // Daten in der Datenbank speichern (Doctrine)
50            $this->entityManager->persist($bookingData);
51            $this->entityManager->flush();
52
53            // Erfolgsmeldung im Template setzen (Alternativ: Redirect auf eine Danke-Seite)
54            $template->set('success', true);
55            return $template->getResponse();
56        }
57
58        // 5. Das Formular-View-Objekt an das Twig-Template übergeben
59        $template->set('form', $form->createView());
60
61        return $template->getResponse();
62    }
63}

1{% extends "@Contao/content_element/_base.html.twig" %}
2
3{# 
4   FORM THEME MAGIC: 
5   Wir sagen Twig, dass es für dieses Formular das Bootstrap 5 Layout nutzen soll.
6   Dadurch erhalten alle Felder automatisch Klassen wie 'form-control' oder 'form-label'.
7#}
8{% form_theme form 'bootstrap_5_layout.html.twig' %}
9
10{% block content %}
11    <div>
12        
13        {% if success %}
14            <div>
15                <h3>Vielen Dank für Ihre Buchung!</h3>
16                <p>Wir haben Ihre Anfrage erhalten und melden uns in Kürze.</p>
17            </div>
18        {% else %}
19            
20            <h3>Strandkorb jetzt buchen</h3>
21            
22            {# form_start generiert das <form> Tag und das CSRF-Token #}
23            {{ form_start(form, {'attr': {'class': 'needs-validation'}}) }}
24            
25                {# Wir können Fehler für das gesamte Formular hier ausgeben #}
26                {{ form_errors(form) }}
27
28                <div>
29                    <div>
30                        {# form_row rendert Label, Input, Fehler und Help-Text auf einmal #}
31                        {{ form_row(form.customerName) }}
32                    </div>
33                </div>
34
35                <div>
36                    <div>
37                        {{ form_row(form.dateStart) }}
38                    </div>
39                    <div>
40                        {{ form_row(form.dateEnd) }}
41                    </div>
42                </div>
43
44                <div>
45                    {# Den Submit Button manuell platzieren #}
46                    {{ form_row(form.submit) }}
47                </div>
48
49            {# form_end schließt das Tag und rendert versteckte Felder (wie das CSRF-Token!) #}
50            {{ form_end(form) }}
51            
52        {% endif %}
53        
54    </div>
55{% endblock %}

twig:
    form_themes: ['bootstrap_5_layout.html.twig']

1<?php
2
3namespace Acme\BeachsideBundle\Validator;
4
5use Symfony\Component\Validator\Constraint;
6
7#[\Attribute(\Attribute::TARGET_CLASS)]
8class BeachChairAvailable extends Constraint
9{
10    // Die Standard-Fehlermeldung
11    public string $message = 'Der Strandkorb ist in diesem Zeitraum leider schon belegt.';
12
13    // Wichtig: Wir wollen das gesamte Objekt (Start, End, Chair) prüfen, nicht nur ein einzelnes Feld.
14    public function getTargets(): string|array
15    {
16        return self::CLASS_CONSTRAINT;
17    }
18}

1<?php
2
3namespace Acme\BeachsideBundle\Validator;
4
5use Acme\BeachsideBundle\Entity\Booking;
6use Acme\BeachsideBundle\Service\AvailabilityChecker;
7use Symfony\Component\Validator\Constraint;
8use Symfony\Component\Validator\ConstraintValidator;
9use Symfony\Component\Validator\Exception\UnexpectedTypeException;
10
11class BeachChairAvailableValidator extends ConstraintValidator
12{
13    public function __construct(
14        private readonly AvailabilityChecker $checker
15    ) {
16    }
17
18    public function validate($value, Constraint $constraint): void
19    {
20        if (!$constraint instanceof BeachChairAvailable) {
21            throw new UnexpectedTypeException($constraint, BeachChairAvailable::class);
22        }
23
24        // Da wir es als Class-Constraint nutzen, ist $value unsere Booking Entity!
25        if (!$value instanceof Booking) {
26            return;
27        }
28
29        // Wenn Felder leer sind, übernimmt das die Standard-Required-Validierung
30        if (!$value->getBeachChair() || !$value->getDateStart() || !$value->getDateEnd()) {
31            return;
32        }
33
34        // Datumskontrolle: Abreise vor Anreise?
35        if ($value->getDateStart() >= $value->getDateEnd()) {
36            $this->context->buildViolation('Das Abreisedatum muss nach dem Anreisedatum liegen.')
37                ->atPath('dateEnd') // Fehler direkt an das Feld "dateEnd" heften
38                ->addViolation();
39            return;
40        }
41
42        // Business-Logik: Ist der Strandkorb frei?
43        $isFree = $this->checker->isAvailable(
44            $value->getBeachChair(), 
45            $value->getDateStart(), 
46            $value->getDateEnd()
47        );
48
49        if (!$isFree) {
50            // Fehler an das Formular hängen
51            $this->context->buildViolation($constraint->message)
52                ->addViolation();
53        }
54    }
55}

1<?php
2
3namespace Acme\BeachsideBundle\Entity;
4
5use Acme\BeachsideBundle\Validator\BeachChairAvailable; // Importieren!
6use Doctrine\ORM\Mapping as ORM;
7
8#[ORM\Entity]
9#[ORM\Table(name: "tl_booking")]
10#[BeachChairAvailable] // <-- HIER IST DIE MAGIE!
11class Booking
12{
13    // ... restlicher Code ...
14}

1<?php
2
3namespace Acme\BeachsideBundle\Controller\ContentElement;
4
5// ... bisherige Imports ...
6use Symfony\Bridge\Twig\Mime\TemplatedEmail;
7use Symfony\Component\Mailer\MailerInterface;
8use Symfony\Component\Mime\Address;
9
10#[AsContentElement(category: 'beachside', template: 'content_element/booking_form')]
11class BookingFormElementController extends AbstractContentElementController
12{
13    public function __construct(
14        private readonly FormFactoryInterface $formFactory,
15        private readonly EntityManagerInterface $entityManager,
16        private readonly MailerInterface $mailer // <-- NEU: Symfony Mailer injizieren
17    ) {
18    }
19
20    protected function getResponse(FragmentTemplate $template, ContentModel $model, Request $request): Response
21    {
22        $booking = new Booking();
23        $form = $this->formFactory->create(BookingType::class, $booking);
24        $form->handleRequest($request);
25
26        if ($form->isSubmitted() && $form->isValid()) {
27            
28            /** @var Booking $bookingData */
29            $bookingData = $form->getData();
30            $bookingData->setTstamp(time());
31
32            $this->entityManager->persist($bookingData);
33            $this->entityManager->flush();
34
35            // --------------------------------------------------
36            // NEU: E-Mail Versand aufbauen
37            // --------------------------------------------------
38            $email = (new TemplatedEmail())
39                ->from(new Address('no-reply@beachside.de', 'Strandkorbvermietung Binz'))
40                // In einer echten App würden wir die Kunden-Mail aus dem Formular holen.
41                // Fürs Beispiel schicken wir es an den Admin.
42                ->to('admin@beachside.de')
43                ->subject('Neue Strandkorb-Buchung eingegangen!')
44                
45                // Pfad zum Twig-Template für die E-Mail
46                ->htmlTemplate('@AcmeBeachside/emails/booking_notification.html.twig')
47                
48                // Variablen an das E-Mail-Template übergeben
49                ->context([
50                    'booking' => $bookingData,
51                ]);
52
53            // E-Mail absenden
54            $this->mailer->send($email);
55            // --------------------------------------------------
56
57            $template->set('success', true);
58            return $template->getResponse();
59        }
60
61        $template->set('form', $form->createView());
62        return $template->getResponse();
63    }
64}

1{# templates/emails/booking_notification.html.twig #}
2<!DOCTYPE html>
3<html>
4<head>
5    <meta charset="UTF-8">
6    <title>Neue Buchung</title>
7</head>
8<body>
9    <h1>Neue Strandkorb-Buchung!</h1>
10    
11    <p>Hallo Admin,</p>
12    <p>es ist eine neue Buchung über die Website eingegangen:</p>
13    
14    <ul>
15        <li><strong>Kunde:</strong> {{ booking.customerName }}</li>
16        <li><strong>Strandkorb:</strong> Nr. {{ booking.beachChair.chairNumber }}</li>
17        <li><strong>Von:</strong> {{ booking.dateStart|format_date('medium') }}</li>
18        <li><strong>Bis:</strong> {{ booking.dateEnd|format_date('medium') }}</li>
19    </ul>
20
21    <p>Bitte logge dich ins Contao-Backend ein, um die Details zu prüfen.</p>
22</body>
23</html>