TYPO3 - Extensions mit Extbase programmieren

Links

Extbase und Extension Builder

http://wiki.typo3.org/T3Doc/Extension_Builder/Using_the_Extension_Builder

http://docs.typo3.org/typo3cms/extensions/extension_builder/

http://docs.typo3.org/typo3cms/ExtbaseGuide/Extbase/FirstExtbaseExtension.html

Fluid

TYPO3 - Fluid Templates

https://fluidtypo3.org/documentation/templating-manual/introduction.html

Debugging in TYPO3 v5=

Installtool:

Wer im Frontend eine weiße leere Seite erhält muss im Installtool folgende Einstellungen zum Debuggen setzen:

devIPmask = Deine öffentliche IP-Adresse (www.wieistmeineip.de)
sqlDebug = 1
displayErrors = 1
debug = 1

Überblick

MVC

Extbase Extensions arbeiten nach dem Model-View-Controller Prinzip und sollten nach dem Domain Driven Design entwickelt werden. D.h. man entwickelt in Hinblick auf den Einsatzzweck und die Funktionalität das Datenmodell. Dies landet in den Model Dateien. Wie die Daten in der Ausgabe dargestellt werden gehört in den View bzw. die dafür zuständigen Datein. Die Funktionalität wird über den Controller abgebildet. Er ist sozusagen vermittler zwischen Model und View. Auf diese Weise sind Ansichten, Daten und Funktionalität sauber voneinander getrennt. Auch für die einzelnen Funktionalitäten benutzt man getrennte Controller. So bleiben Dateien im Controller übersichtlich.

Datenbankzugriffe

Mit Extbase greift Ihr nicht mehr direkt auf die Datenbank zu. Extbase liest praktisch Eure Klassen- und Variablennamen aus und sucht anhand dieser Namen Tabellen mit den gleichen Namen in der Datenbank

Wo finde ich was in Extbase ?

Frontend Plugin einbinden

1. Registrieren des Plugins

ext_tables.php

Tx_Extbase_Utility_Extension::registerPlugin(
    $_EXTKEY,
    'Pi1',
    'Mein erstes Fluid-Template'
);

Parameter:

1. Name der Extension. Variable $EXTKEY erspart etwas Arbeit
2. eindeutiger Name des Plugins. Erster Buchstabe großgeschrieben. Gängige Namenskonvention in TYPO3 mit pi1, pi2, pi3, ...
3. Text, der in der Selectbox der Pluginauswahl erscheinen soll.

2. Konfigurieren des Plugins

Hiermit zeigt man Typo3 wo der Code zu finden ist.

ext_localconf.php

Tx_Extbase_Utility_Extension::configurePlugin(
    $_EXTKEY,
    'Pi1',
    array(

        'Blabla' => 'testblabla',
    )
);

Parameter:

1. Name der Extension (s.o.)
2. Eindeutigen Namen unseres Plugins (s.o.)
3. Array in dem als Key (hier: Blabla) der Wert "testblabla" übergeben wird. Wie ich oben schon gesagt habe, bastelt das FLOW3-Prinzip sich die Funktions- und Objektnamen selbst zusammen.

In diesem Beispiel würde TYPO3 einen Controller suchen der als Klasse Tx_Sffluid_Controller_BlablaController angelegt ist. Der Name weist auch auf die Verzeichnisstruktur hin in der die Datei liegen sollte:

• Tx = Rootverzeichnis für installierte Extensions. Meist: typo3conf/ext
• extkey = Verzeichnis innerhalb des Extensionrootverzeichnisses lautet wie der extensionkey
• Controller = Unterverzeichnis von Classes. Classes ist ein Ordner, der bei Extbase-Projekten zwingend vorhanden sein muss.
• BlablaController = Dateiname (.php) im Ordner Controller

Es wird also im Verzeichnis:

typo3conf/ext/extkey/Classes/Controller 

eine Datei mit dem Namen

BlablaController.php 

erwartet, die eine Klasse

