Registriert man bei Google Mail eine E-Mailadresse – z.B. dasIstEineEMailAdresse@googlemail.com – so wird der komplette Benutzername unabhängig von Groß-/Kleinschreibung und Punkten (.) interpretiert: registriert man die E-Mail-Adresse dasIstEineEMailAdresse@googlemail.com, so hat man automatisch auch folgende weitere Adressen das.ist.eine.emailadresse@googlemail.com oder das.istEineEmailAdresse@googlemail.com etc.

Welche Vorteile sich für den Benutzer und welche Nachteile für einen Webmaster sich hierdurch ergeben soll hier kurz aufgezeigt werden.

Vorteile für den Benutzer

Durch unterschiedliche E-Mail-Adressen, welche aber alle zu einem Postfach führen, gibt es für den Benutzer eine Reihe von Vorteilen.

Organisation/Kategorisierungen

Der Benutzer kann die E-Mails besser organisieren bzw. kategorisieren. Beispielsweise wird für alle Newsletter die E-Mail-Adresse m.ax.mueller@googlemail.com verwendet, für den privaten Kontakt max.mueller@googlemail.com. Mit Hilfe der Filtereinstellungen bei Google-Mail können dann alle Newsletter unabhängig vom Absender mit einem Label versehen und aus dem Posteingang verschoben werden – so findet man im Posteingang dann wirklich nur die “wichtigen” E-Mails.

Privatsphäre

Manche Plattformen bieten die Möglichkeit über eine E-Mail-Adresse zu prüfen ob ein User angemeldet ist (z.B. Facebook). Dies ist nicht von jedem User gewünscht. Hier bietet sich dann mit einer Google-Mail-Adresse die Möglichkeit seine E-Mail-Adresse auf der Plattform z.B. auf max.m.u.e.l.l.e.r@googlemail.com zu ändern. Sucht ein User nach max.mueller@googlemail.com so wird er nicht fündig werden – und trotzdem muss man nicht eine weitere E-Mail-Adresse registrieren.

Nachteile für den Webmaster

Natürlich ergeben Sie durch dieses Feature auch Nachteile. Oft wird die E-Mail-Adresse als primary Key verwendet um so Mehrfachanmeldungen oder Nutzungen schnell und einfach zu unterbinden. Dies wird genutzt unter anderem bei:

• Serialversand
  Das Produkt X darf 14 Tage mit der Serial Y getestet werden. Wird danach versucht erneut eine Serial anzufordern, schlägt das für die benutzte Adresse fehl
• Unterbinden von Mehrfachregistrierung
  Es soll verhindert werden dass sich ein Benutzer mehrfach registriert – unabhängig ob das Verhalten gewollt oder ungewollt ist. Sei es auf Community-Seiten oder auch finanziell orientierten Homepages wie Online-Shops.

Natürlich gibt es neben der “Google-Mail-Problematik” auch noch andere Möglichkeiten wie Wegwerf-E-Mail-Adressen, Automatische Erstellung von E-Mail-Konten, oder sogar der Besitz einer (E-Mail-)Domain (ich@meineDomain.de, ich1@meineDomain.de, …). Wir wollen uns aber hier nur mit Google-Mail beschäftigen.

Eine Möglichkeit das Problem zu umgehen ist der folgende einfache Algorithmus:

1. Prüfe ob Google-Mail-Adresse
2. Wenn Ja entferne im Benutzername alle Punkte
3. Speichere E-Mail-Adresse

Wenn nun geprüft werden soll, ob ein Account schon eine E-Mail-Adresse verwendet, wird auf diese der Algorithmus angewandt, und dann z.B. die Datenbank nach der Mail-Adresse durchsucht. Bleibt die Suche erfolglos, darf sich der User registrieren, wenn nicht, ist der User wohl mit einer ähnliche Adresse bereits registriert und sollte darauf hingewiesen werden. Wichtig ist hierbei, dass der Datenbestand, in dem die Mail-Adresse gesucht wird, bereits die “gesäuberte Adressen” besitzt.

Hinweis: Bei Google-Mail sind gmail.com und googlemail.com möglich. Dies wird vom Script entsprechend beachtet und alle Adressen auf gmail.com umgeschrieben.

Die Implementierung könnte in PHP z.B. gefolgt aussehen:

/**
 * Cleans an e-mail-address (especially Google-Mail-adresses) to avoid duplicates.
 * @param String $emailStr e-mail-address
 */
function clean_email($emailStr) {
	$emailStr = strtolower ($emailStr);
	$tokens = preg_split ("/@/", $emailStr);

	if ($tokens [1] == "gmail.com" || $tokens [1] == "googlemail.com") {
		return str_replace (".", "", $tokens [0]) . "@googlemail.com";
	} else {
		return $emailStr;
	}
}

Ein Aufruf von

echo clean_email("m.a.x.MUELLE.R@gmail.com") . "<br/>";
echo clean_email("m.a.x.MUELLE.R@googlemail.com") . "<br/>";
echo clean_email("max.mueller@web.de");

hat dann entsprechende folgende Ausgabe:

maxmueller@googlemail.com
maxmueller@googlemail.com
max.mueller@web.de

Epilog

Nicht immer wenn sich ein User versucht nochmal zu registrieren ist dies beabsichtigt. Ggf. hat der User schlicht vergessen dass er auf einer Seite registriert ist, oder kann sich nicht mehr einloggen, weil er seine Logindaten nicht mehr kennt. Deshalb sollte immer eine entsprechende Meldung ausgegeben werden wie z.B. “Es ist bereits ein User mit dieser E-Mail-Adresse registriert. Haben Sie Ihr Passwort vergessen?” mit entsprechenden Link zu einer Seite, wo ein neues Passwort beantragt werden kann.

Auch ist bei Prüfung auf Google-Mail-Adressen und Wegwerf-Adressen natürlich nicht vor einer Mehrfachregistrierung geschützt. Sicher ist das nur über das kostenpflichtige und  zeitaufwendige Postident-Verfahren – was jedoch im Internet an der Praxis scheitert.

Weitere Informationen:

• Google Mail-Hilfe – Empfangen von E-Mail-Nachrichten anderer Personen
• bspamfree.org – Wegwerf-E-Mail-Adressen
• Wikipedia – Postident
• Deutsche Post – Identitätsprüfung

Ein Besuch auf www.regnets.in zeigt kurz und knapp die aktuelle Wetterlage für den Standort des Besuchers an. Ermöglicht wird das über Geolocation anhand der IP-Adresse des Benutzers. Natürlich kann der Benutzer auch andere Städte abfragen: www.regnets.in/Hamburg oder www.regnets.in/Berlin.

Geolocation lässt sich beispielsweise mit (kostenlosen) GeoLite City von MaxMind sehr einfach in PHP-Projekte integrieren. Mit nur wenigen Dateien und wenigen Zeilen Code lässt sich so der Standort des Besuchers relativ genau (für Deutschland mit 71% Trefferquote) bestimmen.

Die benötigten Dateien…

• geoip.inc
• geoipcity.inc
• geoipregionvars.php
• GeoLiteCity.dat – die eigentliche Datenbank

… lassen sich hier herunterladen.

Folgender PHP Code liefert die Geolocation des Besuchers:

include("geoipcity.inc");
include("geoipregionvars.php");

function getCity() {

	$gi = geoip_open("GeoLiteCity.dat", GEOIP_STANDARD);
	$record = geoip_record_by_addr($gi, $_SERVER['REMOTE_ADDR']);
	geoip_close($gi);

	return $record->city;
}

