Monatliches Archiv: Juni 2011

Joomla 1.6 Entwicklung – Datenbank Insert

In Joomla 1.6 habe ich zwei Möglichkeiten gefunden, sinnvolle Datenbank INSERT Befehle abzusetzen. Die eine Möglichkeit macht es auf objektorientierter Ebene, mit der man ein wenig mehr Möglichkeiten besitzt, als mit der zweiten Methode. Diese besteht einfach aus einem ganz normalen INSERT Query, der einfach ausgeführt wird. Zunächst gibt es aber Grundlegendes, was gemacht werden muss. Dies ist einmal vor dem Erstellen des Query ein Queryprojekt einbauen und einmal darunter die Query-Ausführung. Diese beiden Teile der Datenbankabfrage sind immer gleich. Wir erstellen also erst einmal eine Datenbankverbindung

1
2
3
4
5
6
7
// Hier erstellen wir eine Datenbankverbindung
$db = $this->getDbo();
/**
*    Hier kommt unsere Query-Definition hin
**/
// Und nun müssen wir die Abfrage auch ausführen.
$db->query()

Nun haben wir zweierlei Möglichkeiten einen Datenbank Query in Joomla 1.6 zu definieren. Als erstes möchte ich auf die OOP Variante eingehen. Dabei wird ein neues Query Objekt erstellt und dann nach und nach mit entsprechenden Daten gefüllt. Ich denke hier bestehen mehr Möglichkeiten, da sich die Definition auf beliebigen Code aufteilen lässt und so weitere Berechnungen gemacht werden können, bevor die Query-Definition fertig gestellt wird.

