$rechner_array = split(',',$rechner);
$rechner_array_size = count($rechner_array);
foreach($rechner_array as $element) {
  $counter++;
  $element = trim($element);
  $einzelne_rechner .= ''.$element.'';
  if($counter!=$rechner_array_size) {
    $einzelne_rechner .= '\',\'';
  }
}

Tja, das war mein erster einfacher Gedanke. Durch die äußerst hilfreichen Kommentare, sind weitere Lösungen hinzugekommen.
Der klassische Einzeile für obiges Beispiel lautet:

implode(',', $rechner);

oder

join(',', $rechner);

Split ist nämlich ein NoGo.

Und mit Entfernung von Leerzeichen ergibt sich:

implode(',', array_map(‘trim’, $rechner));

Vielen Dank an alle.

 $rechnernummer = $_POST['rechnernummer'];
 $monitor_nr = $_POST['monitor_nr'];
 $externe_ip = $_POST['externe_ip'];
 $ipnummer = $_POST['ipnummer'];
 $zertifikat = $_POST['zertifikat'];
 $passwort = $_POST['passwort'];
 $macadresse = $_POST['macadresse'];
 $orts_id = $_POST['orts_id'];
 $verwendungs_id = $_POST['verwendungs_id'];
 $bereichs_id = $_POST['bereichs_id'];
 $seriennummer = $_POST['seriennummer'];
 $bemerkung = $_POST['bemerkung'];

Dies ist natürlich alles andere als dynamisch und sparsamer Code.
Daher habe ich mich nach einer besseren Alternative umgeschaut und bin dabei auf folgendes gestoßen:

foreach($_POST as $k=>$v) $$k=$v;

Dieser Einzeiler macht genau das, was ich gesucht habe.

Hinweis: Aus Sicherheitsgründen ist es ratsam, dass alles, was per POST verschickt wird, erst validiert werden sollte, bevor ihr es blind (wie in meinem Beispiel) weiterverwendet.

Ich setze an dieser Stelle eine erfolgreiche Verbindung per mysql_connect() zur MySQL-Datenbank voraus. Außerdem benötigt ihr einen Google Maps-API Key, den ihr hier erhaltet.
Wie ich feststellen musste, ist dieser IP- bzw. Domainabhängig, d.h. er funktioniert nur unter der IP/Domain, die ihr bei der Anmeldung des Keys angegeben hat.

Um schön modular und nicht reduntant zu arbeiten habe ich 2 Funktionen geschrieben.
Eine dient für die Geokodierung eines Ortes geocodeOrt($adresse, $orts_id) , die andere itteriert durch alle in der Datenbank vorhandenen Orte namens alleOrte() und übergibt an geocodeOrt($adresse, $orts_id) die Parameter $adresse bestehend aus Straße, Hausnummer, PLZ , Ort und die $orts_id, was die ID des geokodiertem Ort ist.

Funktion alleOrte():

function alleOrte() {
 $query_alleOrte = "SELECT orts_id as id, concat(strasse,',',plz,' ',ort) as adresse FROM orte";
 $query_alleOrte_result = mysql_query($query_alleOrte);

 while ($row = mysql_fetch_array($query_alleOrte_result)) {
  geocodeOrt($row['adresse'], $row['id']);
 }
}

Und nun die spannendere Funktion geocodeOrt($adresse, $orts_id):

function geocodeOrt($adresse, $id) {
 define("MAPS_HOST", "maps.google.com");
 define("KEY", KEY); // hier euren Key als String eintragen

 $delay = 0;
 $base_url = "http://" . MAPS_HOST . "/maps/geo?output=xml" . "&key=" . KEY;
 $geocode_pending = true;
 while ($geocode_pending) {
  $request_url = $base_url . "&q=" . urlencode($adresse);
  $xml = simplexml_load_file($request_url) or die("url not loading");

  $status = $xml->Response->Status->code;
  if (strcmp($status, "200") == 0) {
   // Successful geocode
   $geocode_pending = false;
   $coordinates = $xml->Response->Placemark->Point->coordinates;
   $coordinatesSplit = split(",", $coordinates);
   // Format: Laenge, Breite, Hoehe
   $breite = $coordinatesSplit[1];
   $laenge = $coordinatesSplit[0];

   $query_update = "UPDATE orte
   SET laengengrad = '$laenge',
   breitengrad = '$breite'
   WHERE orts_id = '$id'";

   $update_result = mysql_query($query_update);
   if (!$update_result) {
    die("Invalid query: " . mysql_error());
   }
 } else if (strcmp($status, "620") == 0) {
  // sent geocodes too fast
  $delay += 100000;
 } else {
   // failure to geocode
   $geocode_pending = false;
   echo "Address " . $adresse . " failed to geocoded. ";
   echo "Received status " . $status . "\n";
  }
  usleep($delay);
 }
}