Das $record-Objekt enthält aber auch noch andere, interessante Daten:

print $record->country_code . " " . $record->country_code3 . " " . $record->country_name . "\n";
print $record->region . " " . $GEOIP_REGION_NAME[$record->country_code][$record->region] . "\n";
print $record->city . "\n";
print $record->postal_code . "\n";
print $record->latitude . "\n";
print $record->longitude . "\n";
print $record->metro_code . "\n";
print $record->area_code . "\n";

Fragen, Anregungen? Dafür sind die Kommentare da!

Bei zahlreichen Webspace-Providern ist die Funktionalität von file_get_contents für http deaktiviert. Es treten dann Fehlermeldungen wie

Warning: file_get_contents() [function.file-get-contents]: URL file-access is disabled in the server configuration in [..] und

Warning: file_get_contents([..]) [function.file-get-contents]: failed to open stream: no suitable wrapper could be found in [..]

auf. Mit folgender Funktion kann man das Verhalten von file_get_contents jedoch emulieren.

Die Funktion get_contents_by_uri benutzt fsockopen um Inhalte zu laden:

/**
 * Gets contents of any webside by an URI.
 * @author http://blog.root-of-all-evil.com
 * @param String $uri
 */
function get_contents_by_uri($uri) {
	$uriElem = parse_url ( $uri );
	$fp = @fsockopen ( $uriElem ['host'], 80, $errno, $errstr, 10 );

	if (! $fp) {
		throw new Exception ( "Could not create socket: '" . $errnstr . "' (" . $errno . ")." );
	}

	$request = "GET " . $uriElem ['path'] . (isset ( $uriElem ['query'] ) ? "?" . $uriElem ['query'] : "") . " HTTP/1.1\r\n";
	$request .= "Host: " . $uriElem ['host'] . "\r\n";
	$request .= "Connection: Close\r\n\r\n";

	fwrite ( $fp, $request );
	$response = "";
	while ( ! feof ( $fp ) ) {
		$response .= fgets ( $fp, 128 );
	}
	fclose ( $fp );

	// split headers from data
	$responseSplit = explode ( "\r\n\r\n", $response, 2 );

	return $responseSplit [1];
}

Erklärung

Socket erstellen

Die übergebene URI wird über die PHP-Funktion parse_url in ihre Teilmengen zerlegt. Anschließend wird ein Socket erstellt für den entsprechenden Host, auf Port 80 mit einem Timeout von 10 Sekunden. Fehlermeldungen unterdrücken wir durch das @, da wir explizit nach Erfolg abfragen und ggf. eine Ausnahme werfen.

Anfrage schicken, Antwort lesen

Danach wird über fwrite eine entsprechende GET-Anfrage geschickt, welche auch – falls vorhanden – die Parameter der URI und nicht nur den Pfad beachtet. Die darauffolgende Antwort wird in die Variable response gelesen.

Antwort bearbeiten und zurückgeben

Da diese neben dem eigentlichen Inhalt auch den Antwortheader enthält wird die Funktion explode benutzt um den Inhalt davon abzuschneiden. Durch den dritten Parameter bei explode mit dem Wert 2, stellen wir sicher, dass nur einmalig an Hand einer Leerzeile getrennt wird wie Sie sich zwischen Antwort-Header und HTML-Code befindet und nicht mehrmals, da natürlich auch Leerzeilen im HTML-Code selbst auftreten können.

Das zweite Element von responseSplit wird zurückgegeben, responseSplit[0] würde entsprechend den Antwort-Header liefern.

Beispielaufrufe

Der einfachste Aufruf:

echo get_contents_by_uri ( 'http://www.google.de/' );

Aufruf mit Parametern:

echo get_contents_by_uri ( 'http://www.google.de/search?hl=de&site=&q=test' );

Aufruf mit Ausnahmebehandlung:

try{
    echo get_contents_by_uri ( 'http://does_not_exist_.com/bogus.html' );
}
catch(Exception $e)
{
    echo "get_contents_by_uri: ".$e->getMessage();
}

Weitere Links:

• PHP – Funktion parse_url
• PHP – Funktion file_get_contens
• PHP – Funktion fsockopen
• PHP – Funktion explode

Dieser Beitrag beschreibt kurz wie man mit Zend_Validate prüfen kann, ob eine URL / URI syntaktisch korrekt und die verlinkte Ressource erreichbar ist.

Aufbau einer URL prüfen

Ein eigenständiger Validator ist im Zend Framework nicht vorhanden welcher den Aufbau einer URL / URI prüft. Jedoch bietet Zend_URI mit der Methode check() hier eine entsprechende Funktionalität an. Auf diese greifen wir in einem selbst geschriebenen Validator zurück:

class Validator_Uri extends Zend_Validate_Abstract {
	const INVALID_URI = 'invalidUri';
	protected $_messageTemplates = array (self::INVALID_URI => "'%value%' is not a valid URI" );

	public function isValid($value) {
		$this->_setValue ($value);

		if (! Zend_Uri::check ($value)) {
			$this->_error ( self::INVALID_URI );
			return false;
		}

		return true;
	}
}

Erreichbarkeit einer URL prüfen

Es ist nicht nur wichtig, dass die Ressourcenangabe in Ihrem Aufbau korrekt ist, sondern auch, dass sich dahinter ein erreichbares Objekt (Webseite, Bild, PDF etc.) befindet.
Mit Hilfe der PHP-Funktion get_headers prüfen wir den Antwort-Header auf Erfolg (200 OK). Mit Hilfe des @ unterdrücken wir eine Fehler-Ausgabe von PHP, wenn der String an get_headers keine URL sein sollte:

class Validator_Uri_Reachable extends Zend_Validate_Abstract {
	const URI_REACHABLE = 'uriReachable';
	protected $_messageTemplates = array (self::URI_REACHABLE => "'%value%' not reachable" );

	public function isValid($value) {
		$this->_setValue ( $value );

		$headers = @get_headers ( $value );
		if (! preg_match ( '/200 OK/', $headers [0] )) {
			$this->_error ();
			return false;
		}

		return true;
	}
}

Entsprechend kann dann in einem Zend-Formular z.B. eine Homepageadresse geprüft werden:

$hpUrl = new Zend_Form_Element_Text ( 'hpUrl' );
$hpUrl->setLabel ( 'Homepage:' )
			  ->setDescription ( 'Ihre Homepage- oder Blog-Adresse' );
			  ->setAttrib ( 'value', 'http://' )
			  ->addValidator ( new Validator_Uri() )
			  ->addValidator ( new Validator_Uri_Reachable() )

Weitere Links:

• Zend Framework Dokumentation – Schreiben von Prüfern
• PHP – Funktion getheaders
• Wikipedia – Aufbau einer URL
• ROAE Blog – Tools für Regex / Reguläre Ausdrücke

Converting ISO 8601 Duration Time Format in PHP

This little sniplet will enable you to parse ISO 8601 Period (Duration) Time Formats into seconds. The ISO 8601 Period is represented by a string like PnYnMnDTnHnMnS where nY represents the number of years, nM the months, nD the days, nH the hours, nM the Minutes and nS the Seconds. The T seperates the date (to the left of the T) from the time (to the right of the T). Parsing this string is quite tricky, because unneeded values (like years and months for durations shorter than a month) can be left out. Parsing is also tricky, because we face two “M” as identifiers (for months and Minutes).

