Header Joomla Database

Joomla! Zugriff auf die Benutzer Datenbank

  • Johannes Hartwig
  • Blog

Joomla! Verfügt über eine Datenbankstruktur, welche sich über eine Vielzahl von Schichten streckt. Hier liegt das Augenmerk auf die einfache, aber weitreichende Verarbeitung und Verwendung für alle Entwickler. Joomla! bietet viele Arten von Datenbanksystemen, die sich in den Tabellenpräfixen unterscheiden lassen. Darüber hinaus verfügt es über ein Maximum an Vereinbarkeit und Variabilität der eigenen und der Erweiterungen von Joomla!.

J! Datenbank

Die Datenbank von Joomla! ist in zwei unterschiedlichen Bereichen gegliedert.
In dem einen werden alle Daten gespeichert, welche von den eigenen Komponenten verwendet werden. Der andere Teil dient für den Speicherort der übergreifenden Tabellen, sei es ein Asset oder externe Extensions. In diesem Beitrag werde ich nur auf die Benutzer Datenbank eingehen, um damit zu zeigen, wie sich die Verbindungen und Abfragen dieser Tabellen verhalten.

Joomla! Benutzer Object

Der sogenannte Benutzer zeigt alle wichtigen Daten auf, die von einer Person gespeichert wurden, welche sich auf der dementsprechenden Webseite angemeldet hat. Hierbei wird nicht unterschieden, ob die dementsprechende Person nur Zugriff aufs Front- oder Backend besitzt. Die Informationen, die hinter einem jeden Benutzer stehen, sind Informationen, welche Ausschluss geben wie der Benutzername heißt, wie die E-Mail-Adresse lautet oder dem Namen des Benutzers. Ausserdem bekommt man einen Einblick über andere Einstellungen, wie Verbindungen zur Sprache, Editoren, etc. Darüber hinaus werden in der Tabelle auch dynamische Informationen hinterlegt, welche unter anderem die letzte Anmeldung der jeweiligen Person beinhaltet. Einer der wichtigsten Punkte sind die Berechtigungen, welche den jeweiligen Personen zugeteilt worden sind. Mit den Berechtigungen wird eine Hierarchie geboten, um die Struktur nicht zusammenbrechen zu lassen und nicht jedem Benutzer dieselben Freiheiten zu erteilen.

Verwendung der Joomla! Syntax

Um Joomla! zu verwenden muss man die notwendigen Dateien für die Joomla! Factory einbinden. JFactory ist die Joomla! Klasse mit der man auf die wichtigsten Objekte von Joomla! drauf zugreifen kann. Darunter fällt auch die Abfrage an die Joomla! Datenbank. Die notwendigen Dateien (defines und framework) befinden sich in dem Ordner ‘includes‘. Zunächst definiert man die ‘JPATH_BASE‘, welches den Root-Pfad enthalten soll und bettet die Dateien da ein, wo man das Framework und die Methoden/Klassen von Joomla! verwenden will. Wenn das erledigt ist hat man Zugriff auf viele der Joomla! eigenen Methoden und Klassen.

 define('_JEXEC', 1);
 define('JPATH_BASE', dirname(__DIR__));
 // Get Joomla! core functionality
 require_once JPATH_BASE . '/includes/defines.php';
 require_once JPATH_BASE . '/includes/framework.php';
Abbildung 1

Nun können wir das Objekt für alle angemeldeten Benutzer aufrufen. Hier wird zunächst die Verbindung zur JFactory hergestellt und dann kann hiermit schon der direkte Zugriff auf die Benutzer Datenbanktabelle durchgeführt werden. Wir laden alle Daten des angemeldeten Users in die $user Variable. Mithilfe dieser Variablen können wir nun gezielte Abfragen starten und dementsprechende Informationen auslesen.

 // Factory Verbindung herstellen und der Variable $user zuweisen
 $user = Factory::getUser();

 $user_name = $user->name;
 $user_email = $user->email;
 $user_username = $user->username;
Abbildung 2

Man kann nicht nur Abfragen für E-Mail, Name oder Username starten, sondern bekommt man über die API unter anderem Informationen über folgende Datensätze:

Datensätze der J!Datenbank

  • ID
  • Name
  • Benutzername
  • Email
  • Passwort
  • Password_clear
  • Block
  • sendEmail
  • registerDate
  • lastvisitDate
  • Aktivierung
  • Params
  • Gruppen
  • Gast
  • lastResetTime
  • resetCount
  • requireReset

Wenn man noch mehr Informationen braucht, kann man diese über die getParam() Methode aufrufen. Hier kann man unter anderem herausfinden, welche Sprache der Benutzer für sich eingestellt oder welche Zeitzone er gewählt hat.

 //Joomla \ CMS \ Factory
 $user = Factory::getUser(); 
 $user_name = $user->name;
 $sprache = $user->getParam('language', 'Standardsprache');
    
 echo "<p> Der $user_name hat die Sprache {$sprache}, als standard Sprache gesetzt. </p>";
Abbildung 3

User eingeloggt?