1
2
3
4
5
6
7
8
9
// Wir erstellen einen neuen Query
$sql = $db->getQuery(true);
// Der Query ist ein INSERT in die Tabelle “kontakt” ist
$sql->insert(‘#__kontakt’);
// wir legen noch Daten für 2 Felder fest
$sql->set(‘vorname’ = ‘Testvorname’);
$sql->set(‘nachname’ = ‘Testnachname’);
//Wir setzen unseren Query bereit zur ausführung
$db->setQuery((string)$sql);

Damit hätten wir einen Objektorientierten INSERT in die Datenbank ausgeführt. Aber wenn wir „nur mal schnell“ einen INSERT in die Datenbank von Joomla 1.6 ausführen möchten. Dazu haben wir eine etwas „einfachere“ Möglichkeit.

1
2
3
4
5
// Wir erstellen uns einen Query
$sql = ‘INSERT INTO #__kontakt (vorname, nachname)
VALUES (“Testvorname”, “Testnachname”);’
// Wir setzen den Query zur Ausführung
$db->setQuery($sql);

Wenn es um die Realisierung eines größeren Projektes geht, rate ich zu der Objektorientierten Methode eine Datenbankabfrage in Joomla 1.6 abzusetzen. Diese gibt einem einfach viel mehr Spielraum um den Query entsprechend zu bearbeiten.

Sehr wichtig ist hier ganz oft auch dass man sich die Fehlermeldungen ausgibt. Dies kann in Joomla 1.6 mit folgenden zwei Zeilen realisiert werden.

1
2
3
4
// Wir lassen uns die Fehler geben
$fehler = $db->getErrorMsg();
// Wir geben die Fehler aus
echo $fehler;

So haben wir die Möglichkeit zu sehen, ob die Ausführung unseres Query’s Probleme bereitet. Wenn es Fehler gibt, werden diese auch ausgegeben.

Joomla 1.6 Komponente erstellen – Teil1

Da Joomla! 1.6 erst Anfang dieses Jahres herausgekommen ist, gibt es noch nicht wirklich viele Tutorials und Informationen im deutschen Bereich. Wenn Sie jedoch eine Joomla 1.6 komponente erstellen möchten wäre so manche Info hilfreich. Da ich derzeit dabei bin eine Joomla 1.6 Komponente zu erstellen, möchte ich mein Wissen und meine Erfahrungen damit mit euch teilen. In diesem Joomla 1.6 Tutorial möchte ich so viele Facetten der Komponenten Entwicklung für Joomla 1.6 zeigen. Das Joomla 1.6 Tutorial soll von Anfänger bis Fortgeschritten gehen. Das bedeutet dass wir eine Komponente erstellen werden, die erst einmal im Frontend nur eine Liste aus der Datenbank ausgibt. Dazu wird es dann eine Administrations Verwaltung geben. Am Schluss dieses Joomla 1.6 Tutorial möchte ich euch zeigen wie diese Listen so realisiert werden können, dass auf der Webseite eine Liste ausgegeben wird die aber von mehreren Benutzern erstellt worden ist. Dabei darf jeder Benutzer nur seine eigenen Einträge sehen und verwalten. Dazu wird es dann nebenbei noch ein Joomla 1.6 Tutorial geben, wie ein Content-Modul erstellt wird, dass die Daten auf der Webseite ausgibt, so dass dieses Flexibel eingesetzt werden kann. Falls etwas unvollständig oder missverständlich ist, solltet ihr mir das schnellstmöglich über die Kommentarfunktion mitteilen. Dies gilt ebenso für Fehler etc.

Wenn Sie eine Joomla 1.6 Komponente erstellen möchten, müssen folgende persönlichen Vorraussetzungen gegeben sein (Vorraussetzungen für dieses Joomla 1.6 Tutorial:

  • Basis Kenntnisse im Backend von Joomla! 1.6
  • Gute Kenntnisse in PHP
  • Gute Kenntnisse in Objektorientierter Programmierung (OOP)
  • viel Ausdauer

Nun aber zum grundsätzlichen Aufbau der Komponente (Und dieses Joomla 1.6 Tutorial). Alle Komponenten, Plugins und Module folgen dem Model View Controller (kurz MVC) Konzept. Genau nach diesem Prinzip ist auch die Ordnerstruktur einer Komponente aufgebaut. Dabei ist das Model das Datenmodel nach dem die Daten verarbeitet werden. Das View ist letztendlich unser Template und ist zuständig für das Anzeigen der Elemente / Inhalte. Der Controller übernimmt dabei die Steuerung zwischen Ansicht und Datenmodell. Jegliche Interaktionen laufen in der Regel über den Controller.

Wie die Dateien am besten editiert werden bleibt jedem selbst überlassen. Ich verwende phpStorm. Ich erstelle mir im Root-Verzeichnis neben den ganzen Joomla! 1.6 Verzeichnissen ein Verzeichnis /dev. Dort erstelle ich ein entsprechendes Verzeichnis für die Komponente, das Modul oder Plugin. In unserem Fall beim Tutorial wäre das dann /dev/com_list/. In diesem Verzeichnis wiederrum finden sich dann alle notwendigen Dateien für die Komponente, das Modul oder Plugin. Warum mache ich das so kompliziert? Dafür habe ich mehrere Gründe. Ich finde es immer noch einfacher als die ganze Zeit zwischen den Systemordnern hin und her zu wechseln. Desweiteren erreiche ich dadurch den Vorteil dass ich das entsprechende Verzeichnis (com_list) jederzeit herunterladen und zippen kann. Diese Zip ist eine vollwertige Joomla! 1.6 erweiterung. Das bedeutet ich kann in jedes Joomla! 1.6 wechseln und muss nur diese Zip-Datei über den Erweiterungsmanager installieren. Allerdings hat diese Methode einen gravierenden Nachteil: Die Erweiterung muss jedes mal neu installiert werden. Da Joomla! 1.6 die Installation von einem Verzeichnis aus starten kann gehe ich dann entsprechend in den Erweiterungsmanager und gebe das Verzeichnis an. Bei jeder Änderung gehe ich also wieder in den Erweiterungsmanager und drücke auf installieren. Joomla! 1.6 Speichert den einegebenen Pfad solange ich eingeloggt bin, ich muss ihn also nicht jedesmal erneut angeben. Ich denke das ist verkraftbar. So könnt Ihr am ende dieses Joomla 1.6 Tutorial auch diese hier erstellte Komponente erstellen.

Dieses Joomla 1.6! Tutorial werde ich nicht weiter fortführen. Es wird bei Gelegenheit ein Tutorial für eine neuere Joomla! Version geben.

Domain auf www umleiten mit htaccess

Für Suchmaschinen ist es sehr sinnvoll dass Domains nur über eine festgelegte Adresse erreichbar sind. Leider ist es so dass die Adresse www.domain.tld eine andere als domain.tld ist. Da dies zwei unterschiedliche Adressen sind aber beide den gleichen Inhalt anzeigen werten das viele Suchmaschinen als sogenannten „Duplicate Content“. Dies wird entsprechend mit Abstrafung bestraft. Eine Möglichkeit um sinnvoll auf www umzuleiten ist dies via htaccess zu tun. Dazu muss folgender Code in die .htaccess eingefügt werden:

1
2
3
RewriteEngine On
rewritecond %{HTTP_HOST} ^domain.tld [nc]
rewriterule ^(.*)$ http://www.domain.tld/$1 [r=301,nc]

Wenn die .htaccess dann im Hauptverzeichnis liegt, wird jede Anfrage ohne www auf die mit www umgeleitet. Der Umleitungscode 301 wird auch „Permanently Moved“ genannt. Wie Permanently Moved schon sagt, wird den Suchmaschinen gesagt den Inhalt der gesuchten Adresse findest du in Zukunft unter www.domain.tld. Damit ist das Problem „Duplicate Content“ behoben.

Typoscript abgekoppelte Navigation der 2. Ebene

Bei so manchen Seite ist es sinnvoll, in der Navigation die zweite Ebene von der ersten Ebene völlig separat darzustellen. Dies nennt sich abgekoppelte Navigation. Beispielsweise wenn die zweite Ebene einer Navigation an einer völlig anderen Stelle ausgegeben werden soll. Umgangssprachlich habe ich dies als abgekoppelte Navigation immer verstanden. Mit folgendem Typo Script wird das möglich

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
# Hauptnavigation ausgeben
temp.navi = HMENU
temp.navi {
   special = directory
   special.value = 1
   1 = TMENU
   1 {
      noBlur = 1
      NO {
         1.NO = 1
         ATagTitle.field = description // title
      }
      CUR < .NO
      CUR = 1
      CUR.ATagParams = class=”aktiv”
      CUR.before.cObject=LOAD_REGISTER
      CUR.before.cObject.rootuid.cObject = TEXT
      CUR.before.cObject.rootuid.cObject.value = {field:uid}
      CUR.before.cObject.rootuid.cObject.insertData = 1
      ACT < .NO
      ACT = 1
      ACT.ATagParams = class=”aktiv”
      ACT.before.cObject=LOAD_REGISTER
      ACT.before.cObject.rootuid.cObject = TEXT
      ACT.before.cObject.rootuid.cObject.value = {field:uid}
      ACT.before.cObject.rootuid.cObject.insertData = 1
   }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
# Navigation an der Seite
   temp.snavi = HMENU
   temp.snavi {
   special = directory
   special.value = {register:rootuid}
   special.value.insertData = 1
   entryLevel = 1
   1 = TMENU
   1 {
      noBlur = 1
      wrap =
      <ul>|</ul>
      NO = 1
      NO {
         wrapItemAndSub =
         <ul>
            <li>|</li>
         </ul>
         ATagTitle.field = description // title
      }
      CUR &lt; .NO
      CUR = 1
      CUR {
         ATagParams = class=”aktiv”
         wrapItemAndSub =
         <ul>
            <li>|</li>
         </ul>
      }
      ACT &lt; .NO
      ACT = 1
      ACT {
         ATagParams = class=”aktiv”
      }
      ACTIFSUB &lt; .NO
      ACTIFSUB = 1
      ACTIFSUB {
         ATagParams = class=”aktiv”
         wrapItemAndSub =
         <ul>
            <li>|</li>
         </ul>
      }
      CURIFSUB &lt; .CUR
      CURIFSUB = 1
      CURIFSUB{
         ATagParams = class=”aktiv”
         wrapItemAndSub =
         <ul>
               <li>|</li>
         </ul>
      }
   }
}

jQuery Quelltexte zum Schluss ausführen

Möchte man dass JQuery Funktionen erst nach dem Laden der Webseite ausgeführt werden, kann man die Ausführung verzögern bis die Seite vollständig geladen wurde.

Im folgenden Beispiel erkläre ich einen kleinen JQuery Code-Schnipsel der dies bewirkt.

1
2
3
4
5
$(document).ready(function () {

// Hier würden dann die auszuführenden Anweisungen stehen.

});

Alle Anweisungen die innerhalb dieses Blockes stehen, werden erst ausgeführt wenn die Seite vollständig geladen wurde. Dies ist zum Beispiel sinnvoll wenn man ein JQuery Plugin verwenden möchte (z.B. einen Slider) und der erst richtig funktioniert wenn alle Bilder geladen sind.

CSV Import mit PHP

Des öfteren hat man aus einem Export aus, anderen Systemen CSV-Dateien die wieder in ein Projekt importiert werden sollen. Ein Import einer CSV-Datei kann in PHP sehr leicht geschrieben werden. Im folgenden werde ich den Import einer CSV-Datei kurz und knackig erklären.

Als Beispiel besitzen wir eine CSV Datei mit 3 Spalten und mehreren Zeilen. Die erste Zeile ist die Headerzeile und gibt die Spaltenbeschriftung an.

Hier der dazu notwendige Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// Datei öffnen
$dateihandle = fopen('dateipfad/dateiname.csv', 'r+');
// Prüfen ob $dateihandle auch ein wirklicher Dateizeiger ist
if(!is_resource($dateihandle){
die("Datei konnte nicht geöffnet werden");
}
// Wenn eine Headerzeile existiert lesen wir diese als erstes aus:
$headline = explode(';', fgets($dateihandle));
// Nun durchlaufen wir die gesamte datei in einer Schleife.
while($zeile = fgets($dateihandle)){
$zeileninhalt = explode(';', $zeile);
// Hier können wir mittels $zeileninhalt['Spaltennummer'] auf die Inhalte zugreifen
// Bitte beachten dass die Zählung der Spaltennummer bei 0 anfängt
}
// Zum Schluss noch die Datei ordnungsgemäß schließen
fclose($dateihandle);

Was passiert hier nun im Detail? Es ist relativ simpel. Mit fopen() öffnen wir die Datei und erstellen einen Dateizeiger.
Im nächsten Schritt prüfen wir mit is_resource() ob bei dem öffnen der Datei auch wirklich nichts schief gelaufen ist und $dateihandle eine echte Resource für weitere Handlungen ist.
Die Zeile mit $headline wird natürlich nur benötigt, wenn auch eine Headline in der CSV vorhanden ist. Sollte in der CSV keine Headline vorhanden sein, diese Zeile aber dennoch an gegeben sein, dann wird der erste Datensatz ignoriert. Mit explode() erstellen wir aus der Zeile der CSV ein Array auf das wir hinterher bequem via Array-Index zugreifen können. Die while Schleife wird so lange ausgeführt bis fgets() einen Fehler zurückliefert. Dies ist der Fall wenn das Ende der CSV Datei erreicht wurde und fgets() nicht mehr weiter die Datei auslesen kann. Am Ende schließen wir die Datei wieder ordnungsgemäß.

Nun haben wir einen sehr einfachen CSV Import geschrieben.

Mit mod_rewrite teile der URL entfernen

Mit der mod_rewrite Engine des Apache ist es möglich Teile der angesteuerten URL zu entfernen.

Dazu muss folgender Eintrag in die .htaccess auf dem
Root-Verzeichnis des Web Projektes:

1
RewriteRule verzeichnis1/verzeichnis2/(.*) http://domain.tld/$1 [R=3D301,L]

Diese Zeile bewirkt dass alle Anfragen die an http://domain.tld/verzeichnis2/verzeichnis2/seite.html auf http://domain.tld/seite.html umgeleitet werden. Wenn die Seite mit der alten Struktur verzeichnis1/verzeichnis2 indiziert wurde und die Struktur der überarbeiteten Seite sich nun auf / geändert hat, kann dies bewirken dass die von Suchmaschinen indizierte Seite weiterhin erreichbar ist. Google wird beim nächsten Besuch merken, dass die Seite nun unter einer anderen URL verfügbar ist. Dieses teilen wir Google mit dem Weiterleitungscode 301 mit. So wird schon bald die neue Struktur der Webseite auch in den Suchmaschinen zu finden sein.

TypoScript Basis konfiguration

Fast immer ist es sinnvoll einen festen Bestandteil an Konfigurationen zu haben. So erspart man sich so manchen Ärger. Ein Beispiel so einer Basis Konfiguration ist folgender:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
config {
/*
* Das Caching von Typo3 deaktivieren.
*
* Dies ist nur so lange sinnvoll wie an der Seite gearbeitet wird.
* So muss nicht bei jeder Template bearbeitung der Cache von hand geleert werden.
*
* Zum aktivieren des Caches einfach die 1 durch eine 0 ersetzen.
*
*/
no_cache = 1

/*
* Basis URL der Typo3 Installation
*
* Sehr wichtig für so manche Funktion.
* Wird zum Beispiel für Druck-Ansichten oder RealURL verwendet
*
*/
baseURL = http://deine-eigene-domain.tld/
}

Dieser Code kann so in das Root-Template kopiert und eingebaut werden. Er wird von TypoScript sofort verstanden und muss nicht noch irgendwo zugewiesen werden.

Mit einem Grundstock an TypoScript Basis Konfigurationen kann man sich beim weiteren erstellen der Seite viele suchereien ersparen. Allerdings sollten die Konfigurationsmöglichkeiten auch verstanden werden. Wer es nicht versteht sollte sich erst weiter noch damit auseinander setzen.

Wer aber wirklich etwas auf seiner Seite sehen will muss noch viel mehr als nur diesen einfachen config{} Block einbauen.

Mit PHP Dateien erstellen

Ich möchte hier ganz kurz darauf eingehen wie mit PHP Dateien erstellen kann und die Grundfunktion erklären. Dabei stellt dies keinen vollwertigen Codeschnipsel dar sondern eher eine Art Grundstruktur. Mit dieser Grundstruktur können dann erweiterte Operationen durchgeführt werden, die am Ende dann das entsprechende gewünschte Ergebnis bringen.

Dabei ist es völlig egal ob man eine CSV-Datei oder eine Text Datei erstellen möchte.

Allerdings muss unbedingt darauf geachtet werden, dass der Webserver in dem entsrechenden Rechte für das Verzeichnis (zum Anlegen) bzw. die Datei (zum neu beschreiben) besitzt.

1
2
3
4
5
6
7
8
9
// Als erstes erstellen wir ein Dateihandle und öffnen die Datei
// Falls die Datei nicht existiert, wird versucht sie anzulegen
$handle = fopen(“pfad/zur/datei.end” , “w+”);
// Irgend ein beliebiger Inhalt
$inhalt = “test”;
// Wir schreiben in die Datei
fwrite($dateihandle, $inhalt);
// und zu guter letzt schließen wir die Datei wieder
fclose($dateihandle);

Dies ist eine kleine Grundstruktur die man sich merken oder immer gleich zur Hand haben sollte denn sie zeigt ganz einfach wie man mit PHP dateien erstellen kann..