// ISO 8601 period format PnYnMnDTnHnMnS (e.g., P0Y0M2DT23H32M51S) to seconds
function calcFinishTime($timeleft)
{
	$parsed = array('Y' => 0, 'Mo' => 0, 'D' => 0, 'H' => 0, 'Mi' => 0, 'S' => 0);
	$calcSec = array(12, 31, 24, 60, 60);
	$toParse = preg_split('/T/', strtoupper($timeleft));
	foreach($toParse as $i => $array) {
		$split = preg_split('/([PYMDTHMS]+)/', $array, -1, PREG_SPLIT_NO_EMPTY | PREG_SPLIT_DELIM_CAPTURE);
		$count = count($split);
		for($j = 0; $j < $count; $j++) {
			if(is_numeric($split[$j])) {
				$type = substr($split[$j +1], 0, 1);
				if($i < 1 && $type == 'M')	$type = 'Mo';
				elseif($type == 'M')		$type = 'Mi';
				$parsed[$type] += (int)$split[$j];
			}
		}
	}
	$k = 0;
	foreach($parsed as $type) {
		$sec = 1;
		for($j = $k; $j < 5; $j++) {
			$sec *= $calcSec[$j];
		}
		$parsed['seconds'] += $sec * $type;
		$k++;
	}
	$parsed['endtime'] = time() + $parsed['seconds'];
	return $parsed;
}

A input of “P2DT3H6M24″ will result in an array like this:

array(8) {
  ["Y"]=>
  int(0)
  ["Mo"]=>
  int(0)
  ["D"]=>
  int(2)
  ["H"]=>
  int(3)
  ["Mi"]=>
  int(6)
  ["S"]=>
  int(24)
  ["seconds"]=>
  int(183984)
  ["endtime"]=>
  int(1270843142)
}

Die Überlegung ist simpel: Ich besitze mehrere Blogs zu unterschiedlichen Themen, die ich auf demgleichen Server mit Verwendung der WordPress-Blogsoftware und Verwendung der gleichen Datenbank hoste. Jeder Blog basiert auf seiner eigenen WordPress-Installation und ist in seinem eigenen Ordner hinterlegt. Das bedeutet aber auch: Jeden Blog einzeln auf neue WordPress-Installationen und für jeden Blog jedes einzelne Plugin bei Updates aktualisieren. Eine Menge Administrationsaufwand…

Dabei geht es viel einfacher. Warum nicht eine einzelne WordPress-Installation für mehrere Blogs und Domains nutzen? Die WordPress-Installation also multidomainfähig machen. So muss nur ein einziges WordPress-System muss aktualisiert werden und alle meine Blogs arbeiten mitder neuesten Version.

1. Schritt – alle WordPress-Installationen auf die gleiche Version updaten

Damit die Zusammenführung reibungslos funktioniert müssen zunächst alle vorhandenen WordPress-Installationen ein letztes mal auf die aktuellste – oder zumindest gleiche – Version aktualisiert werden.

2. Schritt – einen neue WordPress-Installation in neuem Verzeichnis anlegen

Sind alle WordPress-Installationen auf die gleiche Version aktualisiert worden müssen wir eine komplett neue WordPress-Installation anlegen. Dazu laden wir die benötigte WordPress-Version herunter und entpacken sie auf unseren Server in einem neuen Verzeichnis. Achtung: Die Installation selbst muss nicht ausgeführt werden. Lediglich die Dateien müssen auf den Server entpackt werden.

3. Schritt – eine neue Datenbank anlegen (optional)

Um die neue Installation von allen vorherigen zu trennen empfehle ich eine neue Datenbank anzulegen. Das muss aber nicht sein. Die WordPress-Installation kann auch in einer bereits vorhanden Datenbank arbeiten.

3. Schritt – die wp-config.php anpassen

Der Trick ist einfach: WordPress nutzt für die Datenbank einen Table_Prefix. Dieser wird in der wp-config.php festgelegt und kann von uns beliebig verändert werden. Folgende Änderungen an der Variablendeklaration von $table_prefix müssen an der wp-config vorgenommen werden:

$table_prefix = str_replace(array('.', '-' ), '_', $_SERVER['HTTP_HOST'] ) . '_';
$table_prefix = str_replace(array('www_'), '', $table_prefix);

Unser Table_Prefix wird jetzt also gemäß unserer aufgerufenen Domain ausgewählt. Striche und Punkte werden in Unterstriche übersetzt, das “www” entfernt. Beispiel:

• “www.mein-cooler-blog.de” wird auf die Tabellen mit dem Table_Prefix “mein_cooler_blog_de_” basieren
• “www.meinblog.com” wird auf die Tabellen mit dem Table_Prefix “meinblog_com_” basieren
• “blog.meine-domain.de” wird auf die Tabellen mit dem Table_Prefix “blog_meine_domain_de_” basieren

Dazu müssen die Verbindungsdaten der (neu erstellten) Datenbank wie gewohnt in der wp-config.php angepasst werden.

4. Schritt – alle wp-content Ordner übertragen

Sämtliche wp-content Ordner aus den alten WordPress-Installationen müssen in die neue Installation übertragen werden. Dabei werden alle Bilder, Medien, Plugins und Skins mit übertragen.

5. Schritt – die Datenbanktabellen umziehen

In diesem Schritt müssen alle Datenbanktabellen der einzelnen WordPress-Installationen in die (neu erstellte) Datenbank umgezogen werden. Das lässt sich mit php_MyAdmin recht leicht lösen (allerdings wird der Table_Prefix nicht geändert und muss manuel geändert werden):

Das PHP-Skript macht dagegen alles vollautomatisch und ändert den Table_Prefix gleich mit:

<?php
function echoOk($msg) { echo('[OK]    ' . $msg . "\n"); }
?><html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
<title>Datenbank-Umzug</title>
<style>
    div.form label, div.form input {
        display: block;
    }
    div.form label {
        margin: 10px 0 5px 0;
    }
    div.form input {
        margin: 5px 0 10px 0;
    }
