Zum Inhalt springen

Einleitung

Dieses Tutorial hat in seiner Ursprungsversion von 2017 die ersten Schritte mit dem damals neuen TYPO3 Form Framework beschrieben: von der Grund­konfiguration im eigenen Sitepackage bis zu individuellen Formular-Templates, für die ich den Weg eines neuen Prototypen gewählt hatte.

In seiner heutigen Fassung liegt der Schwerpunkt auf der Frage, wie ihr mittels Prototypen Formular-spezifische Templates zuweist und wie ihr (und eure Redakteure) mit mehreren Prototypen arbeiten könnt.
Ich habe mich aber dagegen entschieden, die Grundkonfiguration komplett aus dem Tutorial zu entfernen.

Dieses Tutorial beschreibt eine von drei Lösungen für individuelle Formular-Templates. Zum Vergleich der Lösungswege mit Vor-/Nachteilen und passenden Anwendungsfällen.

1. Grundkonfiguration des Form Framework

Die Konfiguration der Form-Extension erfolgt komplett über YAML: Diese Auszeichnungs­sprache wurde mit Version 8 in TYPO3 eingeführt und ist dort auch für die Konfiguration des neuen Richtext-Editors CKEditor zuständig. Gerade für das Form Framework gibt es eine Vielzahl von Konfigurationen, da es bewusst flexibel gehalten wurde.

Ein großer Vorteil gegenüber den erprobten Formular-Extensions wie Powermail ist, dass jedes erstellte Formular inklusive Felder, Validierungen und der Verarbeitung der übermittelten Daten (über die sogenannten Finisher) als YAML-Datei exportiert wird. Diese Dateien werden vom Form-Backend-Modul per Default im fileadmin gespeichert, können aber in Template-Extensions ausgelagert und versioniert werden. So ist es einfach möglich, Formulare als Gesamtpaket in andere TYPO3-Installationen zu übertragen.

Mittels YAML-Konfiguration kann man auch einrichten, dass man die in eine Extension ausgelagerten Formulare wieder im Backend-Modul bearbeiten kann. Diese Einstellung füge ich gleich ebenfalls hinzu.

Dateistruktur

Als Speicherort dient in diesem Tutorial ein Sitepackage, dessen Ordnerstruktur auf TYPO3 Extbase-Extensions beruht:

  • ext_typoscript_setup.typoscript
    Die hier enthaltenen Konfigurationen werden direkt nach Installation der Extension verwendet.
  • Configuration/Yaml/CustomFormSetup.yaml
    Mit dieser Datei konfigurieren wir das Form Framework nach unseren Vorstellungen.
  • Resources/Private/Forms/
    Hier werden die erstellen Formulare gespeichert.
  • Resources/Private/Frontend/Partials/
    Speicherort für angepasste Frontend Partials.
  • Resources/Private/Frontend/Templates/
    Speicherort für angepasste Frontend Templates.

Analog hierzu speichert man geänderte Templates für das Backend-Modul im Unterordner Resources/Private/Backend/Templates/. Beachtet bitte, dass ihr innerhalb dieser Ordner weiterhin die Ordnerstruktur und Dateibezeichnung von EXT:form beibehaltet: Das kleine Partial für den Pflichtfeld-Hinweis müsste im Ordner Resources/Private/Frontend/Partials/Field/Required.html gespeichert werden.

Anmerkung: Die für ein Sitepackage notwendige Extension-Konfiguration (z.B. composer.json) ist hier nicht extra beschrieben.

YAML-Konfiguration mit TypoScript einbinden

Zuerst einmal setzen wir über TypoScript den Pfad zu der YAML-Datei, mit der wir die Default-Konfigurationen überschreiben werden. Da die Nummern 10-30 bereits von EXT:form reserviert sind, starten wir einfach mit der Nummer 100, um unseren Pfad zum Array der Dateipfade hinzufügen.

Weil wir diese Datei auch für Konfigurationen im Backend verwenden werden, verlinken wir dies sowohl im Top Level Object plugin als auch unter module.

ext_typoscript_setup.typoscript:

