- Die TYPO3-Backend-API
- TCEforms
- require_once(PATH_t3lib.'class.t3lib_tceforms.php');
- $this->tceforms = t3lib_div::makeInstance("t3lib_TCEforms");
- $this->tceforms...
- TCEmain
- require_once(PATH_t3lib.'class.t3lib_tcemain.php');
- $this->tcemain = t3lib_div::makeInstance("t3lib_TCEmain");
- $this->tcemain...
- Backend User Object
- RTE-API
- require_once(PATH_t3lib.'class.t3lib_rteapi.php');
- class user_classXYZ extends t3lib_rteapi { ... }
- Backend-Funktionen
- Die TYPO3-Frontend-API
- TSFE
- Content Objects (Inhaltselemente)
- Plugin Base API
- require_once(PATH_tslib.'class.tslib_pibase.php');
- class tx_classXYZ extends tslib_pibase { ... }
Teil 3 – Backend- und Frontend-APIs: Inside TYPO3 – Ein Blick in das Innere des CMS
Während die APIs im zweiten Teil dieser Serie vom Frontend und Backend gemeinsam genutzt werden konnten, ist dies bei den speziellen APIs in der Regel anders. Hier stehen die jeweiligen Klassen und Funktionen nur einem dedizierten Bereich zur Verfügung. Dies sollte man beachten, wenn man bestimmte Informationen im jeweils anderen Bereich nutzen möchte. So gibt es im Backend schlicht keine Informationen zum Rendering der Seite und im Frontend ist es (über die API) unmöglich, festzustellen, welcher Backend-Nutzer gerade eingeloggt ist – mit Ausnahme des aktuellen Benutzers: Bei diesem lässt sich feststellen, ob er gerade auch zusätzlich im Backend eingeloggt ist.
Die TYPO3-Backend-API
Eine der Hauptkomponenten im Backend ist die „TYPO3 Core Engine“, kurz TCE. Diese ist im Grunde für zwei Dinge zuständig:
- Rendern der Backendformulare (TCEforms)
- Beschreiben der Datenbank – inkl. Anlegen, Verschieben, Kopieren und Löschen von Seiten und Seitenelementen, Versionierung und History (TCEmain)
TCEforms
Diese Klasse ist für alle Funktionen zuständig, die notwendig sind, um Backend-Formulare und deren zahlreiche Funktionalitäten darzustellen, etwa Flexforms, Paletten oder Lokalisierungen.
Zugriff auf die API: | |
Klassendatei: | t3lib/class.t3lib_tceforms.php |
Anzahl Funktionen: | 100 |
Zugriff vom Backend: |
require_once(PATH_t3lib.’class.t3lib_tceforms.php‘);$this->tceforms = t3lib_div::makeInstance("t3lib_TCEforms");$this->tceforms… |
Die Quelle für das Rendering ist dabei das „Table Configuration Array“, kurz TCA. Dieses komplexe Array speichert die komplette Datenbankstruktur inklusive weiterer Parameter, etwa Konfigurationen. Um den Aufbau und die Verwendung des TCA wird es im nächsten Teil dieser Serie gehen.
TCEforms ist die vielleicht komplexeste Klasse im TYPO3-System. Obwohl die API anfangs nie dazu gedacht war, auch von extern benutzt zu werden, ist es dennoch möglich und sinnvoll, dies je nach Anwendungszweck zu tun. Erfahrene Entwickler finden in der Datei „typo3/mod/user/ws/workspaceforms.php“ eine umfassende und gut dokumentierte Anwendung für die API: Hier werden eigene Formulare für Workspace-Einträge gerendert.
Einen sehr guten Einstieg in diese Thematik erhält man in dem Blog-Beitrag „Formularfelder mit TCEforms“ von Martin Helmich [1] sowie in der Dokumentation der TYPO3-Core-API [2].
TCEmain
Diese Klasse ist die Kernklasse aus Sicht des Content Managements. Sie erledigt unter anderem folgende Aufgaben:
- Erstellen, Löschen, Updaten, Kopieren und Bewegen von Einträgen (z. B. Seiten, Inhaltselemente oder andere Elemente – generell Datenbankfelder)
- Cache-Management (Löschen)
- Erstellen, Updaten und Publizieren von Versionen
Zugriff auf die API: | |
Klassendatei: | t3lib/class.t3lib_tcemain.php |
Anzahl Funktionen: | 126 |
Zugriff vom Backend: |
require_once(PATH_t3lib.’class.t3lib_tcemain.php‘);$this->tcemain = t3lib_div::makeInstance("t3lib_TCEmain");$this->tcemain… |
Um beispielsweise die Seite mit „ID=17“ zu verstecken (also das Feld „hidden“ auf den Wert 1 setzen), können Sie folgende API-Funktion verwenden:
// t3lib_TCEmain Klasse laden require_once(PATH_t3lib.'class.t3lib_tcemain.php'); / /Der Wert kann natürlich dynamisiert sein $id = 17; // Array mit Aktion laden (siehe API-Dokumentation) $dataArr['pages'][$id]['hidden'] = 1; // Instanz der Klasse anlegen $tce = t3lib_div::makeInstance('t3lib_TCEmain'); // Initialisierung $tce->start($dataArr, array()); // Verarbeiten der Anweisung $tce->process_datamap();
Listing 1
Eine umfassende API-Dokumentation zu TCEmain finden Sie unter [3].
Backend User Object
Der aktuell eingeloggte Backend-User ist in der globalen Variablen „$BE_USER“ für Backend-Skripte zugänglich. Das Objekt selbst wird in der Datei „init.php“ erstellt und ist eine Instanz der Klasse „t3lib_beUserAuth“ (welche die Klasse „t3lib_userAuthGroup“ erweitert und diese wiederum die Klasse „t3lib_userAuth“).
Hier kann geprüft werden, ob der User Zugang zum aktuellen Modul (bzw. zu beliebigen anderen) oder zu Tabellen und deren Feldern hat. Sehr beliebt ist in diesem Zusammenhang auch die Abfrage „$BE_USER->isAdmin();“, die überprüft, ob der aktuell eingeloggte User Administrator-Rechte hat. Darüber hinaus gibt es Funktionen, die überprüfen, ob der User das Recht hat, bestimmte Seiten zu sehen, oder ob sich eine Seite innerhalb des DB-Mounts befindet. Auch Funktionen zur Ermittlung des WHERE-Statements sind vorhanden, für den Fall, dass man einen SQL-Query aufbauen will, der alle Seiten ermittelt, für die der User beispielsweise Edit-Rechte hat. Schließlich kann über „$BE_USER->user[…]“ auf das gesamte User-Objekt und dessen Informationen zugegriffen werden.
Zugriff auf die API: | |
Klassendatei: | t3lib/class.t3lib_beuserauth.php |
Anzahl Funktionen: | 9 |
Zugriff vom Backend: | $BE_USER |
RTE-API
Diese API hat zwar nur wenige Funktionen, dafür aber eine sehr wichtige. Neben der Funktion „isAvailable()“, die überprüft, ob überhaupt ein Rich Text Editor (RTE) verwendet wird, und der Funktion „drawRTE()“, die den RTE und seine Zusatzfunktionen im Backend darstellt, gibt es die Funktion „transformContent()“. Diese sorgt für die Transformation des Inhalts zwischen Datenbank und RTE. So werden beispielsweise Links und Bilder anders in der Datenbank gespeichert, als sie im RTE angezeigt werden. Die Thematik ist sehr umfangreich und komplex und wird in der Dokumentation der TYPO3-Core-API [4] umfassend behandelt.
Zugriff auf die API: | |
Klassendatei: | t3lib/class.t3lib_rteapi.php |
Anzahl Funktionen: | 4 |
Zugriff vom Backend: |
require_once(PATH_t3lib.’class.t3lib_rteapi.php‘);class user_classXYZ extends t3lib_rteapi { … } |
Backend-Funktionen
Über diese API werden im Backend sämtliche Hilfefunktionen gebündelt, die keinem Objekt direkt zuzuordnen sind. Daher werden diese auch allesamt statisch aufgerufen und nicht instantiiert. Hier gibt es eine ganze Reihe nützlicher Funktionen, die einem das Leben als Backend-Extensionprogrammierer extrem vereinfachen:
- Auswählen und Suchen von Records
- Funktionen rund um den Page-Tree
- Hash-Handling
- User-/Gruppenfunktionen
- Ausgabefunktionen
- Backend-Modul-Funktionen
- Kernfunktionen
- Workspaces/Versionierung
- Verschiedenes
Zugriff auf die API: | |
Klassendatei: | t3lib/class.t3lib_befunc.php |
Anzahl Funktionen: | 99 |
Zugriff vom Backend: | t3lib_BEfunc:: |
Die TYPO3-Frontend-API
Ebenso wie das Backend, hat auch das Frontend verschiedenste APIs.
TSFE
TSFE (TypoScript Frontend) ist die Haupt-Frontend-Klasse. Sie enthält Funktionen, um die Page-ID zu ermitteln, TypoScript-Templates zu parsen, Templates auszugeben, Ausgaben zu verarbeiten und diese mit dem Cache zu verknüpfen. Die Funktionen dieser Klasse werden normalerweise nicht direkt aufgerufen, sondern über deren Eigenschaften. Die wichtigsten Eigenschaften dabei sind:
- additionalHeaderData (zusätzliche Header-Daten für die auszugebende HTML-Seite)
- additionalJavaScript (zusätzliches JavaScript für die auszugebende HTML-Seite)
- config (TypoScript config und page.config-Objekt)
- fe_user (die kompletten Frontend-User-Objekte)
- id (die ID der aktuellen Seite)
- lang (die Sprache der aktuellen Seite)
- page (das Seiten-Objekt und alle seine Eigenschaften)
- rootLine (enthält eine Array der Rootline mit den enthaltenen Page-Objekten)
- fe_user (die kompletten Frontend-User-Objekte)
Zugriff auf die API: | |
Klassendatei: | typo3/sysext/cms/tslib/class.tslib_fe.php |
Anzahl Funktionen: | 116 |
Zugriff vom Backend: | $GLOBALS[‚TSFE‘] |
Content Objects (Inhaltselemente)
Inhaltselemente präsentieren den Inhalt auf den Seiten innerhalb der Frontend-Ausgabe. Alle Inhaltselemente werden ausführlich in der TSref (TypoScript Reference) [5] erläutert und in der Datei „typo3/sysext/cms/tslib/class.tslib_content.php“ definiert.
Die zugrundeliegende Klasse „tslib_cObj“ enthält (neben zahlreichem anderen Wichtigen) alle Funktionen, die notwendig sind, um Inhaltselemente wie „TEXT“, „HTML“, „COA“, „USER“ oder „stdWrap“ zu verarbeiten. Damit ist es beispielsweise möglich, innerhalb einer eigenen Extension TypoScript-Code zu erstellen und zu verarbeiten oder bestehenden TypoScript-Code zu verändern. Funktionen aus dieser API finden sich in beinahe jedem Frontend-Plugin.
Zugriff auf die API: | |
Klassendatei: | typo3/sysext/cms/tslib/class.tslib_content.php |
Anzahl Funktionen: | 135 |
Zugriff vom Backend: | $this->cObj bzw. $GLOBALS[‚TSFE‘]->cObj |
Im nachfolgenden Skript des fiktiven Plugins „pluginXYZ_pi1“ wird zunächst ein Array aufgebaut. Dieses enthält die Entsprechung des TypoScript-Codes um ein Bild zu erzeugen. Dieses wird dann am Ende in ein Content-Object umgewandelt und zurückgegeben.
class tx_pluginXYZ_pi1 extends tslib_pibase { var $prefixId = "tx_pluginXYZ_pi1"; var $scriptRelPath = "pi1/class.tx_pluginXYZ_pi1.php"; var $extKey = "pluginXYZ"; function main($content,$conf) { $this->conf=$conf; $this->pi_setPiVarDefaults(); $this->pi_loadLL(); // Aufbau des TypoScript-Arrays $img["file"] = 'GIFBUILDER'; $img['file.']["XY"] = '200,100'; $img['file.']["5"] = 'IMAGE'; $img['file.']["5."]["file"] = 'fileadmin/dummy_bild.gif''; $img['file.']["10"] = 'TEXT'; $img['file.']["10."]["offset"] = '30,20'; $img['file.']["10."]["text"] = 'Sonderangebot!'; $img['file.']["10."]["fontColor"] = 'red'; $img['file.']["10."]["fontSize"] = '20'; // MAGIC – hier wird das TypoScript-ähnliche Array in ein Content-Object verwandelt $image .= $this->cObj->IMAGE($img); // Und das Bild wird schließlich ausgegeben return $this->pi_wrapInBaseClass($image); } }
Listing 2
Plugin Base API
Neben den Content-Objects ist diese API die wichtigste, wenn es um das
Schreiben von Frontend-Plugins geht. Sie ist die Basis für alle
Plugins, daher werden alle Plugin-Klassen auch von ihrer
Klasse „tslib_pibase“ abgeleitet. Das ist zwar nicht unbedingt notwendig, da es durchaus einige Ansätze gibt, diese Basisklasse zu ersetzen. Nichtsdestotrotz sollte man diese ausgereifte und umfangreiche Klasse
verwenden, zumal sie durch den Extension-Manager
automatisch abgeleitet wird, wie in Zeile 1 des vorherigen Skripts zu sehen ist.
Zugriff auf die API: | |
Klassendatei: | typo3/sysext/cms/tslib/class.tslib_pibase.php |
Anzahl Funktionen: | 35 |
Zugriff vom Backend: |
require_once(PATH_tslib.’class.tslib_pibase.php‘);class tx_classXYZ extends tslib_pibase { … } |
Die Klasse ist vor allem für folgende Funktionen zuständig:
- Link-Generierung
- Handling von lokalisierten Labels
- Frontend-Editing
- Datenbank-Abfragen (diese sind den bereits in der allgemeinen API behandelten sehr ähnlich)
- Flexform-Handling
Gerade die Linkgenerierung und die Datenbank-Abfragen sind von zentraler Bedeutung. Erstere erstellt immer korrekte Links – unabhängig davon, ob Extensions wie „RealURL“ installiert wurden oder ob etwaige Parameter mitgeschleift werden müssen. Und letztere sorgen dafür, dass die Datenbank ebenfalls immer korrekt abgefragt wird, unabhängig davon, welches DBMS verwendet wird oder wie die exakte Struktur der Datenbanktabelle lautet. Zudem können die WHERE-Statements, die den Datensatz eingrenzen, automatisch erzeugt werden – beispielsweise im Hinblick auf Sichtbarkeit oder Zugriffsrechte.
// LINK-GENERIERUNG // Ermittelt die URL zu einer Seite ($id) $this->pi_getPageLink($id,$target='',$urlParameters=array()) // Verlinkt einen String mit der URL zu einer Seite ($id) $this->pi_linkToPage($str,$id,$target='',$urlParameters=array()) // Verlinkt einen String mit der aktuellen URL $this->pi_linkTP($str,$urlParameters=array(),$cache=0,$altPageId=0) // Verlinkt einen String mit der URL zu einer Seite ($id) mit Beibehaltung der Variablen in piVars $this->pi_linkTP_keepPIvars($str,$overrulePIvars=array(),$cache=0,$clearAnyway=0,$altPageId=0) // Verlinkt einen String mit der aktuellen URL mit Beibehaltung der Variablen in piVars $this->pi_linkTP_keepPIvars_url($overrulePIvars=array(),$cache=0,$clearAnyway=0,$altPageId=0) // DATENBANK-ABFRAGEN // Erstellt einen Standard-Query, führt diesen aus und liefert das Ergebnis als Pointer zurück function pi_exec_query($table,$count=0,$addWhere='',$mm_cat='',$groupBy='',$orderBy='',$query='') // Ermitteln des Records $uid der Tabelle $table $this->pi_getRecord($table,$uid,$checkPage=0)
Listing 3
Der nächste Teil dieser Artikelserie wirft einen detaillierten Blick auf das TCA sowie das Flexform- und AJAX-Handling von TYPO3.
Der letzte Artikel der Serie erscheint in der nächsten t3n-Ausgabe: | |
Teil 1 (t3n Nr. 13) | Tour de Core |
Teil 2 (t3n Nr. 14) | Allgemeine APIs |
Teil 3 (t3n Nr. 15) | Backend- und Frontend-APIs |
Teil 4 (t3n Nr. 16) | TCA, Flexforms, AJAX |
Hallo und vielen Dank für diesen Artikel. Kann man Teil 1 und 2 auch im Heftarchiv lesen? Eine Verlinkung wäre schön.
Vielen Dank,
tommy
Verzeihung, ich hätte bis zum Ende lesen sollen. Eine Google Suche hat diese Links zu Tage befördert:
Teil 1, Tour de Core: https://t3n.de/magazin/typo3-teil-1-tour-de-core-221024/
Teil 2, Allgemeine APIs: https://t3n.de/magazin/typo3-blick-innere-cms-teil-2-allgemeine-apis-221175/