Extbase: Fluid zum rendern von E-Mail-Templates verwenden

TYPO3Extbase und Fluid sind die Zukunft von TYPO3 in der guten alten 4er-Version. Und auch mit der neuen Version 5 wird Fluid als Template-Engine für FLOW3 das Rendering von Inhalten übernehmen. Für “normale” Anforderungen, wie dem Anzeigen von Datenbankinhalten stellt das auch absolut kein Problem dar, alles, was man braucht, wird vom Framework bereits geliefert. Im jeweiligen Controller muss man lediglich die benötigten Daten aus dem Repository holen und an die View weitergeben – die Initialisierung von Fluid hat bereits stattgefunden und die passenden Templates wurden eingerichtet. Werden die Anforderungen allerdings komplexer, braucht man zum Beispiel eine “parallele” View zum Rendern einer Bestätigungs-E-Mail, wird es schon ein wenig kniffliger.

Früher hätte man einfach das entsprechende Template-File ausgelesen, ein Marker-Array mit Inhalten gefüllt, das Ganze durch die TYPO3-Template-Engine vom cObject gejagt und abschließend den so gerenderten Content per E-Mail verschickt. Mit Extbase und Fluid gestaltet sich das ganze etwas anders. Die Standard-Komponenten für die View sind hier bereits vom Framework initialisiert, eine zweite, “parallele” View für die E-Mail-Inhalte ist nicht vorgesehen. Um Fluid aber trotzdem für das Rendern der E-Mail-Inhalte verwenden zu können und gleichzeitig eine Ausgabe im Browser machen zu können, hilft vielleicht folgendes vorgehen:

Ein Beispielhafter Extbase-Controller könnte z.B. so aussehen:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
<?php
class Tx_MyExt_Controller_TestController extends Tx_Extbase_MVC_Controller_ActionController {
	/**
	 * The data repository
	 * @var Tx_MyExt_Domain_Repository_DataRepository
	 */
	protected $dataRepository = NULL;
 
	public function initializeAction() {
		$this->dataRepository = t3lib_div::makeInstance('Tx_MyExt_Domain_Repository_DataRepository');
	}
 
	public function testAction() {
		// first of all, get the data
		$data = $this->dataRepository->findAll();
		// then send the notification
		$this->notify($data);
		// then do the standard stuff...
		$this->view->assign('data', $data);
	}
 
	protected function notify($data) {
		// create a Fluid instance for plain text rendering
		$renderer = $this->getPlainTextEmailRenderer('notify');
		// assign the data to it
		$renderer->assign('data', $data);
		// and do the rendering magic
		$message = $renderer->render();
		// finally, send the mail
		$this->sendMail('recipient@example.com', 'Eine Benachrichtigung!', $message, 'sender@example.com', 'Der Benachrichtiger');
	}
 
	protected function sendMail($recipient, $subject, $message, $senderEMail, $senderName='', $replyToEMail='', $replyToName='', $returnPath='', $organization='') {
		$htmlMail = t3lib_div::makeInstance('t3lib_htmlmail');
		$htmlMail->start();
		$htmlMail->recipient = $recipient;
		$htmlMail->subject = $subject;
		$htmlMail->from_email = $senderEMail;
		$htmlMail->from_name = $senderName;
		$htmlMail->replyto_email = $replyToEMail != '' ? $replyToEMail : $senderEMail;
		$htmlMail->replyto_name = $replyToName != '' ? $replyToName : $senderName;
		$htmlMail->organisation = $organisation;
		$htmlMail->returnPath = $returnPath;
		$htmlMail->addPlain($message);
		$htmlMail->send($recipient);
	}
 