Da die Funktion geocodeOrt($adresse, $id) seperat ist, könnt ihr nun auch praktisch diese Funktion aufrufen, wenn in eurem z.B. CMS einen neuen Ort anlegt und direkt dann die Geokodierung durchführen möchtet.
So braucht ihr nicht wieder komplett alle Orte neu geokodieren zu lassen.

Ich hoffe, euch ist nun einiges klarer damit geworden und ich konnte euch helfen.

Wir ihr schon bei den letzten Aritkeln sehen könnt, verwende ich dies bereits und macht den Beitrag schon um einiges leserlicher.

Wenn ihr also Code einbinden möchtet, packt vor dem Codeblock einfach ein

[sourcecode language=”php”]

(oder eine andere Programmiersprache nach Wahl, siehe hier) und dahinter einfach ein

[/sourcecode]

und erstrahlt der Codeblock in schönen Farben, wenn ihr den Artikel anschaut. Allerdings seht ihr das noch nicht in eurem Blogposting-Tool bzw. im Backend.

Ich habe nämlich darüber gegrübelt, wie man denn bei externen PHP-Dateien auf die Sessions insbesondere die Benutzer-IDs der aktuellen Joomla-Session / Sitzung kommt.
Um die Lösung zu veranschaulichen, mache ich an dieser Stelle ein einfaches Beispiel:

Ihr erstellt einen Ordner im Joomla-Root-Verzeichnis z.B. „test“ , indem ihr außerdem noch eine „test.php“ mit folgendem Inhalt anlegt:

<?php
if(ISSET($user)) die( 'Restricted access' );
define('_JEXEC', 1);
define('JPATH_BASE', '../');
define('DS', DIRECTORY_SEPARATOR);
require_once(JPATH_BASE.DS.'includes'.DS.'defines.php');
require_once(JPATH_BASE.DS.'includes'.DS.'framework.php');
$mainframe = JFactory::getApplication('site');
$mainframe->initialise();
$user = JFactory::getUser();
echo $user->get('id');
?>

Diese Testseite gibt also nur die ID des eingeloggten Users aus.

Aber damit dies überhaupt funktioniert, muss die erstellte Testdatei in Joomla eingebunden werden. Dazu geht man in die Menüeinstellungen (sinnvoll wäre hier das „Benutzer-Menü“, welches nur nach einem Login angezeigt wird) und erstellt dort einen neuen „internen“ Link vom Typ „Wrapper“.

In den Einstellunge des Wrapper-Links ist die Wrapper-URL von entscheidener Bedeutung. Hier tragt ihr den Pfad oberhalb des htdocs ein, also in diesem Fall /joomla/test/test.php

Anschließend oben rechts auf speichern, das Joomla-Frontend aufrufen, einloggen und den Link testen.

Nun wird im Frontend die User-ID angezeigt. Was ihr dann damit anstellt, ist euch überlassen.

Dazu lädt man die aktuellste Version von FPDF herunter und entpackt diese in einen Unterordner des PHP-Projektes.
Anschließend wird diese Library per

require('../fpdf/fpdf.php');

in die PHP-Datei eingebunden.

Nun kann man eine Instanz des FPDF-Objekts erzeugen und loslegen:

$pdf=new FPDF(); // Instanziierung
$pdf->AddPage(); // Erste Seite wird generiert
$pdf->SetFont('Arial','B',16); // Schriftart, B=Bold(Fett), Schriftgröße
$pdf->Cell(40,10,'Hello World!'); // Erzeugung eines Textbereiches der Größe 40x10 mit Inhalt "Hello World!"
$pdf->Output(); // PDF wird generiert (Standard = an den Browser zum Download geschickt)

Beim Instanziieren gibt es mehrere Parameter, mit denen man noch die Maße des PDFs und die Ausrichtung angeben kann. Standardgemäß ist A4 und Landscape ausgewählt, wenn man keine Parameter den den Konstruktor übergibt. Möchte man die Ausrichtung „Portrait“, also senkrecht, oder ein anderes Format haben, kann dies so erledigen:

$pdf=new FPDF('P','mm','A5');

Weiterhin lässt sich die Ausgabe auch dahingehend konfigurieren, dass das erzeugte PDF direkt in einem gewünschten Pfad gespeichert wird:

$pdf->Output('../pdfs/document.pdf','F');

Für mehr Einstellungen und Hilfe schaut doch einfach mal bei den Tutorials von FPDF vorbei. Diese sind gut und anschaulich erklärt.

$heute_datetime = date("Y-m-d H:i:s"); // Mit Uhrzeit
$heute_date = date("Y-m-d"); // Ohne Uhrzeit

Wird allerdings aus MySQL ausgelesen, muss man diesen Wert allerdings in das deutsche Format umwandeln:

$datum = explode("-",$wert_aus_db);
$datum = $datum[2].'.'.$datum[1].'.'.$datum[0]; // Nur Datum ohne Uhrzeit

Ich hoffe, ich konnte euch bei diesem Problem helfen.

