2. Kajona V3 | HowTo: Simple Pagelement
HowTo: Simple Pagelement
Mit diesem kleinen Tutorial soll der Aufbau einfachster Seitenelemente in Kajona beschrieben
werden. Das Tutorial beschreibt hierfür die Entwicklung eines Seitenelements zur Ausgabe des
Datums des letzten Bearbeitens der aktuellen Seite – Besucher der Internetseite können so
schnell erkennen, ob die Seite seit dem letzten Besuch verändert wurde, oder nicht. Das Element
„lastmodified“ benötigt hierfür keine eigenen Datenbankeinträge, weswegen auf die Erstellung von
Elementen mit Tabellen hier nicht eingegangen wird.
Analog zu diesem Seitenelement lassen sich natürlich auch andere, einfach Seitenelemente
aufbauen.
Eine aktuelle Version dieses Seitenelements gibt es auch auf www.kajona.de zum Download.
Dateistruktur erstellen
Das im Folgenden entwickelte Seitenelement soll natürlich nicht nur für das eigene System
verwendet werden, sondern soll auch an andere Kajona-User weitergegeben werden können. Von
daher sollte das Seitenelement gleich in einer Version erstellt werden, die später weiter verteilbar
ist.
In unserem Fall legen wir nun einen Ordner „element_lastmodified“ an, der nachstehende Dateien
und Ordner beinhaltet:
element_lastmodified
| admin
| | elemente
| | class_element_lastmodified.php
|
| installer
| | installer_element_lastmodified.php
|
| portal
| |elemente
| | class_element_lastmodified.php
|
| texte
| portal
| modul_elemente
| texte_lastmodified.php
Als Grafik sieht das dann so aus:
www.kajona.de 2/9
3. Kajona V3 | HowTo: Simple Pagelement
Doch nun zur Bedeutung der einzelnen Dateien im Detail:
/admin/elemente/class_element_lastmodified.php
●
In dieser Datei befindet sich die Repräsentation des Seitenelements im Admin-Bereich.
Dies beinhaltet die Formulare im Admin-Bereich zum Anlegen des Elements.
/installer/installer_element_lastmodified.php
●
Wie der Name schon sagt übernimmt diese Datei die Installation des Seitenelements in
einem Kajona System. Dies wird vor allem dann interessant, wenn man das Seitenelement
auch an andere Anwender weitergeben möchte.
/portal/elemente/class_element_lastmodified.php
●
Alles was im Portal passiert, wird in dieser Datei definiert. In unserem Fall wäre das nun die
Ausgabe des Datums der letzten Modifikation der aktuellen Seite.
/texte/portal/modul_elemente/texte_lastmodified_de.php
●
In dieser Datei schließlich liegen die Texte, die das Element zur Aufbereitung der Daten für
das Portal benötigt. Möchte man weitere Sprachen unterstützen, so muss lediglich eine
weitere Datei mit entsprechendem Kürzel angelegt werden.
Benötigte Klassen erstellen
Nachdem nun alle benötigten Dateien angelegt wurden, geht es nun an das Erstellen der benötigte
Klassen, also des Programmcodes.
Beginnen möchten wir hier mit dem
Installer
Der Dateiname des Installers des Seitenelements sollte nach dem Namensschema
installer_element_name.php aufgebaut sein, in unserem Fall also
installer_element_lastmodified.php. Der Installer ist die umfangreichste Klasse und soll nun im
Detail erläutert werden. Der fertige Installer ist wie folgt aufgebaut (der Inhalt der gesamten Datei
sowie aller anderen Dateien befindet sich auch noch einmal im Anhang dieses Dokuments).
<?php
Damit die Klasse alle benötigten Interfaces, Klassen und Funktionen kennt, müssen diese zu
Beginn erst einmal inkludiert werden:
require_once(_realpath_.quot;/installer/class_installer_base.phpquot;);
require_once(_realpath_.quot;/installer/interface_installer.phpquot;);
include_once(_systempath_.quot;/class_modul_pages_element.phpquot;);
Nun kann die Klasse an sich angelegt werden. Wichtig ist hierbei, dass als Klassenname der
Name der aktuellen Datei ergänzt um ein vorangestelltes „class_“ verwendet wird. Sonst kann
Kajona keine Instanz der Klasse anlegen. Damit die Klasse auch als Installer-Klasse
gekennzeichnet wird, muss diese das Interface „interface_installer“ implementieren, sowie von der
Klasse „class_installer_base“ abgeleitet werden. So wird sichergestellt, dass alle benötigten
Methoden und Helfer der Klasse zur Verfügung stehen.
class class_installer_element_lastmodified extends class_installer_base implements
interface_installer {
Der Konstruktor der Klasse beinhaltet alle Daten, die das System über das zu installierende
Seitenelement benötigt. Dazu gehört zum einen natürlich die Version des Seitenelements. Zum
Anderen aber auch der System-Name des Elements, hier „element_lastmodified“, sowie der Name
des Elements, der im Installer angezeigt wird, hier: „Element Lastmodified“. Die Angabe der
„nummer2“ sollte immer auf _pagesinhalte_modul_id_ belassen bleiben. Dieser Wert wird
www.kajona.de 3/9
4. Kajona V3 | HowTo: Simple Pagelement
systemintern verwendet. Am Ende des Konstruktors muss nun der Konstruktor der Elternklasse mit
den soeben angelegten Informationen aufgerufen werden.
public function __construct() {
$arrModule[quot;versionquot;] = quot;3.0.0quot;;
$arrModule[quot;namequot;] = quot;element_lastmodifiedquot;;
$arrModule[quot;name_langquot;] = quot;Element Lastmodifiedquot;;
$arrModule[quot;nummer2quot;] = _pages_inhalte_modul_id_;
parent::__construct($arrModule);
}
Die Methode „getNeededModules“ gibt ein Array an Modultiteln zurück. Die zurückgegebenen
Module werden benötigt, um das Element überhaupt installieren zu können, stellen also eine Liste
an vorrausgesetzen Modulen dar. Hier wären das natürlich das System, sowie das Seitenmodul.
public function getNeededModules() {
return array(quot;systemquot;, quot;pagesquot;);
}
Mit Hilfe der Methode „hasPostInstalls“ wird festgelegt, ob der Installer in der Liste der zu
installierenden Seitenelemente überhaupt auftaucht. Um dies zu erreichen, muss zuvor zumindest
das Seitenmodul installiert worden sein. Dies wird im ersten try-catch-Block geprüft. Im zweiten try-
catch-Block wird getestet, ob das Element bereits installiert wurde. Sollte dies der Fall sein, dann
macht es natürlich keinen Sinn, das Element ein weiteres mal zu installieren – der boolesche Wert
„false“ wird zurückgegeben. Die Zeile
$objElement = class_modul_pages_element::getElement(quot;lastmodifiedquot;);
versucht hierfür, ein Element mit dem Titel „lastmodified“ zu laden.
public function hasPostInstalls() {
try {
$objModule = class_modul_system_module::getModuleByName(quot;pagesquot;);
}
catch (class_exception $objE) { return false; }
try {
$objElement = class_modul_pages_element::getElement(quot;lastmodifiedquot;);
}
catch (class_excpetion $objEx) { }
if($objElement == null)
return true;
return false;
}
Die Methode „install“ bleibt in diesem Fall leer – sie wird nur bei der Installation eines Moduls
benötigt, muss aber auf Grund des Interfaces in dieser Klasse definiert werden.
public function install() { }
In der Methode „postInstall“ wird nun die Hauptarbeit gemacht – das Element wird im System
angelegt.
Hierfür wird zu Beginn erneut geprüft, ob das Element nicht bereits angelegt wurde. Wenn nein,
dass wird eine neue Instanz der Klasse „class_modul_pages_element“ angelegt. Diesem Objekt
wird dann über die Methode „setStrName“ der Name des Seitenelements mitgeteilt. Über diesen
Wert wird das Seitenelement später den Platzhaltern zugeordnet. Wählt man also den Namen
„lastmodified“, so werden in den Templates Platzhalter nach dem Schema „%%titel_lastmodified%
% erwartet. Danach werden die Dateien genannt, in denen sich die Admin- und die
Portaldarstellung befinden. Mit Hilfe des Aufrufs von „setIntCachetime“ wird bestimmt, wie lange
das Element cachebar ist. Per Default wird dieser Wert auf -1 gesetzt, das Cachen also deaktiviert.
Bevor das Element durch „saveObjectToDb“ im System angelegt wird, wird durch „setIntRepeat“
festgelegt, ob das Element an einem Platzhalter wiederholt werden darf, oder nicht.
public function postInstall() {
$strReturn = quot;quot;;
$strReturn .= quot;Registering lastmodifiedelement...nquot;;
try {
$objElement = class_modul_pages_element::getElement(quot;lastmodifiedquot;);
}
www.kajona.de 4/9
5. Kajona V3 | HowTo: Simple Pagelement
catch (class_exception $objEx) {}
if($objElement == null) {
$objElement = new class_modul_pages_element();
$objElement>setStrName(quot;lastmodifiedquot;);
$objElement>setStrClassAdmin(quot;class_element_lastmodified.phpquot;);
$objElement>setStrClassPortal(quot;class_element_lastmodified.phpquot;);
$objElement>setIntCachetime(1);
$objElement>setIntRepeat(0);
$objElement>saveObjectToDb();
$strReturn .= quot;Element registered...nquot;;
}
else {
$strReturn .= quot;Element already installed!...nquot;;
}
return $strReturn;
}
Die Methode „update“ bleibt wie die „install“ Methode leer – diese wird nur bei einem Modul
interessant.
public function update() { }
}
?>
Admin-Darstellung
Nachdem nun der Installer angelegt wurde, geht es um die Darstellung des Elements in der
Adminstration.
<?php
Wie auch im Installer werden in der Admin-Klassen zu Beginn die benötigten Dateien inkludiert.
include_once(_adminpath_.quot;/class_element_admin.phpquot;);
include_once(_adminpath_.quot;/interface_admin_element.phpquot;);
Dann erfolgt die Definition der Klasse. Hierbei ist wichtig, dass der Klassenname dem Dateinamen
entspricht. Ebenso muss das Interface „interface_admin_element“ implementiert, sowie von der
Klasse „class_element_admin“ abgeleitet werden.
class class_element_lastmodified extends class_element_admin implements interface_admin_element {
Im Konstruktor der Klasse werden, wie beim Installer, Informationen zur aktuellen Klasse
gesammelt. Auch hier gilt, dass der Wert des Eintrages „moduleId“ nicht verändert werden sollte.
Ebenfalls wichtig ist es, die Werte „table“ und „tableColumns“ mit einem leeren, Wert, also ““
anzugeben. Hierdurch wird Kajona mitgeteilt, dass das Element keine Daten in fremden Tabellen
speichert. Am Ende werden die gesammelten Aufrufe an den Konstruktor der Elternklasse
übergeben.
public function __construct() {
$arrModul[quot;namequot;] = quot;element_lastmodifiedquot;;
$arrModul[quot;authorquot;] = quot;sidler@mulchprod.dequot;;
$arrModul[quot;moduleIdquot;] = _pages_elemente_modul_id_;
$arrModul[quot;tablequot;] = quot;quot;;
$arrModul[quot;modulquot;] = quot;elementequot;;
$arrModul[quot;tableColumnsquot;] = quot;quot;;
parent::__construct($arrModul);
}
Die nun folgende Methoden muss auf Grund des Interfaces definiert werden. Da das Element aber
keine eigenen Daten in eigenen Tabellen speichert, bleibt der Methodenrumpf quasi leer und gibt
nur den vom System erwarteten Rückgabewert zurück.
public function getEditForm($arrElementData) {
return quot;quot;;
}
}
?>
Um eine Vorstellung davon zu bekommen, was die obige Datei erreicht – so sieht das Element
beim Anlegen im Admin-Bereich aus:
www.kajona.de 5/9
6. Kajona V3 | HowTo: Simple Pagelement
Portal-Darstellung
Nachdem nun der Installer und der Teil der Administration angelegt wurden, geht es um die
Darstellung des Elements im Portal. Vieles wiederholt sich hier, weswegen nur auf die neuen
Aspekte eingegangen werden soll.
<?php
require_once(_portalpath_.quot;/class_elemente_portal.phpquot;);
require_once(_portalpath_.quot;/interface_portal_element.phpquot;);
class class_element_lastmodified extends class_element_portal implements interface_portal_element {
public function __construct($objElementData) {
$arrModule[quot;namequot;] = quot;element_lastmodifiedquot;;
$arrModule[quot;authorquot;] = quot;sidler@mulchprod.dequot;;
$arrModule[quot;moduleIdquot;] = _pages_elemente_modul_id_;
$arrModule[quot;tablequot;] = quot;quot;;
$arrModule[quot;modulquot;] = quot;elementequot;;
parent::__construct($arrModule, $objElementData);
}
Die eigentliche Logik steckt in der Methode „loadData“. Der Name der Methode kann hierbei nicht
verändert werden, da dieser über das Interface vorgegeben wird. In der Methode wird nun ein
Seiten-Objekt der aktuell geladenen Seite geholt (class_modul_pages_page::getPageByName($this
>getPagename())). Danach wird dem Rückgabewert ein Text mit dem Titel „lastmodified“ hinzugefügt
(dieser wird in einer Textdatei hinterlegt, siehe unten), sowie das durch die Funktion „timeToString“
formatierte Datum des letzten Bearbeitens der Seite – fertig.
public function loadData() {
$strReturn = quot;quot;;
$objPage = class_modul_pages_page::getPageByName($this>getPagename());
$strReturn .= $this>getText(quot;lastmodifiedquot;).timeToString($objPage>getEditDate());
return $strReturn;
}
}
?>
Wenn man sich die Ausgabe im Portal anschaut, so kann das wie in nachstehendem Bild
aussehen:
Texte
Um den Text „lastmodified“ laden zu können, muss dieser in der zu Beginn hinterlegten Textdatei
eingetragen werden. Das ist in diesem Fall lediglich eine einzelne Zeile.
<?php
$text[quot;lastmodifiedquot;] = quot;Bearbeitet am: quot;;
?>
Und das wars schon. Fertig ist das erste, eigene Seitenelement. Nun muss dieses nur noch im
System getestet werden.
Viel Spaß beim Erstellen weiterer, eigener Seitenelemente.
P.S.: Wir freuen uns immer darüber, neue Seitenelemente auf www.kajona.de veröffentlichen zu
dürfen.
www.kajona.de 6/9