	/**
	 * This creates another stand-alone instance of the Fluid view to render a plain text e-mail template
	 * @param string $templateName the name of the template to use
	 * @return Tx_Fluid_View_StandaloneView the Fluid instance
	 */
	protected function getPlainTextEmailRenderer($templateName = 'default') {
		$emailView = $this->objectManager->create('Tx_Fluid_View_StandaloneView');
		$emailView->setFormat('txt');
		$extbaseFrameworkConfiguration = $this->configurationManager->getConfiguration(Tx_Extbase_Configuration_ConfigurationManagerInterface::CONFIGURATION_TYPE_FRAMEWORK);
		$templateRootPath = t3lib_div::getFileAbsFileName($extbaseFrameworkConfiguration['view']['templateRootPath']);
		$templatePathAndFilename = $templateRootPath . $this->request->getControllerName().'/' . $templateName . '.txt';
		$emailView->setTemplatePathAndFilename($templatePathAndFilename);
		$emailView->assign('settings', $this->settings);
		return $emailView;
 
/* This is a variant for extbase versions prior to 1.3.0
		// create another instance of Fluid
		$renderer = t3lib_div::makeInstance('Tx_Fluid_View_TemplateView');
		// set the controller context
		$controllerContext = $this->buildControllerContext();
		$controllerContext->setRequest($this->request);
		$renderer->setControllerContext($controllerContext);
		// this is the default template path
		$templatePath = t3lib_extMgm::extPath($this->extensionKey) . 'Resources/Private/Templates/EMail/';
		// override the template path with individual settings in TypoScript
		$extbaseFrameworkConfiguration = Tx_Extbase_Dispatcher::getExtbaseFrameworkConfiguration();
		if (isset($extbaseFrameworkConfiguration['view']['templateRootPath']) && strlen($extbaseFrameworkConfiguration['view']['templateRootPath']) > 0) {
			$templatePath = t3lib_div::getFileAbsFileName($extbaseFrameworkConfiguration['view']['templateRootPath']);
		}
		$templateFile = $templatePath.$templateName.'.txt';
		// set the e-mail template
		$renderer->setTemplatePathAndFilename($templateFile);
		// and return the new Fluid instance
		return $renderer;
*/
	}
}
?>

Und nun zur Erläuterung:
In der aufgerufenen Action (testAction) werden zunächst wie gewohnt die erforderlichen Daten aus dem Repository geholt. Anschließend wird die E-Mail-Benachrichtigung mittels der Methode notify() angestoßen, dann die Daten an die View für die Browser-Ausgabe weitergegeben und der Rest ist Extbase und Fluid überlassen.
Die Methode notify macht nun aber Folgendes: Zunächst wird hier eine weitere Fluid-Instanz erzeugt. dies geschieht in der Hilfsmethode getPlainTextEmailRenderer(), der man auch noch einen Templatenamen mitgeben kann. Diese Fluid-Instanz wird nun ebenfalls mit den Daten gefüttert und der Rendering-Prozess angestoßen. Die Rückgabe von render() kann dann als Nachricht per E-Mail mittels der Methode sendMail() verschickt werden.

AKTUALISIERUNG: (18.05.2001)
Endlich bin ich dazu gekommen, nach dem hilfreichen Kommentar von Bastian die Erzeugung der Fluid-Instanz auf Extbase 1.3.0 anzupassen. Im groben habe ich mich an diesen Artikel gehalten, allerdings einige kleine Anpassungen vorgenommen. Das Template für die E-Mail ist in diesem Falle nach wie vor ein Text- und kein HTML-Template (Dateiendung .txt) und liegt hier in dem Template-Ordner des aktuellen Controllers. Im Wiki-Artikel wurde davon ausgegangen, dass die E-Mail-Templates a) HTML-Vorlagen sind und b) dass sie im Ordner Resources/Private/Templates/Email/ liegen.

10 Gedanken zu „Extbase: Fluid zum rendern von E-Mail-Templates verwenden

  1. Pingback: Extbase/Fluid | Pearltrees

  2. Pingback: Extbase: Fluid zum rendern von E-Mail-Templates verwenden (v. Benny) » Lime Flavour PasteBin

  3. Alex

    Klasse Beitrag, vielen Dank!
    Wollte schon die alte Methode (mit den Markern) nach Extbase als Service portieren aber so ist es viel eleganter!
    Danke nochmals :)

    Antworten
  4. Thomas

    Hey,

    sehr guter Artikel und hat mir weiter geholfen. Was ich jedoch festgestellt habe ist, dass die Funktion: Tx_Extbase_Dispatcher::getExtbaseFrameworkConfiguration() inzwischen als deprecated markiert ist. Was wäre hier die korrekte Alternative? Ich habe mal gesucht bin mir aber einfach nicht sicher.

    Gruß,
    Thomas

    Antworten

Hinterlasse eine Antwort

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind markiert *

Du kannst folgende HTML-Tags benutzen: <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <strike> <strong>