</style>
</head>
<body>
<?php
    $formElements = array('server', 'username', 'password',
        'database', 'newdatabase',
        'tableprefix', 'newtableprefix');
    $showForm = false;
    foreach($formElements as $element) {
        if(!isset($_POST[$element])) {
            $showForm = true;
        }
    }
    if($showForm) {
?>
<div class="form">
    <form action="" method="post">
        <fieldset>
            <label for="server">Datenbank-Server</label>
            <input type="text" name="server" />
            <label for="username">Benutzername</label>
            <input type="text" name="username" />
            <label for="password">Passwort</label>
            <input type="password" name="password" />
        </fieldset>
        <fieldset>
            <label for="database">Ursprüngliche Datenbank</label>
            <input type="text" name="database" />
            <label for="newdatabase">Neue Datenbank</label>
            <input type="text" name="newdatabase" />
            <label for="tableprefix">Ursprünglicher Table_Prefix</label>
            <input type="text" name="tableprefix" />
            <label for="newtableprefix">Neuer Table_Prefix</label>
            <input type="text" name="newtableprefix" />
        </fieldset>
        <fieldset>
            <p>ACHTUNG: Dieses Skript sendet manche der eingegebenen Daten ungefiltert an die Datenbank und überschreibt bereits existierende Tabellen beim Umzug!</p>
            <input type="submit" />
        </fieldset>
    </form>
</div>
<?php } else {
    echo('<pre>');
    try {

        $con = mysql_connect($_POST['server'], $_POST['username'], $_POST['password']);
        if(!$con) {
            throw new Exception('Verbindung mit Server nicht möglich. ' . mysql_error());
        } else {
            echoOk('Mit \'' . htmlentities($_POST['server']) . '\' verbunden.');
        }

        if(!mysql_select_db($_POST['database'], $con)) {
            throw new Exception('Auswahl der Datenbank nicht möglich. ' . mysql_error());
        } else {
            echoOk('Aktuelle Datenbank \'' . htmlentities($_POST['database']) . '\'.');
        }

        $res = mysql_query('SHOW TABLES IN `' . $_POST['database'] . '` LIKE \'' . $_POST['tableprefix'] . '%\'', $con);
        if(!$res) {
            throw new Exception('Fehler bei Datenbankabfrage. ' . mysql_error());
        } else {
            while($result = mysql_fetch_row($res)) {
                $tables[] = $result[0];
                $newTables[] = str_replace($_POST['tableprefix'], $_POST['newtableprefix'], $result[0]);
            }
            $numTables = count($tables);
            if($numTables > 0) {
                echoOk($numTables . ' Tabellen mit Table_Prefix \'' . htmlentities($_POST['tableprefix']) . '\' in Datenbank \'' . htmlentities($_POST['database']) . '\' gefunden.');
            } else {
                throw new Exception('Keine Tabellen mit Table_Prefix \'' . htmlentities($_POST['tableprefix']) . '\' gefunden.');
            }
        }

        foreach($tables as $num => $table) {
            $res = mysql_query('DROP TABLE IF EXISTS `' . $_POST['newdatabase'] . '`.`' . $newTables[$num] . '`', $con);
            if(!$res) {
                throw new Exception('Fehler bei Datenbankabfrage: ' . mysql_error());
            }
            $res = mysql_query('CREATE TABLE `' . $_POST['newdatabase'] . '`.`' . $newTables[$num] . '` LIKE `' . $_POST['database'] . '`.`' . $table . '`');
            if(!$res) {
                throw new Exception('Fehler bei Datenbankabfrage: ' . mysql_error());
            }
            $res = mysql_query('INSERT INTO `' . $_POST['database'] . '`.`' . $table . '` SELECT * FROM `' . $_POST['newdatabase'] . '`.`' . $newTables[$num] . '`');
            if(!$res) {
                throw new Exception('Fehler bei Datenbankabfrage: ' . mysql_error());
            } else {
                $process = round($num / $numTables * 100);
                if($process < 10) {
                    $process = ' ' . $process;
                }
                if($process < 100) {
                    $process = ' ' . $process;
                }
                echoOk('[' . $process . '%] Tabelle \'' . htmlentities($table) . '\' nach \'' . htmlentities($newTables[$num]) . '\' kopiert.');
            }
        }
        echoOk('[100%] ' . $numTables . ' Tabellen kopiert.');

        if(!mysql_close($con)) {
            throw new Exception('Verbindung mit Server konnte nicht geschlossen werden.');
        } else {
            echoOk('Verbindung mit Server geschlossen.');
        }

    } catch(Exception $e) {
        echo('[ERROR] ' . $e->getMessage() . "\n");
    }
    echo('</pre>');
} ?>
</body>
</html>

Das Skript zum schnellen Umzug von mysql Tabellen kann auch hier heruntergeladen werden: PHP Skript zum schnellen Umzug von mysql Tabellen

6. Schritt – Domain ändern

Letzter Schritt: Die Domain muss jetzt nur noch auf den Speicherplatz der neuen WordPress-Installation umgestellt werden.

Troubleshooting bei “kaputten” Umlauten

Sollten Umlaute nicht funktionieren, empfehle ich diesen Blogpost: Den Inhalt einer mysql Datenbank in utf8 umwandeln

Es kann schon einiges an Kopfzerbrechen verursachen, wenn beispielsweise ein WordPress-Update nur noch kryptische Zeichen statt Umlaute darstellt. Meist liegt das Problem am in der Datenbank verwendetem Zeichensatz. Daten, die beispielsweise in einem latin1 Zeichensatz formatiert sind und in einer utf8-Tabelle abgespeichert werden, werden dadurch beim Auslesen meist unbrauchbar.

Das PHP-Skript hier hilft bei der Umwandlung des Inhalts der Datenbanktabellen in die utf8 Zeichenkodierung. Das Skript wandelt zunächst alle Tabellendaten in Binärdaten um, ändert dann die Tabellencodierung und wandelt schließlich die Tabellendaten wieder in das ursprüngliche Format um. Dadurch werden zum Beispiel Umlaute in ihre utf8-Entsprechungen verwandelt.

Das ist zu tun

1. Zunächst alle Tabellen im Originalformat belassen
2. Eine SICHERHEITSKOPIE DER DATENBANK ANLEGEN
3. Das Skript in einem Texteditor öffnen und die Datenbankparameter anpassen
4. Das Skript auf den Webspace hochladen und im Browser öffnen
5. Das Skript vom Webspace löschen

Wie funktioniert das Skript? Kann ich das auch ohne Skript machen?

Der Trick ist ganz einfach: Wandel ich den Zeichenkodierung einer Tabellenspalte mit folgendem mysql-Befehl in Binärdaten um …

ALTER TABLE Tabellenname CONVERT TO CHARACTER SET binary

… änder dann mit diesem Befehl hier die Zeichenkodierung der Tabelle auf utf8 …

ALTER TABLE Tabellenname CONVERT TO CHARACTER SET utf8

… muss ich im nächsten Schritt die Tabellenspalte wieder auf den ursprünglichen Typ zurücksetzen:

ALTER TABLE Tabellenname MODIFY Spaltentyp Spaltenoptionen

(Wobei Spaltentyp der ursprüngliche Spaltentyp wie Text, Varchar, Enum etc. ist und die Spaltenoptionen die Optionen wie zB. NOT NULL oder DEFAULT sind.)

Das Skript

<?php

$DB_HOST = 'localhost'; // Enter your Database Host
$DB_USER = 'username'; // Enter your Database Username
$DB_PASSWORD = 'password'; // Enter your Database Password
$DB_DATABASE = 'database'; // Enter your Database Name

$tables = array();
$tables_with_fields = array();

$link_id = mysql_connect($DB_HOST, $DB_USER, $DB_PASSWORD) or die('Error establishing a database connection');
echo 'Connected' ."\n";
mysql_select_db($DB_DATABASE, $link_id);
echo 'Selected database' ."\n";

// Gathering information about tables and all the text/string fields that can be affected
// during the conversion to UTF-8.
echo 'Getting tables:' ."\n";
$resource = mysql_query("SHOW TABLES", $link_id);
while ( $result = mysql_fetch_row($resource) ) {
	$tables[] = $result[0];
	echo ' - ' . $result[0] ."\n";
}