In den meisten Fällen will man lediglich herausfinden ob der Benutzer, der die Seite gerade aufruft, auch eingeloggt ist oder über gewisse Rechte verfügt um die Seite zu besuchen. Dieses kann man mit der Benutzer Datenbank herausfinden. Standardmäßig ist ‘guest‘ auf ‘1‘ gesetzt, wenn der Benutzer, der die Seite besucht, nicht angemeldet ist. Ist der User jedoch angemeldet, wird der Status auf ‘0‘ gesetzt. Mit dieser Vorgehensweise kann man dann eine Abfrage starten, indem man einfach den Status von ‘guest‘ ermittelt.

 //Abfrage ob der $user existiert und nicht NULL ist & nicht leer
 if(isset($user) AND !empty($user)){
    // $user->guest enthält 0,1 wenn Gast, eingeloggt
    if(!empty($user->get('id')) AND !$user->guest){
        return true;
    }
 } else {
    	 return false;
 }

 $user=  Factory::getUser();
 $user_name = $user->name;
 if($user->guest){ 
     echo  "<p> Sie sind nur ein Gast. Melden Sie sich an um den Inhalt zu sehen.</p>"; 
 }else{ 
     echo "<p>Willkommen $user_name. Viel spaß beim stöbern.</p>"; 
 }
Abbildung 4

Eingriff in die J!Database

Zunächst muss die Datenbankverbindung aufgebaut werden. Mithilfe der getDbo() Methode können wir eine Verbindung zur J!Database herstellen.

 // Datenbankverbidnung mithilfe der getDbo() Methode aufrufen
 $db = JFactory::getDbo();
 // Nun getQuery Methode aufrufen, den Standardwert auf true setzen
 $query = $db->getQuery(true);
Abbildung 5

Die getQuery() Methode verwendet immer ein optionales Argument, welches entweder „true“ oder „false“ sein kann. Als Standardwert wird immer „false“ gesetzt. Wenn nun die Verbindung einmal aufgebaut ist, können die üblichen SQL-Befehle angewendet werden. Sei es: select, from, join, where und order. Natürlich können auch Inserts, Updates oder Deletes durchgeführt werden. Im folgenden Beispiel zeige ich, wie man ganz einfach den Namen über eine J! Abfrage ermitteln kann und man die User-Id über die JInput Klasse abfragen kann.

JInput als Klasse zur Bestimmung der User-Id

Die User-Id kann man mithilfe der JInput-Klasse bestimmt werden. Mithilfe dieser Klasse können Parameter aus der HTTP Abfrage herausgelesen werden. Hier spielt es keine Rolle ob diese über ein GET oder POST übermittelt worden sind.

 // JInput Klasse verwenden um einen Parameter auszulesen
 $input = Factory::getApplication()->input;
 $user_id = $app->input->get('user', 0, 'int');
 if($user_id != 0){
      $query = $db
          ->getQuery(true)
          ->select($db->quoteName('username'))
          ->from($db->quoteName('#__users'))
          ->where($db->quoteName('id') . ' = ' . $db->quote($user_id));
      $db->setQuery($query);
      $username = $db->loadResult();
 }
Abbildung 6

Natürlich ist es auch möglich direkte Sachen der Benutzer, vorausgesetzt ist es, dass man auch dafür die vorgesehenen Rechte besitzt, bearbeiten kann. Sei es den Namen zu verändern oder wenn es nur darum geht die Zeitzone zu verändern. Da aber diese Handhabung in den seltensten Fällen zum Tragen kommt, wurde diese hier nicht besprochen.

Field Type Nullable Default Key Extra
id integer NOT NULL pk auto_increment
name varchar(255) NOT NULL
username varchar(150) NOT NULL
email varchar(100) NOT NULL
password varchar(100) NOT NULL
usertype varchar(25) NOT NULL
block tinyint(4) 0
sendEmail tinyint(4) NOT NULL 0
registerDate datetime NOT NULL '0000-00-00 00:00:00'
lastvisitDate datetime NOT NULL '0000-00-00 00:00:00'
activation varchar(100) NOT NULL
params text NOT NULL

Indizes

Index Name Columns(s) Unique?
usertype usertype No
idx_name name No
Idx_block block No
username username No
email email No

Fazit

Mithilfe der Joomla! API, ist es einem möglich auf viele vorgefertigten Methoden und Klassen zuzugreifen, um somit viele Abfragen zu vereinfachen und den Code schlank zu halten. Ich finde, wenn man einmal die ganze Geschichte dahinter versteht, ist es recht einfach Daten über angemeldete Benutzer herauszufiltern und an gewissen Stellen zu verwenden.

Mithilfe der Benutzerdatenbank und die dazugehörigen Methoden und Klassen, die einem von Joomla! zur Verfügung gestellt werden, ist es ein Kinderspiel an den verschiedensten Stellen Informationen für die Benutzer bereit zu stellen oder abzufragen.

Joomla!, query, sql, jfactory, jdatabase, user

Johannes Team EURESA
Autor: Johannes Hartwig  
Webentwicklung & IT
Der Johannes ist unser Webdesigner. Bereits während seines Studiums der Wirtschaftsinformatik hat er sich auf die Programmierung von Websites mithilfe von Joomla! spezialisiert. Zudem kümmert er sich um die technische Pflege sowie Optimierung (SEO) von Internetauftritten.

Joomla!

Php

Hardware

Adresse


EURESA Consulting GmbH
Graf-Siegfried-Straße 6
54439 Saarburg