I started to build apps for the iPhone. Here are some ressources which are useful to know.

Tutorials

• Very good video tutorial about iPhone programming from Paul Hegarty (Stanford University) can be found under IPad and iPhone Application Development (SD) on iTuns U.
• Video tutorials from video2brain:
• Getting Started with iOS 5
• iPhone and iOS Application Development Workshop
• iPhone and iOS 5 Advanced App Development
• http://developer.apple.com/videos/, developer videos from Apple
• http://developer.apple.com/library/mac/#documentation/ToolsLanguages/Conceptual/Xcode4UserGuide/…, XCode User Guide from Apple
• http://developer.apple.com/library/mac/#documentation/General/Conceptual/Mac101/Articles/00_Introduction.html#//apple_ref/doc/uid/TP40010611-CH1-SW1, Your first Mac APP from Apple
• Scripting Bride Programming Guide, interact with programs on your Mac (e.g. iTunes)

Code snippets

• TrayBar – Status Bar in Cocoa (NSStatusBar), get programs into the traybar (Mac OS)
• Execute a terminal command from a Cocoa app, code from stackoverflow.com
• Can I receive a callback whenever an NSPasteboard is written to?, information from stackoverflow.com
• Programmatically causing restart, shutdown and/or logout, Mac OS X Developer Library
• List of sample code from Apple, Mac OS X Developer Library

Communities

List will be extended. If you know additional links, post them in the comments, I will add them.

Updates:

• 2012-01-08: Added code snippets, video tutorials
• 2012-01-10: Added code snippets, communities
• 2012-01-14: Added code snippets, tutorials

You’ll find quite a lot of guides showing you how to install an svn server on your Mac OS X machine. But most of them don’t tell you, that Mac OS X ships with a fully functional svn system. This is how you configure it.

Start of by opening Terminal and creating a new folder holding your future svn repositories:

sudo mkdir /usr/local/svn

Make sure you change the folder’s owner to “www” in order to make it accesable through apache:

sudo chown -R www:www /usr/local/svn

Now create a new repository:

sudo svnserve create /user/local/svn/foo

where foo is your repository’s name.

Make sure, apache is running by checking your system preferences and enabling web sharing.

Now create a new file named svn.conf and place it in /etc/apache2/other. Type the following into the file:

LoadModule dav_svn_module /usr/libexec/apache2/mod_dav_svn.so
<Location /svn>
  DAV svn
  SVNParentPath /usr/local/svn
</Location>

Restart apache by typing

sudo apachectl graceful

into your terminal. And you’re ready and set. Access your repository through http://localhost/svn.

Mac OS X comes with a huge amount of useful stuff. You just need to find and use them. Here is a walkthrough showing you how to set up an automatically backup-system on Mac OS X.

There are several ways to backup your files and probably the best way to do it would be to use rsync. It allows you to backup your files onto a remote machine. But probably this is a bit to heavy for the task you most probably want to achieve: Backup a folder on your local harddrive on a regular basis.

First, create a new file called backupFiles.sh in a folder of your choice. I place sh scripts in /User/myusername/Documents/scripts.

Open it in you favourite editor and type:

# Remove the oldest backup file.
rm –f /Library/WebServer/backups/backup.2.tgz

# Rename the old backup files
mv –f /Library/WebServer/backups/backup.1.tgz /Library/WebServer/backups/backup.2.tgz
mv –f /Library/WebServer/backups/backup.0.tgz /Library/WebServer/backups/backup.1.tgz

# create a new backup file.
tar –czf /Library/WebServer/backups/backup.0.tgz /Library/WebServer/Documents/*

Replace the directories to the directories of your choice. Note: The directory paths have to be absolute paths.

The above script will create a new compressed backup file named backup.0.tgz of my htdocs directory located at /Library/WebServer/Documents. A total of three backups will be found in /Library/WebServer/backups/, where backup.0.tgz is the latest and backup.2.tgz the oldest one.

To set up a new so called cronjob (a command that will be excecutet on a defined, regulare basis) open up your terminal and type:

crontab –e

This will open up your crontab file in your default editor. Probably vim. If you have no crontab file, it will simply create a new empty one.

After pressing i to insert into vim, type:

#min hour mday month wday command
0 3 * * 6 sh /Users/myusername/Documents/scripts/backupFiles.sh

Replace the file path with the path of your custom backup script. Press ESC to stop inserting and type :wq to write and quit vim. A new cronjob has been defined. It will be run at 3 am every Saturday.

You can define the time you want the script to be excecuted like this:

Minute Hour DayOfTheMonth Month Weekday (0 = Sunday, 6 = Saturday) Command

A few examples:

Daily excecution at 3:15 am

15 3 * * * command

Weekly excecution at 6:30 pm every Saturday

30 18 * * 6 command

Monthly excecution at midnight on the first day of the month:

0 0 1 * * command

Use */10 to define the excecution every 10 minutes:

*/10 * * * * command

Hope this helped you backup your files.

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

Oft fallen im Bereich der Bildbearbeitung Aufgaben an, die für eine Fülle von Bildern wiederholt werden muss. Hierfür bietet Adobe Photoshop die Stapelverarbeitung welche beliebige Schritte, z.B. für einen Ordner mit Bildern, wiederholt.

Hier sollen die notwendigen Schritte aufgezeigt werden, welche es benötigt, von Bildern automatisiert Thumbnails zu generieren. Das Orginal-Bild und das Thumbnail (Vorschaubild) sollen beide über ein Wasserzeichen geschützt sein.

Sämtliche benötigten Dateien werden zur Verfügung gestellt, sodass die notwendigen Schritte gut nachvollzogen werden können.

Das Ziel

Das Video zeigt auf, wie Sie die Aktion, welche wir erstellen, anwenden. Natürlich könne Sie jedes beliebige Wasserzeichen verwenden.

Vorbereitung

Die benötigten Dateien laden Sie bitte hier herunter. Nachdem Sie diese auf dem Desktop entpackt haben, starten Sie bitte Adobe Photoshop.

Zu Beginn starten wie Adobe Photoshop und  blenden die Aktionen-Palette über Fenster -> Aktionen oder die Funktionstaste F9 ein.

Aufrufen der Aktionen-Palette

Im rechten Teil verfügen wir nun über die Aktionen-Palette.

Aktionen-Palette

Mit Hilfe dieser Palette können wir (fast) alles was wir in Photoshop ausführen aufzeichen lassen und dann später durch einen Knopfdruck abspielen.

Darüber hinaus öffnen Sie bitte die Datei ROAE-Tutorial/logo.gif (Sie können später die Datei durch Ihr eigenes Logo ersetzen).

Aktion erstellen und aufzeichen

Hinweis: In den Dateien ist bereits die fertige Aktion enthalten (Datei Wasserzeichen_und_Thumbnaill-Photoshop_Aktion), welche Sie durch einen Doppelklick in Photoshop importieren können. Sie müssen also nicht die folgenden Schritte nicht durchführen.

Aus je einem Orginal-Bild sollen zwei Bilder erstellt werden. Einmal das Bild mit einem Wasserzeichen versehen, zum zweiten ein Thumbnail (Vorschaubild), mit einer Breite von 400 Pixeln und ebenfalls einem Wasserzeichen.

Schritt 01: Aktion erstellen

Um die notwendigen Schritte aufzeichnen zu lassen, klicken wir in der Aktionen-Palette auf Neue Aktion erstellen

Erstellen einer neuen Aktion

und tragen in dem neuen Fenster als Aktionsname Wasserzeichen und Thumbnail ein.

Neue Aktion erstellen & aufzeichnen beginnen

Rechts in der Aktionenpalette ist nun der Eintrag Wasserzeichen und Thumbnail markiert. Des weiteren ist der Aufnahme-Knopf aktiviert:

Aktionen werden aufgezeichnet

Bitte achten Sie darauf folgende Schritte genau wie beschrieben auszuführen. Kleine Abweichungen (z.B. wechseln zwischen den geöffneten Dateien) können später zu einem Fehler führen.

Schritt 02: Orginal-Bild öffnen

Über Datei -> Öffnen laden wir zuerst eines unser Original-Bilder in Photoshop. Wählen Sie die Datei ROAE-Tutorial/original_bilder/auto.jpg aus dem entpackten ZIP-Archiv (hier können Sie die Bilder nochmal herunterladen – falls Sie dass noch nicht gemacht haben sollten).

Schritt 03: Hintergrund in Ebene wandeln

Betrachten Sie nun die Ebenenpalette rechts unten (sollte diese nicht sichtbar sein, so blenden Sie diese bitte über Fenster -> Ebenen bzw. die Funktionstaste F7 ein). Klicken Sie mit der rechten Maustaste in der Ebenpalette auf die Ebene Hintergrund und wählen Sie im Kontexmenü Ebene aus Hintergrund. Durch diese Aktion wird die Ebene zu einer “gewöhnlichen” Ebene, was mehr Operationen gestartet.
Den Dialog  welcher Name, Farbe und ähnliches abfragt, bestätigen Sie mit ENTER, d.h. die Standardeinstellungen werden übernommen.

In Ebene wandeln

Die Ebene heißt danach nicht mehr Hintergrund, sondern Ebene 0 oder ähnlich.

Schritt 04: Wasserzeichen kopieren