if ( !empty($tables) ) {
    echo 'Starting process' ."\n";
    foreach ( (array) $tables as $table ) {
        echo 'Working on table "' . $table . '"';
        $resource = mysql_query("EXPLAIN $table", $link_id);
        while ( $result = mysql_fetch_assoc($resource) ) {
            if ( preg_match('/(char)|(text)|(enum)|(set)/', $result['Type']) )
                $tables_with_fields[$table][$result['Field']] = $result['Type'] . " " . ( "YES" == $result['Null'] ? "" : "NOT " ) . "NULL " .  ( !is_null($result['Default']) ? "DEFAULT '". $result['Default'] ."'" : "" );
                echo '.';
        }
        echo "\n";
    }

    // Change all text/string fields of the tables to their corresponding binary text/string representations.
    echo 'Altering tables to binary character set';
    foreach ( (array) $tables as $table ) {
        mysql_query("ALTER TABLE $table CONVERT TO CHARACTER SET binary", $link_id);
        echo '.';
    }
    echo "\n";

    // Change database and tables to UTF-8 Character set.
    echo 'Altering tables to utf8 character set';
    mysql_query("ALTER DATABASE " . $DB_DATABASE . " CHARACTER SET utf8", $link_id);
    foreach ( (array) $tables as $table ) {
        mysql_query("ALTER TABLE $table CONVERT TO CHARACTER SET utf8", $link_id);
        echo '.';
    }
    echo "\n";

    // Return all binary text/string fields previously changed to their original representations.
    echo 'Altering binary text/string fields to original representation';
    foreach ( (array) $tables_with_fields as $table => $fields ) {
        foreach ( (array) $fields as $field_type => $field_options ) {
            mysql_query("ALTER TABLE $table MODIFY $field_type $field_options", $link_id);
        }
        echo '.';
    }
    echo "\n";

    // Optimize tables and finally close the mysql link.
    echo 'Optimizing tables' . "\n";
    foreach ( (array) $tables as $table )
        mysql_query("OPTIMIZE TABLE $table", $link_id);
    mysql_close($link_id);
    echo 'DONE';
} else {
    die('There are no tables?');
}
?>

Das Skript basiert auf dem mitlerweile nicht mehr weiter entwickeltem WordPress UTF-8 Database Converter und lässt sich in der obigen Form hier herunterladen.

In dieser Reihe von Publizierungen werden alle notwendigen Schritte beschrieben, eine professionelle Entwicklungsumgebung aufzusetzen mit welcher mit dem Zend Framework entwickelt werden kann. Als ZF-Projekt soll beispielhaft ein Gästebuch mit Administrationsbereich erstellt werden.

Hierfür wird zuerst auf dem System (Windows 7) Apache, MySQL und PHP installiert (Zend Community Server) und der Apache entsprechend konfiguriert, dass das zukünftige Projekt über Virtual Hosts ansprechbar ist. Um den Code komfortabel zu verwalten verwenden wir das Versionskontrollsystem Subversion welches wir gegen unbefugte Benutzung absichern werden. Anschließend wird eine Entwicklungsumgebung (Zend Studio für Eclipse) installiert, welche komfortabel mit der Versionsverwaltung und dem Server zusammenarbeiten kann.

Letzlich wird begonnen das eigentliche Projekt, die Programmierung des Gästebuchs, mit Hilfe von verschiedenen Pattern (z.B. MVC) umzusetzen.

Was ist das Zend Framework

Das Zend Framework (oft abgekürzt mit ZF) ist ein komponentenorientieres Framework für PHP 5, welches zahlreiche Klassen bereit stellt mit welchen sehr komfortabel Anwendungen entwickelt werden können.
Komponentenorientiert in diesen Zusammenhang heißt, dass neue Anwendungen komplett auf dem Framework bassierend entwickelt werden können- alternativ können zu bestehenden Anwendungen aber auch nur bestimmte Funktionen, z.B. Cacheing, Authentifizierung, von dem Framework genutzt werden.
Im März 2006 wurde die erste Pre-Alpha-Version 0.1.1 vorgestellt und wird seit dem stetig von Zend Technologies – den Entwicklern von PHP – weiterentwickelt.

Warum das Zend Framework

Frameworks sind mehrere dutzende verfügbar, eine Wahl fällt hier auf den ersten Blick sehr schwer. Stellt man jedoch eine Reihe von Kriterien auf, wird die Auswahl schnell auf wenige eingeschränkt. Ich möchte hier nur ein Paar der zahlreichen Vorteile listen, welche ich bei dem Zend Framework gegenüber anderen Frameworks sehe:

• Komponentenbasierend
  Wie bereits im Paragraphen “Was ist das Zend Framework” beschrieben. Um das ZF zu nutzen müssen bestehende Anwendungen nicht neu geschrieben werden, sondern es können bestimmte Funktionalitäten ohne großen Aufwand genutzt werden.
  Zahlreiche Standardaufgaben wie Formularerstellung und -validierung, E-Mailversandt oder Templates werden durch die Komponenten abgedeckt.
  Durch durchgehend benutzte Design Patterns (“Entwicklungsmuster”) und Adapter (ein Art abkopelbarer Zwischenschritt) können sehr schnell durch wenige Zeilen Code große Teile der Anwendung umgeschrieben werden.  So ist es z.B. innerhalb weniger Sekunden möglich die Anwendung so umzuschreiben, dass diese zukünftig in einer ini-/ xml-Datei oder SQLite-DB statt in einer Oracle-/ MySQL-Datenbank Fehlermeldungen protokolliert.

• Community
  Das ZF hat eine sehr große Community die von Zend selbst wiederum stark gefördert wird (siehe Zend Framework Wiki). Es existieren zahlreiche, natürlich auch deutschsprachige, Foren, Blogs und Tutorials die sich mit dem ZF beschäftigen.

• Dokumentation
  Das ZF ist vorbildhaft dokumentiert. Die Dokumentation wird von Zend selbst immer auf den neusten Stand gehalten, ist in zahlreichen Sprachen verfügbar und verfügt über zahlreiche Beispiele und Tutorials.

• Web 2.0
  Es stehen zahlreiche Klassen bereit, mit welchen man die Services von Google, Delicous, YouTube, Flickr, Yahoo, Amazon etc. ohne hohe Einarbeitungszeit nutzen kann.

• Ajax
  Das Dojo Toolkit ist in das ZF integriert. Hierdurch können sehr schnell Ajax-Applikationen erstellt werden.
  Auch hier gilt wieder – Dojo kann verwendet werden, muss aber nicht. Sind sie bereits ein anderes Framework gewohnt, können Sie dieses ebenfalls mit dem ZF nutzen.

• Weiterentwicklung
  Da hinter dem ZF die Zend Technologies steht, ist eine in Zukunft Weiterentwicklung gesichert – ein großer Pluspunkt im Vergleich zu anderen Frameworks.

• Lizenzierung/Kosten
  Das ZF steht unter der BSD-Lizenz. Kosten entstehen also nicht.

• Testbasis
  Alle Komponenten werden über Unit-Tests getestet. Auch ist es so dem Entwickler möglich, mit relativ wenig Aufwand Tests für seine Applikation zu schreiben.

Warum Zend-Software

In der Einleitung war schon abzulesen, dass hier fast nur Software von Zend verwendet wird. Hintergrund für diese Wahl ist, dass ich persönlich von den Zend-Produkten überzeugt bin: sie zeichnen sich aus durch eine komfortable, leicht zu erlernende Bedienung und zahlreiche kleine Tools welche die tägliche Arbeit stark erleichtern.

Vorteile

