Ich Schätze das ist um 2004 entstanden und lieferte Termine bzw. Events von einem bestimmten Tag, das ganze für einen Webkalender ala Google-Calendar. Was ich noch erwähnen sollte…. die Funktion wurde für jeden sichtbaren Kalendertag aufgerufen!

 function getevents($year,$month,$day){
   global $SELF;
   $month = (strlen($month) < 2) ? '0'.$month : $month;
   $day = (strlen($day) < 2) ? '0'.$day : $day;
   $str = "$year-$month-$day";
   $strx = "$month-$day";
   $sql = "
           SELECT e.name as ename,
                                                e.description as edescr,
                                                e.id as eid,
                                                t.color as tcolor,
                                                e.time_start as time_start,
                                                e.time_end as time_end,
                                                e.remember as rem,
                                        e.date_start as date_start,
                                                e.date_end as date_end,
                                                t.description as tdescription,
                                                t.showtime as showtime
           FROM cal_entry e, cal_types t
           WHERE e.types_id = t.id
             AND (e.date_start <= '$str'
                           AND ( e.date_end >= '$str' AND e.date_end IS NOT NULL OR e.date_start = '$str' AND e.date_end IS NULL )
         OR(t.id = 1 AND right(e.date_start,5) = '$strx')
                         )
                        ORDER BY e.time_start, t.prio
         ";
   $res = mysql_query($sql);
   $out = "<u><a href=\"$SELF?show=new&date=$year-$month-$day\">$day.$month.</a></u>";
   while($row = mysql_fetch_array($res)){
     $tmp = "<a href=\"$SELF?show=edit&eid=".$row["eid"]."&ym=$year-$month\">";
 
                 $tmp .= "<font class=\"entry\" color=\"".$row["tcolor"]."\"><li>";
                 $tmp .= $row["ename"];
                 $starta = explode("-",$row["date_start"]);
                 $outstart = $starta[2].".".$starta[1].".".$starta[0];
                 $enda = explode("-",$row["date_end"]);
                 $outend = $enda[2].".".$enda[1].".".$enda[0];
                 $divbody = "<table border=0 class=entry><tr>";
                 if($row["date_end"] != '' && $row["date_start"] != $row["date_end"]){
                   $divbody .= "<td>Von:</td><td>$outstart</td></tr><tr><td>Bis:</td><td>$outend</td></tr>";
                 }else{
                   $divbody .= "<td>Am:</td><td>$outstart</td></tr>";
                 }
                 if($row["showtime"]) {
                     if(($row["date_end"] == $row["date_start"] || $row["date_end"] == '') && $row["time_end"] != ''){
                       $divbody .= "<tr><td>Von:</td><td>".$row["time_start"]." Uhr</td></tr>";
                             $divbody .= "<tr><td>Bis:</td><td>".$row["time_end"]." Uhr</td></tr>";
                     }elseif($row["date_start"] < $row["date_end"] && $row["date_start"] == $str && $row["time_start"] != ''){
                           $divbody .= "<tr><td>Ab:</td><td>".$row["time_start"]." Uhr</td></tr>";
                     }elseif($row["date_start"] < $row["date_end"] && $row["date_end"] == $str && $row["time_end"] != ''){
                       $divbody .= "<tr><td>Bis:</td><td>".$row["time_end"]." Uhr</td></tr>";
                     }elseif(($row["date_end"] == $row["date_start"] || $row["date_end"] == '') && $row["time_end"] == ''){
                       $divbody .= "<tr><td>Ab:</td><td>".$row["time_start"]." Uhr</td></tr>";
                     }
                 }
                 $rem = ($row["rem"] == true) ? "<font color=green>EMail Erinnerung aktiv</font>" : "<font color=red>EMail Erinnerung inaktiv</font>";
                 $divbody .= "</table>";
                 #$div = "<div title=\"header=[".$row["ename"]."] body=[".$row["edescr"].$divbody"]\">";
                 $div = '<div title="header=['.$row["ename"].'] body=['.nl2br($row["edescr"]).$divbody.$rem.']">';
                 $tmp .= "</div></li></font></a>";
                 $out .= $div.$tmp;
         }
 
   return $out;
 }

Das Tool nutzt Webkit im internen Backend und kann sogar CSS3 rendern. Die Installation unter MaxOSX und Linux ist absolut simpel: runterladen, ablegen, fertig. Unter Windows wird hier noch ein Installationsprozess durchgeführt, über den ich aktuell leider nichts sagen kann (bisher nicht getestet).