Tx_Sffluid_Controller_BlablaController 

enthält.

In der Konfiguration können mehrere Actions aufgelistet werden, die erste ist die default Action:

...
    array(
        'Blabla' => 'testblabla, bearbeiten, delete, auflisten',
    )
...

Templates

Typo sucht die Templates automatisch in folgender Struktur:

Resources/Private/Templates/[Controller]/[Action].html

Hier kann man Variablen nutzen die in geschweiften Klammern stehen.

Hallo {name}, wie geht es Dir?

Die Variablen werden im zugehörigen Controller gefüttert:

class Tx_Sffluid_Controller_BlablaController extends Tx_Extbase_MVC_Controller_ActionController {
    public function testblablaAction() {
        $this->view->assign('name', 'Theo Tester');
    }
}

Backendkonfiguration und TypoScript

Die Konfiguration für das TCA (Backendfelder) liegt jetzt unter

extkey/Configuration/TCA/Modelpart.php

TypoScript findet man in

extkey/Configuration/TypoScript

Konfiguration des Extension Builder für Änderungen

extkey/Configuration/ExtensionBuilder

Verzeichnisstruktur

- Classes
--- Controller
--- Domain
--- ViewHelpers
- Configuration
--- FlexForms
--- TCA
--- TypoScript
- Resources
--- Private
----- Templates
--- Public

Quickstart

Domain Modelling

• New Model auf Arbeitsfläche ziehen (z.B. Product)
  • Object Setting Aggregate Root für das Hauptobjekt
  • Default Actions z.B. list und show
  • Properties z.b. title, price...
  • Relations z.b. categories 1:n ...

• New Model (z.b. Category)
  • Diesmal KEIN Aggregate Root

• Verbindungen von den Relations der Haupt Domain auf die Unterdomains ziehen.
• Speichern

Extension aktivieren

Extension Manager

Datensätze anlegen

Wie üblich.

Hinweise zum Extension Builder

Welcome to the Extension Builder! This page is intended to give you some overview about the workflow we suggest.

What is this extension builder about?

This extension builder helps you to build and manage applications based on Extbase and Fluid. We also want to provide a learning tool for Domain-Driven Design

=Domain Driven Design

View Putting the Model to Work and Strategic Design by Eric Evans to get an introduction into Domain Driven Design (DDD).

Domain Modelling

At first, you will start creating your Domain Model with a graphical editor. This editor will do the following for you:

Extension Skeleton: will create the extension directory structure needed

Domain Model: Will create basic classes for the Domain Model, residing under Domain/Model/

Database Tables and TCA: Will create Database Tables and TCA definitions which fit to the domain model.

Skeleton Locallang Files: Will create skeleton locallang files

Plugin Configuration: Will create a plugin configuration, so it will work out-of-the-box.

Dynamic Scaffolding: Automatically create all CRUD actions (Create, Read, Update, Delete) for Aggregate Roots!

Have a look at the Wiki Using the Extension Builder for more details.

Go to the Domain Modeller

Iterative model refinement

The first version of the model will usually not be the one you'll use lateron. That's why you should take your time, and improve your model.

Useful things to know

Dynamic Scaffolding: The Scaffolding will automatically adjust the templates needed to render CRUD-functionality for your domain models. That is, if you modify your domain model by adding or removing fields, the standard CRUD actions display the new fields as well.

When you start to modify the generated files, but still want to use the graphical modeler to extend your model, you have to enable the roundtrip feature in the Extension Builder settings in the Extension Manager.

You will find a file in your extension directory

Configuration/ExtensionBuilder/settings.yaml.

There you can configure which files should be overwritten, kept or merged if you save your model.

A good practice would be, to let the Extension Builder generate the Partials for form fields and properties for you and include them in your templates.

At the Wiki http://wiki.typo3.org/T3Doc/Extension_Builder/Modifying_and_extending_the_model Modifying and extending the model you find more details about this feature

Extbase Extensions - Snippets und Glossar

Extbase Extensions - Snippets und Glossar