So ist es z.B. beim Zend Server möglich über eine Web-GUI schnell die Konfiguration zu ändern (z.B. bestimmte PHP-Extensions oder Error-Logging zu (de)aktivieren) und weil alles “aus einer Hand” kommt wird beim ersten Start von Zend Studio (nur eines von zahlreichen weiteren Beispielen) automatisch der Zend Server gefunden und das Debugging konfiguriert. Natürlich stell Zend Studio auch zahlreiche Tools bereit welche das Arbeiten mit dem ZF noch mehr beschleunigen. Mit Zend Tools ist übrigens ein Server-debugging möglich, das heißt der Code kann auf dem Server selbst, unabhängig vom Code in der Entwicklungsumgebung inspiziert werden.
Zend Studio setzt auf Eclipse auf – es können also die Plugins welche man bereits in Eclipse verwendet hat bzw. kennt, auch in Zend Studio verwenden.

Nachteile

Nach viel Lob und Tadel sollen natürlich auch die negativen Aspekte beleuchtet werden: Zend Studio (Eclipse)  benötigt relativ viel Arbeitsspeicher. Sind mehrere große Projekte parallel geöffnet kann dies den Rechner schon stark belasten (insbesondere wenn Tools wie der HTML-Validator aktiv sind).
Zahlreiche Kinderkrankheiten wurden in Verison 7.1 behoben, welches ein Update auf diese Version obligatorisch ist.
Eine offizielle 64-Bit Version für Linux ist noch nicht verfügbar – zwar kann man die 32-Bit Version installieren, dies läuft aber instabil.
Die Entwicklungsumgebung mag hin und wieder ein wenig oversized wirken: man kann wirklich alles damit machen. Über SSH auf einen Server zugreifen und direkt Remote Dateien editieren oder direkt Datenbanken entwickeln – dies ist aber manchmal einfach zuviel des guten wenn man nur “ein paar Zeilen Code” schreiben will.
Auch arbeiten manche Funktionen, z.B. die Codevervollständigung in Javascript, nicht fehlerfrei; andere Funktionen welche z.B. den Code auf (logische) Korrektheit prüfen arbeiten suboptimal, sodass nach einem Import eines Projektes mehrere 1000 angbliche Fehler gelistet werden – dabei steht aber z.B. der schließende Tag in einer includeten-Datei, was Zend natürlich nicht weiß.

Kosten

Der Zend Server ist in der sog. Community Edition (eingeschränkter Fuktionsumfang) kostenlos erhältich. Für die Entwicklung reichen die Funktionen jedoch voll und ganz aus. Zend Studio kostet mit einem 1-Jahres-Abo für Updates und Support 399€, dies ist jedoch verglichen mit Funktionsumfang ok. Eine Testversion für 30 Tage ist verfügbar.

Ausblick

Im nächsten Beitrag werden wir den Zend Server CE herunterladen und installieren. Es wird ein kurzer Überblick über die Funktionen gegeben. Anschließend werden wir noch zwei Virtual Hosts einrichten (live, development) über welche unsere zukünftige Anwendung dann erreichbar sein wird.

Wichtige Links

• http://www.zend.com/de/ – Zend Technologies, Download von Zend Studio und Zend Server CE.
• http://framework.zend.com - Zend Framework, die offizielle Seite von ZF. Mit Links zur Dokumentation, Tutorials und dem ZF Wiki.
• http://www.dojotoolkit.org/ – Dojo Toolkit, das in ZF integrierte Ajax-Toolkit
• http://www.zfforums.com/ – ZF Forum, englischsprachiges ZF Forum.
• http://www.ralfeggert.de/ – Blog von Ralf Eggert, blogt über das ZF und PHP allgemein.

Eines meiner etwas zurückliegenden Projekte zwang mich externe Bilder durch meinen Server zu laden, zu verkleinern und schließlich auch die Durchschnittsfarbe zu berechnen. Aus Gründen der Performancesteigerung war ich nie ein Fan davon die Durchschnittsfarbe Pixel für Pixel des Originalbildes zu berechnen. Es gibt eine viel elegantere und fast genauso exakte Lösung:

Unser Ziel: Wir möchten ein Bild (jpg, gif, png) über einen HTTP-Stream laden, dieses lokal auf dem Server speichern, ein entsprechendes Thumbnail (eine verkleinerte Version) erzeugen, speichern und schlussendlich die dominierende – oder auch durchschnittliche – Farbe im Bild berechnen und abspeichern. Eventuell möchten wir zusätzlich alles in einer Datenbank hinterlegen – das soll aber zunächst außerhalb unserer Betrachtung liegen.

Für das Berechnen der Durchschnittsfarbe gibt es einen wunderbar einfachen Trick. Doch dazu später mehr. Beginnen wir zunächst einmal mit einer Konstante und einer Funktion, die wir später noch benötigen:

DEFINE('CTX', stream_context_create(array(
    'http' => array(
        'timeout' => 20,
        'method' => 'get',
        'header' => 'Referer: XYZ'
    )
)));

Unsere Konstante CTX ist also ein array. Wir benötigen es für unsere HTTP-Anfrage, mit der wir das gewünschte Bild auf unseren Server laden. Für diese Anfrage verwenden wir die HTTP-GET-Methode, definieren einen Timeout von maximal 20 Sekunden und senden einen Referer im Header, den ich hier mal einfach nur “XYZ” genannt habe.

function randomstring_creator($len = 20) {
    $chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
    $string = '';
    mt_srand((double) microtime() * 1000000);
    for($i = 0; $i < $len; $i++) {
        $string .= $chars{mt_rand(0, strlen($chars))};
    }
    return($string);
}

Die Funktion randomstring_creator() generiert uns eine zufällige Zeichenfolge mit einer beliebigen Länge. Wir benötigen diese Funktion, da wir in diesem Beispiel die Bilder lokal unter einem zufälligem Namen speichern werden.

Weiter geht es mit unseren Klassen. Beginnen wir mit der Klasse Image:

class Image {
    var $img;
    var $source;
    var $local;
    var $dimX;
    var $dimY;
    var $avg_colour;
    function get($source, $quality = 90) {
// siehe unten
    }
    function calc_avg_colour() {
// siehe unten
    }
}

Unsere Klasse besitzt also die Eigenschaften source (die Url, von der das Bild stammt), local (den lokalen Speicherpfad), dimX, dimY (die Abmessungen des Bildes in Pixel) und avg_colour (den farblichen Durchschnittswert als HEX-Code in der Form rrggbb). Die Eigenschaft img ist eine Referenz auf das Image-Objekt, dass ich aber später noch näher beleuchten werde.

Die beiden Funktionen get() und calc_avg_colour() der Klasse sollten selbsterklärend sein. Mit der Funktion get(), die gleichzeitig auch als Konstruktor dient, laden wir das Bild, dass unter source zu finden ist, auf unseren Server und speichern es in der gewünschten JPEG-Qualität (90 als Standard) lokal.

calc_avg_colour() berechnet – wie der Name schon sagt – die Durchschnittsfarbe des in der Eigenschaft img gespeicherten Bildes.

Wir wollen zusätzlich aber auch kleine Abbilder des Originalbildes erstellen und erweitern dazu unsere Image-Klasse um die Klasse Thumbnail:

class Thumbnail extends Image {
    function create($parent, $X = 300, $Y = 300, $quality = 60) {
// siehe unten
    }
}

Diese Erweiterung besitzt zunächst nur eine Funktion, mit der das Thumbnail erstellt wird. Die übergebene Variable parent enthält dabei eine bereits existierende Image-Klasse, die herunterskaliert werden soll. Die maximale Breite und Höhe werden mit den Variablen X und Y (standard bei 300 Pixel) übergeben. Die JPEG-Qualität beträgt standardmäßig nur 60.