Um das Tool auf einer Webseite zu nutzen, habe ich mir ne kleine Klasse geschrieben, die HTML-Code als Input akzeptiert und mir den Pfad der fertigen PDF-Datei zurückliefert.

class HtmlToPdf {
	const TMP = '/tmp/';
	const EXEC = '/usr/local/bin/wkhtmltopdf-amd64'; //anpassen!
	private $executable;
	private $htmlcode;
	private $tmphtmlfile;
	private $targetFilename;
 
	private $options = array(
		'--ignore-load-errors'
	); //Kommandozeilenoptionen für wkhtmltopdf
 
	public function __construct($targetFilename = ''){
		$this->targetFilename = $targetFilename;
	}
 
	public function setHtmlCode($htmlcode){
		$this->htmlcode = $htmlcode;
	}
 
	public function setTargetFilename($targetFilename){
		$this->targetFilename = $targetFilename;
	}
 
	public function generate(){
		$this->createTempHtmlFile();
		$this->convertHtmlfileToPdf();
		return self::TMP.$this->targetFilename;
	}
 
	private function createTempHtmlFile(){
		$filename = tempnam(self::TMP);
		File::move($filename, $filename.'.html'); //nötig, damit die Datei als Input akzeptiert wird
		$filename .= '.html';
		file_put_contents($filename, $this->htmlcode);
		$this->tmphtmlfile = $filename;
	}
 
	private function convertHtmlfileToPdf(){
		if(!$this->targetFilename){
			$this->generateTargetFilename();
		}
		$cmd = self::EXEC.' '.implode(' ', $this->options).' '.$this->tmphtmlfile.' '.self::TMP.$this->targetFilename;
		shell_exec($cmd);
		File::delete($this->tmphtmlfile);
	}
 
	private function generateTargetFilename(){
		$this->targetFilename = uniqueid().'.pdf';
	}
}

Und so nutzt man das Ganze:

$converter = new HtmlToPdf('output.pdf');
$converter->setHtmlCode($htmlcodeWithCSS);
$pdfFile = $converter->generate()

Sehr praktisch ist es, wenn man eine Templateengine (z.B. Smarty) nutzt, hier kann man erst den kompletten Code generieren und ihn dann via $smarty->fetch() in den Konverter übergeben. Über einen Parameter kann man dann noch dafür sorgen, dass der CSS Style nicht ausgelagert, sondern im head-Block ausgegeben wird, da das Tool sonst nicht damit klarkommt.

Reproduzierbar ist er folgendermaßen:

$from = new DateTime();
$from->setTime(0, 0, 0);
$from->setISODate(2010, 28, 1); //Montag der 28ten Woche 2010
 
echo $from->format('d.m.Y H:i'); //A
echo $from->getTimestamp(); //B
echo date('Y-m-d H:i', $from->getTimestamp()); //C

A: das ausgegeben Datum stimmt, es ist der 12.07.2010
B: der Timestamp ist viel zu hoch: 1291849200
C: der Beweis, der Timestamp gehört zum 29.05.2011 00:00

Wir haben lange versucht herauszufinden, warum dies passiert. Ein hässlicher Workaround ist dieser:

$from->add(new DateInterval('P0D'));

Wir fügen also ein Interval von 0 Tagen (oder Stunden, Minuten etc) hinzu, wodurch sich eigentlich nichts ändern sollte. Danach stimmt das Ergebnis von ->getTimestamp() allerdings, nämlich 1278885600.

Nachdem wir absolut keinen Grund feststellen konnten, haben wir das Vertrauen verloren und nutzen seitdem Zend_Date, welches, meiner Meinung nach, besser und einfacher zu bedienen ist. Das ZendFramework ist sowieso schon im aktuellen Projekt eingebunden (nicht als Framework an sich, eher als Klassensammlung), als sprach es auch nicht dagegen, einen riesen Klotz an Dateien/Klassen zu integrieren, um nur eine Klasse zu nutzen.

$date = new Zend_Date();
$date->setWeek(28)->setYear(2010)->setWeekday(1);
$date->setHour(0)->setMinute(0)->setSecond(0);
echo $date->getTimestamp();

Liefert das erwartete Ergebnis: 1278885600

