Emailklasse zum Versenden personalisierter Emails per Templatetechnik
Immer dann, wenn man eine Email verschicken möchte, in der bestimmte Textpassagen vom Empfänger
abhängig sind und dynamisch befüllt werden müssen, könnte diese Klasse zum Einsatz kommen.
Andwendungsbeispiele sind z.B. Bestellbestätigungen mit einer Warenkorbliste, Erinnerungsemails,
Benachrichtigungsemails mit persönlichem Link, usw.
Über ein sogenanntes Template (Vorlage) wird die Nachricht textlich gestaltet.
An den Stellen, wo später dynamisch Inhalte eingefügt werden sollen, vergibt man einfach Platzhalter nach dem Schema
{VARNAME}.
Das könnte dann z.B. so aussehen:
Code:
{VON} hat am {DATUM} um {UHRZEIT} Uhr folgende Nachricht geschickt:
{ANREDE} {AN},
Am <b>{DATUM}</b> werde ich vorraussichtlich wieder in {ORT} sein.
Es wäre schön wenn wir dann wieder ein Treffen arrangieren könnten.
{GRUSSFORMEL},
{VON}
<a href="http://www.mysqldumper.de">Meine Projektseite</a>
Die Platzhalter in den geschweiften Klammern werden dann durch den Programmcode mit den tatsächlichen Inhalten
ersetzt. Die Funktionsweise ist also ähnlich einem Serienbriefdruck wie in z.B. Word.
Wo liegen die Vorteile einer solchen Vorgehensweise?
- Man hat den Programmcode sauber von der eigentlichen Email getrennt und eine zweite Person, die nicht programmieren
kann, ist trotzdem in der Lage den Emailtext selbstständig zu verändern - der Text kann beliebig umgestellt werden.
- Nach kurzer Eingwöhnungsphase stellt sich das Versenden von Emails über eine zentrale Klasse als recht komfortabel und einfach dar.
- Da alle Aktionen (Setzen von Variablen, Versenden der Email, Fehlerabfrage,...) in der Klasse gebündelt sind, ist eine
Erweiterung des Funktionsumfangs hier zentral mit wenig Aufwand realisierbar.
Kommen wir zu einem Beispiel.
Zunächst die eigentliche Klasse, die das Objetk Email behandelt.
Code:
<?php
// Email-Template-Klasse
// in 2005 von Daniel Schlichtholz (http://www.mysqldumper.de , http://www.dislabs.de)
// Dieses Script ist Freeware
// Benutzung auf eigene Gefahr. Der Autor kann für Schäden,die im Zusammenhang mit der Benutzung
// dieses Scripts auftreten in keinem Fall haftbar gemnacht werden.
class email
{
function email()
{
$this->empfaenger='';
$this->absender='';
$this->betreff='';
$this->templatevars=array(); // nimmt die zu ersetzenden Templatevariablen auf
$this->output=''; // nimmt die geparste Email auf
}
//Emailadresse auf syntaktische Korrektheit uerberpruefen
function validiere_email($email_adresse)
{
//if (!ereg("^([a-zA-Z0-9\.\_\-]+)@([a-zA-Z0-9\.\-]+\.[A-Za-z][A-Za-z]+)$"),$email_adresse)
if ($email_adresse!="" && ereg("^([a-zA-Z0-9\.\_\-]+)@([a-zA-Z0-9\.\-]+\.[A-Za-z][A-Za-z]+)$", $email_adresse))
return true;
else die('<br><b>Fehler:</b> ungültige Emailadresse: <b> '.$email_adresse.'<b>');
}
// Absenderadresse setzen
function absender($absender)
{
if ($this->validiere_email($absender)) $this->absender=$absender;
}
// Empfaengeradresse setzen
function empfaenger($empfaenger)
{
if ($this->validiere_email($empfaenger)) $this->empfaenger=$empfaenger;
}
// setze Templatevariablen
function absendername($absendername)
{
$this->absendername=$absendername;
}
// setze Templatevariablen
function betreff($betreff)
{
$this->betreff=$betreff;
}
// Zu ersetzende Variablen setzen
function setze_tpl_vars($arr)
{
if (is_array($arr))
{
foreach ($arr AS $key=>$val)
{
$this->templatevars[$key]=$val;
}
}
}
function parse_email($template='')
{
// Wenn gar kein Templatedateinaem angegeben wurde -> Abbruch
$handle=trim($template);
if ($handle=='')
{
die('<br><b>Fehler:</b> es ist kein Dateiname fuer das zu ladende Template angegeben.');
}
if ( (!isset($this->absender)) || ($this->absender=='') )
{
die('<br><b>Fehler:</b> es ist kein Absender definiert. Die Email kann nicht verschickt werden.');
}
if ( (!isset($this->empfaenger)) || ($this->empfaenger=='') )
{
die('<br><b>Fehler:</b> es ist kein Empfänger angegeben. Die Email kann nicht verschickt werden.');
}
// Templaedatei laden
$str='';
$str = @file_get_contents($handle);
if (empty($str))
{
die('<b>Fehler:</b> die Templatedatei <b>.'.$handle.'</b> konnte nicht gefunden oder geladen werden!');
}
// Variablen durch Inhalte ersetzen
if (is_array($this->templatevars))
{
$suchen=array();
$ersetzen=array();
foreach($this->templatevars AS $key=>$val)
{
$suchen[]='{'.$key.'}';
$ersetzen[]=$val;
}
$str=str_replace($suchen,$ersetzen,$str);
}
$this->output=$str;
return true;
}
function screen_output()
{
echo '<br>Empfänger: '.$this->empfaenger;
echo '<br>Absender: '.$this->absender;
echo '<br>Betreff: '.$this->betreff;
echo '<hr><pre>'.$this->output.'</pre><hr>';
}
function sende_email($typ='TEXT')
{
$error='';
if ( (!isset($this->absender)) || ($this->absender=='') )
{
$error.='<br><b>Fehler:</b> es ist kein Absender definiert. Die Email kann nicht verschickt werden.';
}
if ( (!isset($this->empfaenger)) || ($this->empfaenger=='') )
{
$error.='<br><b>Fehler:</b> es ist kein Empfänger angegeben. Die Email kann nicht verschickt werden.';
}
if ( (!isset($this->betreff)) || ($this->betreff=='') )
{
$error.='<br><b>Fehler:</b> es ist kein Betreff angegeben. Die Email kann nicht verschickt werden.';
}
if ($error>'') die ($error);
// Wenn kein Absendername angegeben ist -> Emailadresse des Absender s als Name setzen
if ( (!isset($this->absendername)) || ($this->absendername=='')) $this->absendername=$this->absender;
// Email-Header zusammenstellen
$header="From: ".$this->absendername." <".$this->absender.">\r\n";
// Bei einer HTML-Mail Header entsprechend erweitern, damit Tags ausgefuehrt werden
if ($typ=='HTML')
{
$header.="MIME-version: 1.0\n";
$header.="X-Mailer: PHP/" . phpversion(). "\n";
$header.="X-Sender-IP: ".$_SERVER['REMOTE_ADDR']."\n";
$header.="Content-Type: text/html";
$this->output=nl2br($this->output); //Zeilenumbrueche durch den HTML-Tag "<br>" ersetzen
}
$ret=mail($this->empfaenger,$this->betreff,$this->output,$header);
return $ret;
}
function destroy()
{
// Objekt zerstoeren und Speicherplatz wieder freigeben
unset($this);
}
}
?>
Da der Code weitesgehend kommentiert ist, gehe ich hier nocht näher darauf ein.
Interessanter ist nun die konkrete Anwendung.
Gehen wir davon aus, dass das oben gelistete Template unter dem Namen emailtemplate.tpl abgespeichert wurde.
Dann können wir mit dem folgenden Script (nennen wir es emailtest.php) darauf zugreifen, es mit Werten befüllen und schließlich de Email abschicken.
Code:
<?php
// Anwendungsbeispiel;
// erst Klasse einbinden
include('emailclass.php');
// Objekt erzeugen und mit Werten befuellen
$email=new email;
$email->absendername('Daniel Schlichtholz');
$email->absender('admin@mysqldumper.de');
$email->empfaenger('debug@daniel-schlichtholz.de');
$email->betreff('Testmail');
// die definierten Platzhalter mit Werten belegen
$email->setze_tpl_vars(array('VON'=>'Daniel Schlichtholz'));
$email->setze_tpl_vars(array('AN'=>'Heike Muster'));
$email->setze_tpl_vars(array('ANREDE'=>'Liebe Frau'));
$email->setze_tpl_vars(array('DATUM'=>'2.01.2006'));
$email->setze_tpl_vars(array('UHRZEIT'=>date("G:i",time()) ));
$email->setze_tpl_vars(array('ORT'=>'Bremen'));
$email->setze_tpl_vars(array('GRUSSFORMEL'=>'Mit herzlichem Gruß'));
/* oder alternativ alle Variablen in einem Aufruf uebergeben
$email->setze_tpl_vars(array(
'VON'=>'Daniel Schlichtholz',
'AN'=>'Heike Muster',
'ANREDE'=>'Liebe Frau',
'DATUM'=>'2.01.2006',
'UHRZEIT'=>date("G:i",time()),
'ORT'=>'Bremen',
'GRUSSFORMEL'=>'Mit herzlichem Gruß'
));
*/
// Jetzt alle Variablen im Template durch ihre Werte ersetzen
$email->parse_email('./emailtemplate.tpl'); // als Paramter wird der Ort (relative Pfadangabe) und der Dateiname der Templatedatei übergeben
$email->screen_output(); // Testausgabe auf dem Bildschirm (zur Ueberpruefung ob alles richtig ersetzt wird)
// Email verschicken
$verschickt=$email->sende_email('HTML');
if (!$verschickt===false) echo '<br>Die Email wurde erfolgreich verschickt.';
else echo "<br>Leider ist ein Fehler beim Versenden der Email aufgetreten.<br>Die Nachricht wurde <b>nicht</b> verschickt!";
$email->destroy(); // Objekt zerstoeren und Speicherplatz wieder freigeben
?>
Schauen wir uns einmal genauer an, was dort passiert.
Zunächst muss die Klasse "emailclass.php" eingebunden werden, damit wir überhaupt mit ihr arbeiten können.
Dann wird ein Objekt der Klasse email erzeugt, welches wir dann mit den benötigten Werten befüllen.
Eine Email benötigt naturgemäß folgende Angaben:
- den Absendernamen: dieser Name wird im Feld "Von:" beim Empfänger der Email im Klartext angezeigt
(wird vergessen die Variable zu setzen, so wird hier automatisch die Absender-Emailadresse eingesetzt.
- die Absenderadresse: klar, man muss ja zurückschreiben können. Es sei erwähnt, dass man hier aber
eine beliebige Angabe machen kann. Es wird nicht überprüft ob die Adresse tatsächlich existiert.
- die Empfängeradresse: auch klar, irgendwo soll die Email ja hingeschickt werden
- der Betreff: man sollte immer eine aussagefähige Betreffzeile wählen (auch im Hinblick auf Spamfilter)
Diese Werte werden, wie im Beispiel gezeigt, einfach über gleichnamige Methoden übergeben.
Die Methode "setze_tpl_vars()" sorgt für den eigentlich dynamischen Aspekt und bereitet das Ersetzen der Platzhalter durch
die übergebenen Werte vor. An dieser Stelle hat man als Programmierer nun freie Hand. Es ist völlig egal, wo man
die Werte herbekommt (aus einem Formular, aus einer Datei, aus einer Datenbankabfrage,...).
Wichtig ist nur, dass die Platzhalter hier genau so heißen, wie in der Templatedatei (Groß- und Kleinschrift wird unterschieden).
Die Methode "parse_email('HTML')" sorgt nun endlich für das Ersetzen der Werte.
Es gibt einen Unterschied bei der Behandlung der Umbrüche. Will man eine HTML-Email versenden, in der HTML-Tags
auch wirklich umgesetzt werden, so muss ein entsprechender Header mitgesendet werden. Dies erreicht man über
die Angabe 'HTML' im Aufruf. Gibt man nichts an, so wird die Email als reine Textmail verschickt.
Damit man sich das Ergebnis seiner Bemühungen auch ansehen kann, habe ich die kleine Methode "screen_output()" integriert.
Nach dem Aufruf von "parse_email()" kann man sich den Inhalt der Email damit auf dem Bildschirm anzeigen lassen.
Das ist zum Debuggen ganz nützlich. :-)
Mit unserem Beispielscript erhalten wir durch den Aufruf nun z.B. die Ausgabe:
Zitat:
Empfänger: debug@daniel-schlichtholz.de
Absender: admin@mysqldumper.de
Betreff: Testmail
--------------------------------------------------------------------------------
Daniel Schlichtholz hat am 2.01.2006 um 15:13 Uhr folgende Nachricht geschickt:
Liebe Frau Heike Muster,
Am 2.01.2006 werde ich vorraussichtlich wieder in Bremen sein.
Es wäre schön wenn wir dann wieder ein Treffen arrangieren könnten.
Mit herzlichem Gruß,
Daniel Schlichtholz
Meine Projektseite
--------------------------------------------------------------------------------
|
Mit "sende_email()" wird die Email nun endlich losgeschickt. Kommt es hier zu einem Fehler, so liefert die Funktion
"false" zurück. Wie man darauf reagiert hängt vom Anwendungszweck ab.
Ich gebe im Beispielscript eine entsprechende Meldung aus.
Die Anwendung gestaltet sich also denkbar einfach wenn man den Zusammenhang verstanden hat.
Also nochmal im Kurzdurchlauf:
- man erstellt ein Template mit Platzhaltern (die Namen der Platzhalter kann man frei wählen)
- man erzeugt ein Objekt und befüllt alle Variablen
- man ruft "parse_email()" auf, damit die Platzhalter ersetzt werden
- man schickt die email mit "sende_email()" ab
- Fertig.
Die Anwendung sollte für jeden nachvollziehbar sein.
Die Klasse fängt Fehlanwendungen auch weitestgehend ab, so dass man auch als PHP-Neuling damit experimentieren kann.
Ich wünsche allen Benutzern viel Vergnügen bei der Anwendung.
Für Erweiterungen, Anmerkungen, auftretende Fehler und Verbesserungen bin ich dankbar.
Viel Vergnügen.