Das eigentliche Programm sieht dann nur noch so aus:

$imgurl = 'original.jpg';
// neues Objekt der Klasse Image erzeugen
$img = new Image;
// Bild aus der imgurl laden
if($img->get($imgurl)) {
    // ein Objekt der Klasse Thumbnail erzeugen
    $thumb = new Thumbnail;
    // und ein Thumbnail des oben definierten Objektes der Klasse Image generieren
    $thumb->create($img, 300, 300);
    // dann noch die Durschschnittsfarbe berechnen
    $thumb->calc_avg_colour();
    // und Daten ausgeben... fertig
    echo('Image: ' . $img->source . "\n");
    echo('Thumbnail: ' . $thumb->source . "\n");
    echo('Average colour: #' . $thumb->avg_colour . "\n");
} else {
    echo('Could not get the image.');
}

So, dann sehen wir uns also mal unsere Funktionen der Klassen an. Beginnen wir mit der Funktion get():

function get($source, $quality = 90) {
    $this->source = $source;
    // wir laden das Bild von $source:
    if(($file = file_get_contents($this->source, false, CTX))) {
        // wenn erfolgreich, erzeugen wir mit den geladenen Daten
        // ein neues Bild und speichern dieses in der Eigenschaft img
        $this->img = imagecreatefromstring($file);
        // wir lesen die Höhe und Breite des Bildes aus
        $this->dimX = imagesx($this->img);
        $this->dimY = imagesy($this->img);
        // und speichern das Bild unter zufälligem Namen mit imagejpeg lokal im Ordner "raw"
        $this->local = 'raw/' . randomstring_creator() . '.jpg';
        imagejpeg($this->img, $this->local, $quality);
        // bei Erfolg true zurückgeben
        return(true);
    } else {
        // false, wenn das Bild nicht geladen werden konnte
        return(false);
    }
}

Ein Thumbnail erzeugen wir mit dieser Funktion der Klasse Thumbnail:

function create($parent, $X = 300, $Y = 300, $quality = 60) {
    // zunächst die vorläufigen Abmessungen speichern
    $this->dimX = $X;
    $this->dimY = $Y;
    // die Abmessungen und deren Verhältnis des Originalbildes holen
    $origX = $parent->dimX;
    $origY = $parent->dimY;
    $ratio = $origX / $origY;
    // wenn das Originalbild breiter als hoch ist, kürzen wir die Höhe
    if($X / $Y > $ratio) {
        $this->dimX = $Y * $ratio;
    } else {
    // wenn das Originalbild höher als breit ist, kürzen wir die Breite
        $this->dimY = $X / $ratio;
    }
    // hier erstellen wir ein neues Bild mit den oben berechneten Abmessungen
    $this->img = imagecreatetruecolor($this->dimX, $this->dimY);
    // und kopieren das Originalbild einfach in das eben erstellte kleinere, dabei wird es verkleinert
    imagecopyresampled($this->img, $parent->img, 0, 0, 0, 0, $this->dimX, $this->dimY, $origX, $origY);
    // jetzt speichern wir das neue Thumbnail noch unter zufälligem Namen im Ordner "thumb"
    $this->source = $parent->local;
    $this->local = 'thumb/' . randomstring_creator() . '.jpg';
    imagejpeg($this->img, $this->local, $quality);
}

Das Herzstück: Wir wollen die Durchschnittsfarbe ermitteln. Dazu könnten wir einfach alle Farbwerte aller Pixel zusammen addieren und dann durch die Anzahl der Pixel teilen. Bei einem Thumbnail von der Größe 300 x 300 Pixel, würden wir aber eine Schleife mit 90.000 Durchläufen benötigen. Es gibt einen besseren Weg – einen ganz logischen Trick.

Durchschnittsfarbe berechnen

Wir haben oben beim Erstellen des Thumbnails die Funktion imagecopyresampled() verwendet. Was wenn wir unser Thumbnail einfach auf eine Größe von 1×1 Pixel skalieren? Genau: Es bleibt ein Pixel mit der Durschnittsfarbe übrig. Dessen Farbe auszulesen ist mit imagecolorat() dann nur noch eine Kleinigkeit. Los gehts:

function calc_avg_colour() {
    // ein temporäres Bild mit den Abmessungen 1x1 Pixel erstellen
    $avrg = imagecreatetruecolor(1, 1);
    // Das Thumbnail einfach reinkopieren, dabei auf 1x1 Pixel skalieren
    imagecopyresampled($avrg, $this->img, 0, 0, 0, 0, 1, 1, $this->dimX, $this->dimY);
    // Die Farbe des verbleibenden Pixels auslesen
    $rgb = imagecolorat($avrg, 0, 0);
    // Das temporäre Bild wieder löschen
    imagedestroy($avrg);
    // Und die Farbe in HEX umwandeln
    $r = dechex($rgb >> 16);
    $g = dechex($rgb >> 8 & 255);
    $b = dechex($rgb & 255);
    if(strlen($r) < 2) $r = 0 . $r;
    if(strlen($g) < 2) $g = 0 . $g;
    if(strlen($b) < 2) $b = 0 . $b;
    // tataaaa... da ist unsere Durchschnittsfarbe:
    $this->avg_colour = $r . $g . $b;
}

Super. Das wäre es. Ende und aus.

Die ersten drei Teile dieser Reihe hatten sich mit der theoretischen und praktischen Implementierung des User Consent Flow Prozesses, der für die Authentifizierung des Nutzers mit und der Verwendung der eBay Trading API notwendig ist, befasst. Im vierten und letzten Teil sollen die Implementierungen der letzten drei Teile (Teil 1, Teil 2, Teil 3) dieser Reihe in die Controller und Views umgesetzt und so ein visueller Anmelde- und Authentifizierungsprozess geschaffen werden.

Was wird Teil 4 dieses Guides zeigen?

Wir werden einen Prozess schaffen, der es dem Nutzer erlaubt den eBay User Consent Flow mit Hilfe unserer Webapplikation zu durchschreiten. Dieser Prozess soll möglichst unkompliziert, direkt und intuitiv bedienbar sein. Ich empfehle also die Verwendung von Ajax-Methoden um das User Interface und den darzustellenden Prozess zu visualisieren. Wie das Zend Framework mit Ajax Anfragen umgehen kann wird hier also auch Thema sein.

Warum Ajax?

Wenn wir uns eben an den Ablauf des (in Teil 1 ausführlich beschriebenen) Consent Flow Prozesses erinnern: Der Benutzer muss selbst nur wenige Klicks und Eingaben machen – namentlich die Anmeldung auf der eBay Login-Seite zu der er weitergeleitet wird. Im Hintergrund muss unsere Applikation allerdings zwei Anfragen machen. (1) Eine SessionID von der eBay trading API anfragen und (2) nach der Rückkehr des Benutzers zur Applikation den mit der SessionID verknüpften Auth-Token anfragen.

Hier empfehle ich Ajax: Dem Benutzer soll visualisiert werden, dass sich hinter den Kulissen etwas tut und nicht lange auf den Seitenaufbau warten müssen (die API-Anfragen dauern ein paar wenige Sekunden). Wir werden also die Seite ausliefern, und von dieser eine Ajax-Anfrage starten, die die getSessionID und später die fetchToken Actionen anstoßen wird. Der Benutzer wird ein Lade-Grafik sehen und damit merken, dass sich etwas tut. Die Weiterleitung soll vollautomatisch erfolgen. Das Ergebnis sieht also keinerlei Actionen vom Benutzer auf unserer Applikation vor. Er muss lediglich warten bis er zu eBay weiter geleitet wird und sich dort anmelden kann.