Ist das nun wirklich ein riesen DateTime Bug oder liegt ein Denkfehler unsererseits vor?

class MyClass implements Interator {
  private $array;
}
 
$obj = new MyClass();
foreach($obj as $key => $val){
  ...
}

Damit dieses Konstrukt funktioniert, benötigt die Klasse “MyClass” ein paar weitere Methoden und ein Attribut, welche vom Interface vorgeschrieben werden:

public function rewind(){
  $this->pointer = 0;
}
public function current(){
  return $this->array[$this->pointer];
}
public function key(){
  return $this->pointer;
}
public function next(){
  $this->pointer++;
}
public function valid(){
  return isset($this->array[$this->pointer]);
}

Nun geht das ganze aber auch viel einfacher und mit saubererem Code, mit dem IteratorAggregate Interface und einem schon vorhandenem Iterator (wie dem ArrayIterator). Das Interface ist ziemlich Ähnlich und implementiert ebenfalls Traversable.

class MyClass implements IteratorAggregate {
  private $array;
  public function getIterator(){
    return new ArrayIterator($this->array);
  }
}
 
$obj = new MyClass();
foreach($obj as $key => $value){
  ...
}

Da auf meinem Websever lighttpd und nicht apache läuft, konnte ich mich nicht 100%ig an die Anleitung auf der WP MU Seite halten.

In lighttpd gibt es kein .htaccess, also müssen die Rewriteregeln (ich nutze Subdomains, keine Unterverzeichnisse), in die lighttpd-config. Das ganze sieht so aus:

$HTTP["host"] =~ "^((.*).?example\.de)$" {
  server.document-root = "/var/www/.../wp3/"
  server.error-handler-404 = "/index.php"  #hierdurch erspart man sich rewrite regeln für schöne permalinks
  url.rewrite-once = (
    "^/(.*/)?files/$" => "/index.php",
   "^/(.*/)?files/(.*)" => "/wp-content/blogs.php?file=$2",
    "^/([_0-9a-zA-Z-]+/)?(wp-.*)" => "/$2",
    "^/([_0-9a-zA-Z-]+/)?(.*\.php)$" => "/$2",
  )
}

Der Rest lief einwandfrei nach offizieller Anleitung, da in einigen der anderen Blogs allerdings recht viele Bilder sind, viel mir sofort die mangelnde Performance diesbezüglich auf. Der Grund war schnell gefunden, gab es 40 Bilder auf einer Seite, bedeutete dies, aufgrund der zweiten Rewriteregel, jeweils einen Aufruf eines PHP Skriptes, welches einen ganzen Schweif an includes inkl. Datenbankverbindungen und Queries mit sich bringt.

Die Lösung war, mit ein wenig Linuxwissen, aber schnell gefunden: Symlinks für jeden einzelnen Blog. Erfordert zwar ein wenig mehr Verwaltungsaufwand, spart aber das Umleiten über ein PHP Skript, um Bilder anzuzeigen. Die Regel muss dann so aussehen:

    "^/(.*/)?files/(.*)$" => "/wp-content/blogs.dir/%0/files/$2",

Das %0 funktioniert so nur, weil die Hostdefinition (Zeile 1 im oberen Code) als Pattern definiert ist!

Im, laut Anleitung angelegten, blogs.dir Verzeichnis müssen nun Symlinks angelegt werden:

ln -s /var/www/.../wp3/wp-content/blogs.dir/[BlogID] /var/www/.../wp3/wp-content/blogs.dir/[subdomain].example.de

Falls jemand eine elegantere Lösung kennt, als für jeden Blog einen Symlink anzulegen, als her damit!