Wechseln Sie nun auf das zuvor bereits geöffnete Datei logo.gif.

Wählen Sie nun das komplette Bild aus, in dem Sie über das Menü Auswahl -> Alles auswählen oder die Tastenkombination STRG + A verwenden. Kopieren Sie das Wasserzeichen in die Zwischenablage über das Menü Bearbeiten -> Kopieren (alternativ STRG + C).

Schritt 05: Wasserzeichen in Orginal-Bild einfügen

Wechseln Sie nun zurück auf das Original-Bild mit dem Auto und fügen dort das Wasserzeichen über Bearbeiten -> Einfügen (alternativ STRG + V) ein. Das Wasserzeichen wurde nun zentriert eingefügt und in der Ebenen-Palette eine neue Ebene erstellt:

Zentriertes Logo und neue Ebene

Schritt 06: Wasserzeichen ausrichten

Kontrollieren Sie dass in der Ebenen-Palette die Ebene, mit dem Wasserzeichen markiert ist (Ebene 1). Markieren Sie nun wieder alles über Auswahl -> Alles auswählen bzw. STRG + A. Richten Sie nun das Logo aus in dem Sie im Menü Ebene -> Ebenen an Auswahl ausrichten -> Untere Kanten und Ebene -> Ebenen an Auswahl ausrichten -> Rechte Kanten wählen. Das Wasserzeichen befindet sich nun bündig unten rechts.

Wasserzeichen ausgerichtet

Schritt 07: Bild mit Wasserzeichen speichern

Über Datei -> Speichern unter speichern wir das Bild  in dem Ordner roae_tutorial/fertige_bilder/orginal_Bild.jpg. Wählen Sie hierzu bei Format JPEG (*.JPEG, *.JPG, *.JPE).

Bei den Speicheroptionen setzten Sie bitte die Qualität (1) auf Hoch und klicken anschließend auf Speichern .

Qualtität für Bild festlegen

Schritt 08: Thumbnail erstellen

Wählen Sie im Menü Bild -> Bildgröße. Für die Breite tragen Sie 400 unter Pixel ein und klicken anschließend auf OK.

Bildgröße ändern

Schritt 09: Thumbnail speichern

Speichern Sie das verkleinerte Bild nun über Datei -> Speichern unter  in dem Ordner roae_tutorial/fertige_bilder/thumbnail.jpg. Wählen Sie als Dateityp auch hier wieder JPG. Als Qualitätsstufe dürfte hier Mittel in vielen Fällen ausreichend sein.

Schritt 10: Fenster schließen

Schließen Sie nun das Fenster mit dem Orignal-Bild. Eine Nachfrage ob Sie die Änderung speichern wollen verneinen Sie. Die Datei mit dem Wasserzeichen / Logo lassen Sie geöffnet.

Schritt 11: Aufnahme beenden

Beenden Sie nun die Aufnahme über den Button Aufnahme beenden.

Beenden der Aufnahme

Aktion auf alle Bilder in einem Ordner anwenden / Stapelverarbeitung

Damit die Aktion erfolgreich ausgeführt werden kann, schließen Sie alle Dateien in Photoshop. Anschließend öffnen Sie das Wasserzeichen (ROAE-Tutorial/logo.gif).

Einstellungen

Wählen Sie Datei -> Automatisieren -> Stapelverarbeitung. Es öffnet sich ein großer Dialog der sich in die Bestandteile Abspielen, Quelle, Ziel und Fehler unterteilt. Übernehmen Sie nun die Einstellungen wie im Screenshot gezeigt. Die einzelnen Werte sind gefolgt nochmal schriftlich erläutert:

Einstellungen für die Stapelverarbeitung

Abspielen

Wählen Sie bei Satz Standardaktion (1), bei Aktion Wasserzeichen und Thumbnails (2).

Quelle

Bei der Art der Qelle wählen Sie Ordner (3) damit Sie im Dialog den Pfad zu den Orginal-Bildern (ROAE-Tutorial/original-Bilder) angegeben können (4). Öffnen in Aktionen überschreiben (5) muss darüber hinaus aktiviert werden.

Ziel

Bei Ziel wählen Sie wie bei Quelle  Ordner (6) und legen als Pfad im Dialog den Ordner fertige Bilder (ROAE-Tutorial/fertige-Bilder) fest (7). Hier muss “Speichern unter” in Aktionen überschreiben aktiviert werden (8), da sonst die Dateien überschrieben werden.

Im Bereiech Dateibennenung legen Sie bitte folgendes fest: Dokumentenname (9) + _ (10) + Dreistellige Seriennummer (11) + Erweiterung (12). Die Anfangsseriennummer sollte den Wert 1 haben (13)