Die benötigten Actions

Wie in Teil 2 bereits aufgestellt brauchen wir neben dem Ebayauth Controller folgende fünf Actions:

• index (stößt den Consent Flow an)
  
• step1 (ist Ziel eines Ajax-Requests – übernimmt getSessionID)
• success (bei erfolgreichem Login auf eBay wird der Benutzer hierhin weitergeleitet)
• step2 (ist Ziel eines Ajax-Requests – übernimmt fetchToken)
• und denied (bei fehlgeschlagenem oder abgebrochenen Login)
  

und vier Views für den Controller Ebayauth:

• index.phtml
• step1.ajax.phtml
• success.phtml
  
• step2.ajax.phtml
• und denied.phtml

Ajax Requests erkennen und entsprechend handeln

Um die Unterscheidung zwischen ‘normalem’ Request und einem Ajax-Request können wir einen Context-Switcher verwenden, den uns das Zend Framework zur Verfügung stellt. Dieser muss in der init()-Methode des Controllers initialisiert werden uns sieht in unserem Fall so aus:

$contextSwitch = $this->_helper->getHelper('AjaxContext');
$contextSwitch->addActionContext('step1', 'html') // wir geben html zurück
              ->addActionContext('step2', 'html') // möglich wäre auch xml oder json
              ->initContext();

// Das übrige Layout abschalten
if($this->_request->isXmlHttpRequest()) {
     $this->_helper->layout->disableLayout();
}

Unsere zwei step Actions benötigen noch eine kleine Fallunterscheidung. Wir möchten sie nur ausführen lassen, wenn es sich tatsächlich um einen Ajax-Request handelt:

if(!$this->_request->isXmlHttpRequest()) {
    $this->_redirect('/ebayauth/index'); // zum Start des Auth-Prozesses umleiten
}

Der Controller Ebayauth

Springen wir gleich in den Code:

public function indexAction() {}

public function step1Action()
{
    if(!$this->_request->isXmlHttpRequest()) {
        $this->_redirect('/ebayauth/index');
    }

    // die getSessionID API-Anfrage durchführen
    $tokenAdapter = new Ebay_Auth_ConsentFlow();
    $return = $tokenAdapter->getSessionID();

    // Wir müssen die SessionID in einer Datenbank oä. zwischenspeichern
    $modelAccount = new Model_Account();

    if($return != false) {
        // zwischenspeichern - bitte durch eigenen Implementierung ersetzen
        $modelAccount->writeEbaySessionId($this->accountID, $return['sessionId']);
        if(isset($return->ShortMessage)) {
            // bei Fehler ist ShortMessage teil der API Rückgabe
            $this->view->error = (string)$return->ShortMessage;
        } else {
            $this->view->redirectURL = $return['redirectUrl'];
        }
    } else {
        $this->view->error = 'Keine Verbindung zu eBay.';
    }
}

public function successAction() {}

public function step2Action()
{
    if(!$this->_request->isXmlHttpRequest()) {
        $this->_redirect('/ebayauth/index');
    }

    // die im step1 zwischengespeicherte SessionID aus der Datenbank holen
    $modelAccount = new Model_Account();
    $sessionId = $modelAccount->getEbaySessionId($this->accountID);

    // die fetchToken API Anfrage ausführen
    $tokenAdapter = new Ebay_Auth_ConsentFlow();
    $return = $tokenAdapter->getToken($sessionId);

    if($return != false) {
        // auch hier wieder eigenen Implementierung Verwenden
        $modelAccount->writeEbayTokenId($this->accountID, $return['token'], $return['expiration']);
        if(isset($return->ShortMessage)) {
            $this->view->error = (string)$return->ShortMessage;
        } else {
            // Hier festlegen wohin umgeleitet werden soll
            $this->view->redirectURL = '/'; // zurück zur Startseiten
            $this->view->expiration = $return['expiration'];
        }
    } else {
        $this->view->error = 'Keine Verbindung zu eBay';
    }
}

public function deniedAction() {}

Die drei Actions index, success und denied benötigen keine Methoden im Controller. Der JavaScript, der den Ajax-Request anstößt coden wir einfach fest in die views ein.

Die Views

Das hier ist der index view (index.phtml). Wir binden ein JavaScript ein und rufen die Funktion shootAjaxHtml() auf.

<div>
    <div id="loader" class="redirect"><img src="/images/preloader.gif" /> Weiterleitung an eBay wird vorbereitet ...
        <script type="text/javascript">shootAjaxHtml('/ebay/step1', 'loader')</script>
    </div>
</div>

Der step1.ajax.phtml View:

<?php if(isset($this->redirectURL)) { ?>
<p>Automatische Weiterleitung zu eBay in wenigen Sekunden. <a href="<?php echo($this->redirectURL); ?>" title="Weiterleitung">Oder hier klicken.</a></p>
<script type="text/javascript">window.location = '<?php echo($this->redirectURL); ?>';</script>
<?php } elseif(isset($this->error)) { ?>
<p class="error"><strong>Fehler:</strong> <?php echo $this->error; ?></p>
<?php } ?>

success.phtml:

<div>
    <div id="loader" class="redirect"><img src="<?php echo SKINPATH; ?>/images/preloader.gif" /> eBay Anmeldung wird abgeschlossen ...
        <script type="text/javascript">shootAjaxHtml('/ebay/authgettoken', 'loader')</script>
    </div>
</div>

Und step2.ajax.phtml:

<?php if(isset($this->redirectURL)) { ?>
<p class="info">Die Verknüpfung des Benutzerkontos mit eBay verliert am <?php echo date('d.m.Y', strtotime($this->expiration)); ?> um <?php echo date('H:m', strtotime($this->expiration)); ?> Uhr seine Gültigkeit.</p>
<p><a href="/ebay" class="black" title="Zurück zur Startseite">Weiter</a></p>
<?php } elseif(isset($this->error)) { ?>
<p class="error"><strong>Fehler:</strong> <?php echo $this->error; ?></p>
<?php } ?>

Im denied View gebe ich nur eine Fehlermeldung wie “Anmeldung fehlgeschlagen”.

Der JavaScript (mit mootools):

function shootAjaxHtml(action, loaderid)
{
    var remote = new Request.HTML({
        url: action + "?format=html",
        onSuccess: function(html) {
            $(loaderid).getParent('div').empty().adopt(html);
        },
        onFailure: function(xhr) {
            $(loaderid).getParent('div').empty().adopt(new Element('p').set('text', 'Es ist ein Fehler aufgetreten: ' +xhr.status +' ' +xhr.statusText).addClass('error'));
        }}).get();
}

Und damit sind wir auch schon fertig.

Ich hoffe die ersten drei Teile dieser Einführung in eine Mögliche Implementierung des Consent Flows der eBay trading API in eine Webapplikation mit dem Zend Framework waren gut verständlich und konnten einen guten Überblick über die benötigten Implementierungsschritte geben. Teil vier hat anhand von Codebeispielen gezeigt, wie man den Consent Flow möglichst benutzerfreundlich umsetzen kann.

Empfehlungen, Anmerkungen, Verbesserungsvorschläge? Dazu sind die Kommentare da!