Nach langem hin und her und viel Recherche habe ich mir aus diversen Codefragmenten das hier zusammengebaut und es scheint zu funktionieren:

	function price2float($string){
	    $string = trim($string);
		if(preg_match('/([0-9\.,-]+)/', $string, $matches)){
			// Zahl gefunden also können wir weitermachen
			$string = $matches[0];

			if(preg_match('/^[0-9.-\s]*[\,]{1}[0-9-]{0,2}$/', $string)){
				// Komma als Dezimal Separator
				// Alle Punkte entfernen und anschließend das Komma in einen Punkt umwandeln
				$string = str_replace(' ', '', $string);
				$string = str_replace('.', '', $string);
				$string = str_replace(',', '.', $string);
				return floatval($string);
			}
			elseif(preg_match('/^[0-9,-\s]*[\.]{1}[0-9-]{0,2}$/', $string)){
				// Punkt als Dezimal Separator
				// Alle Kommata entfernen
				$string = str_replace(' ', '', $string);
				$string = str_replace(',', '', $string);
				return floatval($string);
			}
			elseif(preg_match('/^[0-9.-\s]*[\.]{1}[0-9-]{0,3}$/', $string)){
				// Es gibt nur Tausender Separatoren
				// Alle Punkte enfernen
				$string = str_replace(' ', '', $string);
				$string = str_replace('.', '', $string);
				return floatval($string);
			}
			elseif(preg_match('/^[0-9,-\s]*[\,]{1}[0-9-]{0,3}$/', $string)){
				// Es gibt nur Tausender Separatoren
				// Alle Kommata enfernen
				$string = str_replace(' ', '', $string);
				$string = str_replace(',', '', $string);
				return floatval($string);
			}
			else{
				return floatval($string);
			}
		}
		else{
			return 0;
		}
	}

Beispiele zum selbsttesten:
1234.456,78 => 123456.78
1234,456.78 => 123456.78
12.34 => 12.34
12,34 => 12.34
123.456.789 => 123456789
123,456,789 => 123456789

wie immer bin ich für Verbesserungsvorschläge offen!

Meine kleine Bibliothek ist auf GoogleCode zu finden: http://code.google.com/p/phplinkfetcher/

Einige “Fetcher”-Klassen sind bereits dabei, würde mich aber noch über weitere freuen. Ideen und Verbesserungsvorschläge
in Form von Code oder Kritik ist auch jederzeit erwünscht, einfach hier kommentieren oder den Issue-Tracker von Google nutzen.

class Address {
  /*diverse Properties, hauptsächlich Strings*/
}
class MethodSpecial extends Method {
  /*diverse andere Properties*/
}
abtract class Method {
  protected $address;
  public function setAddress(Address $address){
    $this->address = $address;
  }
}

$address = new Address(.....);
$method = new SpecialMethod(....);
$method->setAddress($address);

$string = serialize($method);

Gibt man $string mit einem einfachen echo aus, fällt auf, dass hier komische Sonderzeichen vorhanden sind, speichert man das ganze in ein TEXT Feld in einer Tabelle, werden aus diesen Zeichen Sternchen. Das unserialize schlägt fehl.

Nun gibt es zwei Ansätze, dieses Problem zu lösen:
1. base64_encode und base64_decode: einfach den String vorher kodieren und dann speichern, beim auslesen dann erst dekodieren und danach deserialisieren.
2. GLOB bzw. BLOB statt TEXT als Feldtyp nutzen (nicht von mir getestet, der Tip wurde mit von einem Bekannten gegeben)

Installiert wird der Codesniffer über den Updatemanager (Help -> Install New Software…), hier die Update-URL “http://www.phpsrc.org/eclipse/pti/” eintragen und den Sniffer, sowie wahlweise auch PHPUnit installieren. In den globalen Einstellungen kann man nun einen Standard wählen, Zend und PEAR sind relativ strikt, General enthält typische Regeln, ich habe mich allerdings entschieden, mir aus den vorhandenen Regeln einen eigenen Standard zu erstellen.

Aber zuerst zur Konfiguration:
Oben wird eine lokal installierte PHP Binary gewählt werden, darunter wählt man optional eine PEAR Bibliothek, <internal> wird mitgeliefert und reicht völlig aus. Während man sich einen eigenen Standard zusammenstellt oder nicht nachvollziehen kann, welche Regel einen bestimmten Fehler wirft, empfiehlt es sich den Debugmodus zu aktivieren. Darunter sind nun die vordefinierten Standards zu finden, hier wählen wir später unseren Standard als “default”, aktuell existiert dieser aber noch nicht. Unten sollte man nur noch einstellen, wie breit ein Tab ist und bestätigt erst einmal mit OK.

Testen kann man das ganze nun mit dem Generic-Standard, indem man einen Ordner, ein Projekt oder eine Datei im Navigator wählt und im Kontextmenü unter dem Punkt “PHP Tools” den “PHP Code Sniffer” klickt. Hat man in den Einstellungen den entsprechenden Validator aktiviert, muss man eine geöffnete Datei nur speichern oder explizit validieren.