plugin.tx_form.settings.yamlConfigurations {
    100 = EXT:my_extension/Configuration/Yaml/CustomFormSetup.yaml
}

module.tx_form.settings.yamlConfigurations {
    100 = EXT:my_extension/Configuration/Yaml/CustomFormSetup.yaml
}

YAML-Konfiguration anlegen

Nun erstellen wir die oben verlinkte Konfigurationsdatei, in der wir folgende Dinge einrichten:

  1. Wir legen mit allowedExtensionPaths fest, wo unsere erstellten Formulare gespeichert werden
  2. Mit allowSaveToExtensionPaths und allowDeleteFromExtensionPaths können Formulare im Backend-Modul gespeichert und auch gelöscht werden. Überlegt euch ob ihr ggf. darauf verzichtet, falls Redakteure Zugriff auf das Modul erhalten sollen.

CustomFormSetup.yaml:

TYPO3:
  CMS:
    Form:
      persistenceManager:
        allowedExtensionPaths:
          10: EXT:my_extension/Resources/Private/Forms/
        allowSaveToExtensionPaths: true
        allowDeleteFromExtensionPaths: true

Ab diesem Zeitpunkt können wir im Backend neue Formulare erstellen und im Sitepackage speichern.

2. Eigene Formular-Prototypen

Jedes Formular basiert auf einem sogenannten Prototyp. Für diesen Prototyp werden alle erforderlichen Formularfelder, Validatoren und Finisher konfiguriert. Auch die Pfade zu Frontend-Templates und XLIFF-Sprachdateien werden im Prototyp definiert.

Alle im Form Framework mitgelieferten Konfigurationen beziehen sich auf den standard-Prototyp.

Die Konfiguration eigener Prototypen hat diverse Vorteile. Prototypen beeinflussen nicht nur das Frontend, sondern auch den Form Editor im Backend sowie die Plugin-Overrides.
Für Formulare, die auf einem eigenen Prototyp basieren, könnt ihr beispielsweise:

  • abweichende Template-Pfade und CSS-Klassen definieren
  • im Form Editor nur noch Textfelder und Checkboxen zur Verfügung stellen und
  • alle Finisher bis auf den SaveToDatabase-Finisher entfernen;
  • im Plugin den Override eines neuen Finishers erlauben

Einrichtung des eigenen Formular-Prototyps

Die Grundeinrichtung steht, im nächsten Schritt ergänzen wir in der CustomFormSetup.yaml einen eigenen Prototyp:

TYPO3:
  CMS:
    Form:
      prototypes:
        complaintForm:
          __inheritances:
            10: 'TYPO3.CMS.Form.prototypes.standard'
          formElementsDefinition:
            Form:
              renderingOptions:
                templateRootPaths:
                  100: 'EXT:form_examples/Resources/Private/Frontend/Templates/ComplaintForm/'
                partialRootPaths:
                  100: 'EXT:form_examples/Resources/Private/Frontend/Partials/ComplaintForm/'
                layoutRootPaths:
                  100: 'EXT:form_examples/Resources/Private/Frontend/Layouts/ComplaintForm/'
            SingleSelect:
              properties:
                elementClassAttribute: 'custom-select'

Dieser neue Prototyp erhält den (frei wählbaren) Namen complaintForm. Mit dem Operator __inheritances kopieren wir die aktuelle Konfiguration des Prototyp standard. Alternativ könnten wir die im eigenen Prototyp verfügbaren Formularfelder, Validatoren und Finisher selektiv ergänzen.

Anschließend definieren wir die gewünschten Template-Pfade sowie eine spezielle CSS-Klasse für Select-Felder.

Der neue Formular-Prototyp könnte ab jetzt von TYPO3-Integratoren manuell in YAML zugewiesen werden.

Formularvorlage erstellen

Da wir weiter unten den Prototyp im Backend bereitstellen werden, müssen wir noch ein Start-Template für neu erstelltes Formulare definieren. Dabei handelt es sich um ein normales Formular, das als Auswahl im Form Manager ergänzt wird.

renderingOptions:
  submitButtonLabel: Submit