Damit dies überhaupt möglich ist, muss man sich die GD-Library herunterladen und installieren. Diese gibt es für Windows, Linux und Mac OS X.

Man startet dann damit, dass man sich in z.B. Gimp oder Photoshop ein transparentes Bild mit dem gewünschten Format erstellt und dann als PNG abspeichert. Dieses wird am besten in einem Unterordner „Bilder“ (um Ordnung zu halten) im Verzeichnis erstellt, wo sich die PHP-Datei befindet.

Um möglichst flexibel zu sein, ist es empfehlenswert sich hierfür eine eigene Funtion in einer eigenen PHP-Datei mit den nötigen Parametern (je nach Belieben) zu erstellen, z.B.:

function erzeugeTextAufBild($text, $fontsize)

Anschließend fügt man in dieser Funktion folgenden Code ein:

Header('Content-type: image/png');
$img = ImageCreateFromPNG("Pfad zum transparenten Bild");
$color = ImageColorAllocate($img, 255, 255, 255); //Farbe der Schrift
$ttf = "Pfad zur Schriftart"; //Schriftart
$ttfsize = $fontsize; //Schriftgroesse
$angle = 0;  // Winkel der Schrift
$t_x = 21; // Startpunkt x auf dem transparenten Bild
$t_y = 35;  // Startpunkt y auf dem transparenten Bild

imagealphablending($img, true); //  alphablending aktivieren
imagesavealpha($img, true); // alphablending settings speichern
imagettftext($img, $ttfsize, $angle, $t_x, $t_y, $color, $ttf, $text); // Text auf Bild packen
imagepng($img); // Bild erstellen
imagedestroy($img); // Der belegte Zwischenspeicher des Bildes wird wieder freigegeben

Das waren die wichtigsten Einstellungen, an einigen müsst ihr noch eine Feinjustierung vornehmen, z.B. $t_x und $t_y.

Tipps: Ich habe für diese Funktion eine eigene PHP-Datei (bild.php) erstellt, um damit flexibler agieren zu können (Meiner Meinung nach ist es sogar zwingend erforderlich, dies in einer eigenen Datei zu erledigen, da der Header der Datei auf PNG geändert wird). So kann man in der CSS-Datei eine Klasse für das Bild erstellen und per

background-image: url("./bild.php?bild=HalloWelt");

ansteuern. Vergesst an dieser Stelle nicht, die Größe per „width“ und „height“ entsprechend der Größe eures transparenten Bildes anzupassen.

In der bild.php würde dann am Anfang folgendes stehen:

$bild = '';
if ( isset($_POST['bild'])){
$bild = $_POST['bild'];
} else { $bild = $_GET['bild']; }

switch($bild){
case 'HalloWelt':
erzeugeTextAufBild("Hallo Welt", 45);
break;
}

Natürlich lassen sich noch beliebig viele Parameter ergänzen, aber dies dürfte für eine kleine Einführung reichen.

Bei Fragen und Anregungen, könnt ihr mir diese natürlich gerne per Kommentar mitteilen.

Hier habe ich ein interessantes Umlaute-Problem, welches ich nicht sofort lösen konnte.
Umlaute wurden erst nicht richtig vom JavaScript zur Serverseite (PHP) geschickt und anschließend kamen auch Umlaute nicht richtig vom DBMS MySQL zurück.

Die Lösung für dieses Problem ist allerdings eigenartig:

	mysql_query('set character set utf8;');

Dieser Code-Schnipsel muss nach dem mysql_connect() eingefügt werden und sorgt somit, dass wirklich auch immer per UTF8 übertragen bzw. erzwungen wird.

Weitere Möglichkeiten um Probleme mit Umlauten zu lösen:

header('content-type: text/html; charset=UTF-8');

(am Besten direkt am Anfang nach dem <? – Tag)

UND/ODER

<meta http-equiv=„Content-Type“ content=„text/html; charset=UTF-8″ />

(oben innerhalb des HEAD-Tags einer HTML/PHP-Seite einbinden)

Natürlich ist es auch empfehlenswert, die erstellten Dateien direkt im UTF8-Format abzuspeichern.
Notepad++, mein Favorit in einer Windows-Umgebung, kann das zum Beispiel sehr fix und ist kinderleicht einzustellen.

Weiterhin sehr hilfreich und manchmal sogar notwendig ist es besonders auch in JavaScript (nicht nur), wenn man Umlaute HTML-codiert ausgibt oder umschreibt.
Dazu hilft folgende Tabelle:

Man sieht, es ist nicht schwer sich den Aufbau zu merken: Erst ein „&“ (Ampersand), dann vom Umlaut der normale Laut und danach ein „uml;“ .
Mehr Kodierungen gibt es bei SELFHTML.

dies ist mein neuer Blog, dieses Mal gezielt zu dem Thema „Webentwicklung“, wo ich einige interessante Themen vorstellen und praktische Tutorials veröffentlichen möchte.

Viel Spaß (und natürlich auch Erfolg)
maTTes