Im Quelltext werden nun “Fehler” markiert:

Eine der gesetzten Regeln besagt, dass ein String nicht in double quotes eingeschlossen sein darf, falls dies nicht unbedingt nötig ist (Nötig wäre es z.B. bei einem manuellen Zeilenumbruch im String). Nachdem man nun die double quotes gegen quotes getauscht hat und die Datei gespeichert hat, verschwindet der Fehler.

Erstellen eines eigenen Standards:

Den Pfad zu den Standards musste ich selbst auch erst suchen, er ist tief im plugins Verzeichnis von Eclipse versteckt:

/plugins/org.phpsrc.eclipse.pti.library.pear_1.1.1.R20091122000100/php/library/PEAR/PHP/CodeSniffer/Standards

Die Verzeichnisstruktur sieht hier folgendermaßen aus (daran muss sich gehalten werden, wenn der eigene Standard funktionieren soll, da hier mit autoload gearbeitet wird!).

Als Vorlage nehmen wir den Zend-Standard und kopieren erstmal das Verzeichnis nach MyStandard, das Unterverzeichnis Sniffs (so werden einzelne Regeln bezeichnet) solle bestehen bleiben, den Inhalt können wir jedoch erst einmal löschen. Die Datei ZendCodingStandard.php wird umbenannt in MyStandardCodingStandard.php und der Inhalt angepasst, in Zeile 33 muss der Klassenname stimmen, aus

class PHP_CodeSniffer_Standards_Zend_ZendCodingStandard extends PHP_CodeSniffer_Standards_CodingStandard{

wird

class PHP_CodeSniffer_Standards_MyStandard_MyStandardCodingStandard extends PHP_CodeSniffer_Standards_CodingStandard

Nicht vergessen, den Standard in den Einstellungen als “default” zu setzen, dies geht entweder global oder pro Projekt, sobald der Ordner erstellt ist.
Nun können weiter unten in der Methode “getIncludedSniffs()” vorhandene Regeln aus allen Standards zusammengestellt werden, die Dateinamen sollten aussagekräftig genug sein, ansonsten gibts es eigentlich in allen Sniffs entsprechende Kommentare.

    public function getIncludedSniffs()
    {
        return array(
                'Generic/Sniffs/Functions/OpeningFunctionBraceBsdAllmanSniff.php',
                'Generic/Sniffs/PHP/DisallowShortOpenTagSniff.php',
                'Generic/Sniffs/WhiteSpace/DisallowTabIndentSniff.php',
                'PEAR/Sniffs/Classes/ClassDeclarationSniff.php',
                'PEAR/Sniffs/ControlStructures/ControlSignatureSniff.php',
                'PEAR/Sniffs/Files/LineEndingsSniff.php',
                'PEAR/Sniffs/Functions/FunctionCallArgumentSpacingSniff.php',
                'PEAR/Sniffs/Functions/FunctionCallSignatureSniff.php',
                'PEAR/Sniffs/Functions/ValidDefaultValueSniff.php',
                'PEAR/Sniffs/WhiteSpace/ScopeClosingBraceSniff.php',
                'Squiz/Sniffs/Functions/GlobalFunctionSniff.php',
               );

    }//end getIncludedSniffs()

Zusätzlich zu den hier aufgezählten “externen” Regeln kann man nun eigene Sniffs erstellen, in dem ein Ordner mit der entsprechenden “Kategorie” im Verzeichnis “Sniffs” angelegt wird, z.B. “Array”, hier muss nun eine PHP Datei angelegt werden, deren Dateiname mit ..Sniff.php enden muss, dieser Sniff wird dann vom CodeSniffer automatisch geladen. Wichtig ist, dass der Klassenname innerhalb der Datei stimmt: Die Datei “/MyStandard/Sniffs/Arrays/ArrayDeclarationSniff.php” muss diesen Klassennamen tragen:

class MyStandard_Sniffs_Arrays_ArrayDeclarationSniff implements PHP_CodeSniffer_Sniff

Hat man sich seinen Standard zusammengestellt, ist aber mit Details eines bestimmten Sniffs so nicht zufrieden, kopiert man ihn sich einfach in seinen Standard und entfernt ihn aus dem array, in dem die externen Sniffs definiert sind. Zusätzlich passt man noch den Klassennamen an und ändert die entsprechende Stelle im Code.