identifier: CustomPrototypeExample
label: 'Example - Custom prototype (complaint form)'
type: Form
prototypeName: complaintForm
finishers:
  -
    options:
      message: 'Oops! No email was sent. Anyway, have a great day! ????'
    identifier: Confirmation
renderables:
  -
    renderingOptions:
      previousButtonLabel: 'Previous step'
      nextButtonLabel: 'Next step'
    identifier: page-1
    label: Complaint
    type: Page
    renderables:
      -
        defaultValue: ''
        identifier: name
        label: Name
        type: Text
        properties:
          fluidAdditionalAttributes:
            required: required
        validators:
          -
            identifier: NotEmpty
      -
        defaultValue: ''
        identifier: email
        label: Email
        type: Text
        properties:
          fluidAdditionalAttributes:
            required: required
        validators:
          -
            identifier: NotEmpty
          -
            identifier: EmailAddress
      -
        properties:
          options:
            'This form is ridiculous': 'This form is ridiculous'
          prependOptionLabel: 'Please select …'
          fluidAdditionalAttributes:
            required: required
        type: SingleSelect
        identifier: issue
        label: Issue
        validators:
          -
            identifier: NotEmpty
  -
    renderingOptions:
      previousButtonLabel: 'Previous step'
      nextButtonLabel: 'Next step'
    identifier: summarypage
    label: 'Summary page'
    type: SummaryPage

Prototyp-Auswahl für Redakteure

Damit auch Redakteure alternative Prototypen verwenden können, müssen wir die zur Auswahl stehenden Prototypen im Form Manager registrieren.

TYPO3:
  CMS:
    Form:
      formManager:
        selectablePrototypesConfiguration:
          200:
            identifier: complaintForm
            label: 'Beschwerdeformular'
            newFormTemplates:
              100:
                templatePath: 'EXT:form_examples/Resources/Private/Forms/CustomPrototypeExample.form.yaml'
                label: 'Beschwerdeformular (Start template)'

Schauen wir uns die Konfiguration im Detail an:

  • Unterhalb von selectablePrototypesConfiguration vergeben wir einen neuen Key. Für den standard-Prototyp wird der Key 100 genutzt.
  • Als identifier müssen wir den exakten Namen unseres eigenen Prototyps angeben.
  • Unterhalb von newFormTemplates vergeben wir erneut einen selbst gewählten Key.
  • Der templatePath verweist auf das Beispielformular mit dem Prototyp complaintForm.
  • label: Hier könnte man auch XLIFF-Keys für mehrsprachige Labels verwenden.

Mit diesen Einstellungen ist der neue Prototyp mit einer (notwendigen) Formularvorlage im Backend-Modul verfügbar. Ihr könnt auch mehr als eine Formularvorlage je Prototyp bereitstellen. Im Form Framework wird dieses Konzept "Start templates" genannt.

Der Redakteur kann im Backend-Modul "Formulare" nun ein neues Formular erstellen und im ersten Modal die Auswahl "Vordefiniertes Formular" treffen. Im nachfolgenden Modal wählt er zuerst den gewünschten Formular-Prototyp, danach die bereitgestellte Formularvorlage.
Die Auswahl "Formular-Prototyp" wird im Backend erst angezeigt, wenn mehr als nur der standard-Prototyp registriert wurde.

Demo

Den Prototypen, das Beispielformular und die weitere Konfiguration findet ihr in der TYPO3-Extension "form_examples". Für den Form Manager habe ich dort weitere Prototypen und Formularvorlagen ergänzt. Die vor kurzem aktualisierte Fassung der Extension ist für TYPO3 v10 bis v12 in eigenen, jeweils optimierten Branches verfügbar.

form_examples auf GitHub

Fazit

Das Konzept der Formular-Prototypen sind ein mächtiges Werkzeug. Es bleibt aber vom Projekt abhängig, ob man mehr als nur den standard-Prototyp benötigt und ob man sie Redakteuren zur Verfügung stellt.

Wenn es nur um abweichendes Formular-Styling geht, gibt es auch zwei weitere Möglichkeiten – diese habe ich in diesem Beitrag verglichen.