Fehler

Im Bereich Fehler wählen Sie Bei Fehlern anhalten (14)

Starten und Resultat

Nachdem Sie all diese Einstellungen vorgenommen haben, klicken Sie auf OK (15). Kurz darauf können Sie Photoshop bei der Arbeit zuschauen, wie innerhalb weniger Sekunden die Bilder erstellt  und im Ordner fertige Bilder abgelegt werden:

Die fertigen Bilder, automatisch generiert von Photoshop

Sie können nun natürlich die das Logo oder die Orginal-Bilder durch ihre eigenen ersetzen. Auch können Sie die Aktion anpassen und z.B. die Vorschaubilder mit abgerundeten Ecken versehen.

Für Fragen, Hinweise und Anmerkungen kann wie immer die Kommentarfunktion benutzt werden.

Siehe auch

• Thumbnails erzeugen und Durchschnittsfarbe in PHP ermitteln

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.

Ein kurzer Beitrag welcher beschreibt, wie man unter Windows das Passwort des Benutzers root zurücksetzen, bzw. neu setzen kann, wenn man es vergessen hat.

Um das vergessene Passwort des root Benutzers bei MySQL neu zu setzen sind 3 Schritte notwendig:

• MySQL-Daemon beenden
• Init-Datei mit neuem Passwort anlegen
• MySQL-Daemon mit Init-Datei starten – Passwort wird auf “Init-Passwort” gesetzt

Die notwendigen Schritte werden gefolgt beschrieben bei Verwendung von Windows 7.

Den MySQL-Daemon beenden

Ein laufender MySQL-Daemon muss zuerst beendet werden, damit wir das Passwort ändern können. Hier werden zwei Varianten beschrieben, wobei Variante 1 klar zu empfehlen ist.

Variante 1: MySQL-Daemon über die Computerverwaltung beenden

Rufen Sie die Computerverwaltung über die folgende Schritte auf.

In der Computerverwaltung wählen Sie links im Baum den Bereich Dienste (1), rechts MySQL (2) und beenden den Dienst zuletzt über das Stop-Icon (3).

Variante 2: MySQL-Daemon über den Task-Manager beenden/ killen

(Diesen Schritt brauchen Sie nur durchführen, wenn Sie über die Computerverwaltung MySQL nicht beenden konnten).

Starten Sie den Task-Manger durch einen Rechtsklick auf die Taskleiste und einen Klick auf Task-Manager starten. Klicken Sie im Task-Manager auf den Button Prozesse aller Benutzer anzeigen, um auch die Systemprozesse und somit MySQL gelistet zu bekommen.

Auch Systemprozesse anzeigen

Klicken Sie auf Abbildname (1) um alle Prozesse alphabetisch zu sortieren. Selektieren Sie nun in der Liste den Eintrag mysqld.exe (2). Diesen Prozess können Sie nun durch Prozess beenden (3) beenden. Bestätigen Sie die Aktion in dem Sie bei der Sicherheitsabfrage erneut auf Prozess beenden (4) klicken.

Killen von MySQL über den Task-Manager

Init-Datei anlegen

Die Init-Datei enthält Anweisungen, welche beim Starten von MySQL direkt ausgeführt werden. Wir hinterlegen in ein solchen Datei nun eine Direktive, um das Passwort des Users root zu ändern.

Legen Sie auf dem Desktop eine Datei mit dem Namen mysql-init.txt an. Öffen Sie Datei und kopieren Sie folgende SQL-Anweisung hinein

SET PASSWORD FOR 'root'@'localhost' = PASSWORD('geheim');

Natürlich können Sie statt geheim jedes erdenkliche Passwort verwenden.

MySQL-Daemon mit init-Datei starten

Nun starten wir den MySQL-Daemon mit der init-Datei, welcher wir zuvor erstellt haben.

Öffnen Sie eine Eingabeaufforderung (Startmenü -> CMD -> ENTER). Geben Sie nun folgende Anweisung ein:

<Pfad mysqld.exe> --init-file=C:\Users\<Ihr Windowsbenutzer>\Desktop\my-init.txt --console

So sieht der Aufruf z.B. aus wenn MySQL in einem Unterordner namens Zend installiert ist:

mysqld mit --init-file aufgerufen

Das Passwort wurde nun auf Ihren Wert, welchen Sie im Schritt Init-Datei anlegen festgelegt haben, gesetzt. Beenden Sie nun die Eingabeaufforderung durch STRG + C. Starten Sie nun anschließend wieder mysql über die Diensteverwaltung (siehe oben), in dem Sie das Start-Icon benutzen.

Anschließend können Sie wie gewohnt MySQL nutzen – jetzt aber mit Ihrem neuen Passwort.