RE-Design – Enrico Reinsdorf

So bald habe wir es geschafft alle Klassen zu beschreiben. Es fehlen jetzt nur noch 2 Hilfsklassen. Auf der einen Seite ist das die „Date“-Klasse und auf der anderen die „Editor“-Klasse.

Date Class

Als erstes nun die „Date“-Klasse. Sie hat im gesamten System die wohl kleinste Rolle, denn sie managt die Konvertierung von einer internationalen Schreibweise der Zeit (YYYY-MM-DD HH:MM:SS +00:00) in eine deutsche Schreibweise. Dabei unterscheide ich 2 verschiedene Ausgaben. Einmal ist das die Kurzschreibweise des Datums (DD. MM. YYYY) und dann noch die umfangreichere Schreibweise (Tag. Monatsname Jahr).

1. class Date
2. {
3. static $formatShort;
4. static $formatLong;
6. static function setShortFormat($format)
7. {
8. self::$formatShort = $format;
9. }
10. static function setLongFormat($format)
11. {
12. self::$formatLong = $format;
13. }
15. static function getShortFormat($date)
16. {
17. $ts = strtotime($date);
18. return strftime(self::$formatShort, $ts);
19. }
21. static function getLongFormat($date)
22. {
23. $ts = strtotime($date);
24. return strftime(self::$formatLong, $ts);
25. }
26. }

Um die Darstellung des Formates schnell ändern zu können wird diese in der Konfiguration abgespeichert und kann dadurch jeder Zeit geändert werden.

1. [Application]
2. dateformatlong = “%d. %B %Y”
3. dateformatshort = “%d. %m. %Y”

Ich habe mich bewusst hier für statische Methoden entschieden, um schneller auf die Konvertierungen zuzugreifen. So bekomme ich mit dem Befehl „Date::getLongFormat()“ und dem übergebenen Zeitstempel direkt die deutsche Schreibweise.

Editor Class

Um die Texte online besser editieren zu können habe ich mich für FCKeditor als WYSIWYG-Editor, also als Online-Editor entschieden. Dadurch wird den Redakteuren die Arbeit mit REDcms erleichtert. Wobei man nicht vergessen darf dass es nur ein Hilfsmittel ist. Die Kenntnisse über HTML wird trotzdem vorausgesetzt.

In der „Editor“-Klasse, die die „FCKeditor“-Klasse des Online-Editors erweitert, wird nur während der Instanziierung verschiedene Einstellungen schon mal mit geladen. Wie z.B. wo der Editor gespeichert ist, wo die Konfiguration zu finden ist, bzw. welche Sprache der Editor benutzen soll.

1. class Editor extends FCKeditor
2. {
3. function __construct( $instanceName )
4. {
5. parent::__construct( $instanceName );
7. $this->BasePath = BASEURL.‘/fckeditor/’;
8. $this->ToolbarSet = ‘REDcms’;
9. $this->Config["CustomConfigurationsPath"] = BASEURL.“/templates/scripts/myEditorConfig.js”;
10. $this->Config['DefaultLanguage'] = ‘de’;
12. $this->Height = 400;
14. $this->Config['LinkBrowser'] = true;
15. }
17. function __destruct(){}
18. }

Downloads

• REDcms_11.zip

Nachdem ich gestern wiedermal eine sehr umfangreiche Klasse beschrieben habe, heute nun wieder etwas einfacheres – die „Login“-Klasse.

Sie regelt das An- und Abmelden am System. Um die angemeldeten User verwalten zu können, nutze ich Sessions. Deshalb wird im Konstruktor mit der „session_start()“-Funktion eine Verbindung zur Session aufgebaut.

1. function __construct()
2. {
3. session_start();
4. }

Nach einer erfolgreichen Anmeldung z.B. werden in einer Session-Variablen „$_SESSION['REDcms']“ die Werte des Benutzers abgespeichert. Das geschieht in der „checkLogin()“-Methode. Sie prüft ob innerhalb der globalen Variablen „$_POST“ die korrekten Angaben sich befinden, die in der Klasse selbst abgespeichert sind.

1. public function checkLogin()
2. {
3. if($_POST['user'] == self::$user && $_POST['password'] == self::$password)
4. {
5. $_SESSION['REDcms'] = array();
6. $_SESSION['REDcms']['user'] = $_POST['user'];
7. $_SESSION['REDcms']['access'] = 0;
8. }
10. header(‘Location: ‘.$_POST['request']);
11. exit();
12. }

Natürlich gibt es auch die „logout()“-Methode, die die gespeicherten Werte aus der Session wieder löscht.

1. public function logout()
2. {
3. $_SESSION['REDcms'] = array();
4. unset($_SESSION['REDcms']);
6. header(‘Location: ‘.$_POST['request']);
7. exit();
8. }

So kann über die „isLogged()“-Methode relativ einfach überprüft werden ob der Benutzer angemeldet ist oder nicht. Das ist besonders bei den Verarbeitungsmethoden der „Page“-, „Box“- und „Menu“-Klasse wichtig.

1. public function isLogged()
2. {
3. if(isset($_SESSION['REDcms']) && $_SESSION['REDcms']['user'] == self::$user)
4. {
5. return true;
6. }
7. return false;
8. }

Als letztes gibt es noch die „getAdminBox()“-Methode. Sie hat die Aufgabe bei nicht angemeldeten Benutzern das Anmelde-Formular, bzw. bei angemeldeten Benutzern eine zusätzliches Menü anzuzeigen.

1. public function getAdminBox()
2. {
3. $content = ‘<h4>Administration</h4>’;
5. $tpl = new Template(TEMPLATEPATH);
7. if(empty($_SESSION['REDcms']))
8. {
9. $tpl->load(‘login.tpl.html’);
10. $tpl->set(‘##URL##’, BASEURL.‘/login.php’);
11. }
12. else
13. {
14. $tpl->load(‘logout.tpl.html’);
15. $tpl->set(‘##URL##’, BASEURL.‘/logout.php’);
16. $tpl->set(‘##URLPAGE##’, BASEURL.‘/page/0/add’);
17. $tpl->set(‘##URLBOX##’, BASEURL.‘/box/0/add’);
18. $tpl->set(‘##URLMENU##’, BASEURL.‘/menu/0/add’);
19. $tpl->set(‘##USERNAME##’, $_SESSION['REDcms']['user']);
20. }
22. if(isset($_SERVER['REDIRECT_URI']))
23. {
24. $tpl->set(‘##REQUEST##’, $_SERVER['REDIRECT_URL']);
25. }
26. else
27. {
28. $tpl->set(‘##REQUEST##’, BASEURL);
29. }
30. $content .= $tpl->get();
32. return $content;
33. }

Um die An- und Abmeldung relativ einfach zu machen, habe ich für jeden Prozess eine eigene PHP-Seite erstellt. Der Inhalt dieser Dateien ist sehr überschaubar.

1. <?php
2. error_reporting(E_ALL | E_WARNING);
4. require_once ‘includes.php’;
6. $login = new Login();
7. $login->checkLogin();
8. ?>

1. <?php
2. error_reporting(E_ALL | E_WARNING);
4. require_once ‘includes.php’;
6. $login = new Login();
7. $login->logout();
8. ?>

Zu einem späteren Zeitpunkt werde ich wahrscheinlich diese separaten Dateien mit in die „index.php“-Datei integrieren.

Downloads

• REDcms_10.zip

Schon seid vielen Jahren benutzte ich diese Klasse. Immer wenn ich ein kleines Template-System brauche setze ich auf diese Klasse. Die Funktionsweise meiner Klasse ist dabei recht einfach.

Als erstes wird im Konstruktor festgelegt wo die Vorlagen zu finden sind, dazu wird ihn der Pfad mit übergeben. Zusätzlich wird die „value“-Eigenschaft mit einem leeren Array vorbereitet.

1. public function __construct( $path )
2. {
3. $this->path = $path.‘/’;
4. $this->values = array();
5. }

Um aber auch eine konkrete Vorlage zu laden, gibt es in der „Template“-Klasse die „load()“-Methode. Ihr wird der Dateiname übergeben. Die geladene Datei wird als String in die „source“-Eigenschaft abgelegt. Zusätzlich wird die „reload()“-Methode aufgerufen.

1. public function load( $file )

2. {
3. $this->source = file_get_contents( $this->path.$file );
4. $this->reload();
5. }

Sie kopiert den geladene String in die „template“-Eigenschaft. So muss nicht beim wiederholten Aufrufen der gleichen Vorlage immer wieder erst die Datei von der Festplatte geladen werden.

1. public function reload()
2. {
3. $this->template = $this->source;
4. }

Über die „set()“-Methode werden die Werte mit ihren Schlüsselworten in die Klasse geladen. Dabei werden 2 Parameter erwartet: der Schlüssel mit folgender Schreibweise „##SCHLÜSSELNAME##“ (Name in Großbuchstaben) und optional ein Wert.

1. public function set( $key, $value=” )
2. {
3. $this->values[$key] = $value;
4. }

Neben der „set()“-Methode gibt es natürlich auch die „get()“-Methode. Sie hat als Aufgabe aus dem Template einen brauchbare Quellcode für den Browser zu generieren. Dabei prüft sie als erstes ob überhaupt das Template schon geladen wurde. Danach ruft sie die „parse()“-Methode auf, um das Template mit den Werten zu verarbeiten. Falls der Methode über der „sourcecode“-Parameter der statische Wert Template::DISPLAY_CODE mitgegeben wurde, wird die Ausgabe in lesbaren HTML-Code konvertiert.

1. public function get( $sourcecode=true )
2. {
3. if( $this->source==null || $this->source==” )
4. {
5. return null;
6. }
8. $this->parse();
10. if( !$sourcecode )
11. {
12. $out = ‘<pre>’;
13. $out .= htmlentities( $this->template );
14. $out .= ‘</prev>’;
15. }
16. else
17. {
18. $out = $this->template;
19. }
20. return $out;
21. }

Die „parse()“-Methode hat nun die Aufgabe die Schlüsselworte innerhalb der Vorlage durch die Werte innerhalb der „values“-Eigenschaft zu ersetzen. Dabei prüft sie als erstes ob überhaupt das Template schon geladen ist. Danach ersetzt sie alle Werte. Zum Schluss werden noch alle nicht ersetzten Schlüsselworte in der Vorlage gelöscht, um unschöne Darstellungen zu vermeiden.

1. private function parse()
2. {
3. if( $this->source == null || $this->source==” )
4. {
5. die(‘TPL-Error: file not loaded!’);
6. }
8. foreach ( $this->values as $key => $value )
9. {
10. $this->template = str_replace( $key, $value, $this->template );
11. }
13. $this->template = ereg_replace( ‘##[A-Za-z0-9_]+##’, ”, $this->template);
14. }

Als letzte Methode innerhalb der „Template“-Klasse gibt es noch die „write()“-Methode. Sie macht im Grunde genau das was die „get()“-Methode auch macht, nur gibt sie das Ergebnis direkt an den Browser weiter.

1. public function write( $sourcecode=true )
2. {
3. echo $this->get( $sourcecode );
4. }

Wie schon eingangs erklärt, ist diese Klasse eine meiner ersten Klassen die ich konstant in meinen Projekten einsetze. Die Verwendung ist dabei sehr einfach. Als erstes erstellt man eine Vorlagendatei mit folgenden exemplarischen Quellcode:

1. <!DOCTYPE html PUBLIC “-//W3C//DTD XHTML 1.0 Transitional//EN” “http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd”>
2. <html xmlns=“http://www.w3.org/1999/xhtml”>
3. <head>
4. <meta http-equiv=“Content-Type” content=“text/html; charset=utf-8″ />
5. <title>##TITLEBAR##</title>
6. </head>
7. <body lang=“de”>
8. <div id=“page”>
9. <div id=“branding”>
10. <h1>##WEBSITETITLE##</h1>
11. <h2>##TAGLINE##</h2>
12. </div>
13. <div id=“main”>
14. <div id=“content”>
15. ##CONTENT##
16. </div>
17. <div id=“sidebar”>
18. ##SIDEBAR##
19. </div>
20. </div>
21. <div id=“copyright”>
22. <p>&copy; 2008 &ndash; <a href=“http://www.re-design.de”>RE-Design</a></p>
23. </div>
24. </div>
25. </body>

26. </html>

Um diese Vorlage verwenden zu können muss man in PHP nur folgendes schreiben:

1. <?php

2. include_once ‘core/Template.php’;
4. $tpl = new Template(‘./templates/layouts’);
5. $tpl->load(‘index.tpl.html’);
7. $tpl->set(‘##TITLEBAR##’, ‘RE-Design - Beispiel-Template-Code’);
8. $tpl->set(‘##WEBSITETITLE##’, ‘RE-Design’);
9. $tpl->set(‘##TAGLINE##’, ‘Template-Klassen-Beispiel’);
10. $tpl->set(‘##CONTENT##’, ‘<p>Lorem ipsum dolor sit amet, … et netus et malesuada fames ac turpis egestas.</p>’);
11. $tpl->set(‘##SIDEBAR##’, ‘<div class=”box”><h2>Autor</h2><p>Enrico Reinsdorf</p></div>’);
13. echo $tpl->get(Template::DISPLAY_HTML);
14. ?>

Downloads

• REDcms_09.zip

Gestern hatte ich sehr ausführlich über die „Application“-Klasse geschrieben. Heute möchte ich über den Inhalt der „Request“-Klassen meines REDcms schreiben.

Die wichtigste Verarbeitung findet innerhalb des Konstruktors statt. Dem Konstruktor werden 2 Arrays als Parameter mit übergeben, wobei z.Z. nur der Erste wichtig ist. Es handelt sich hierbei um die „GET“-Werte der URL. Da ja per „mod_rewrite“ und „.htaccess“ Anhänge an die „index.php“-Datei gemacht werden.

Als erstes wird der Modus gesetzt, dabei kommen die 4 Klassenkonstanten Request::MODE_PAGE, Request::MODE_BOX und Request::MODE_MENU zum Einsatz.

Als nächstes wird die ID ausgelesen. Falls sie nicht vorhanden ist wird ihr Wert auf 1 gesetzt.

Zum Schluss wird versucht die Aktion aus dem „GET“-Wert zu ermitteln. Falls keiner vorhanden ist, wird standardmäßig die Aktion „show“ benutzt. Auch hier kommen wieder Klassenkonstanten zu Einsatz. Diesmal sind es aber 5 Stück: Request::ACTION_ADD, Request::ACTION_EDIT, Request::ACTION_UPDATE, Request::ACTION_DELETE und Request::ACTION_SHOW.

1. function __construct($get, $request)
2. {
3. $this->request = $request;
5. if (!empty($get['mode'])) {
6. switch ($get['mode']) {
7. case self::MODE_BOX:
8. $this->mode = self::MODE_BOX;
9. break;
10. case self::MODE_MENU:
11. $this->mode = self::MODE_MENU;
12. break;
13. default:
14. $this->mode = self::MODE_PAGE;
15. }
16. } else {
17. $this->mode = self::MODE_PAGE;
18. }
20. if (!empty($get['id']) && !is_nan($get['id'])) {
21. $this->id = $get['id'];
22. } else {
23. $this->id = 1;
24. }
26. if(!empty($get['action'])){
27. switch ($get['action']) {
28. case self::ACTION_ADD:
29. $this->action = self::ACTION_ADD;
30. break;
31. case self::ACTION_EDIT:
32. $this->action = self::ACTION_EDIT;
33. break;
34. case self::ACTION_UPDATE:
35. $this->action = self::ACTION_UPDATE;
36. break;
37. case self::ACTION_DELETE:
38. $this->action = self::ACTION_DELETE;
39. break;
40. case self::ACTION_SHOW:
41. default:
42. $this->action = self::ACTION_SHOW;
43. }
44. } else {
45. $this->action = self::ACTION_SHOW;
46. }
47. }

Warum arbeite ich nicht mit Strings sondern mit Konstanten, die ja auch Strings beinhalten? Durch die Verwendung von Konstanten gewährleiste ich, dass die Werte unverändert eingesetzt werden können. Ohne Angst haben zu müssen, dass sie versehentlich überschrieben werden. Auch kann ich so später aus den String-Konstanten relativ schnell z.B. Integer-Konstanten machen und die Verwendung bleibt gleicht.

Die restlichen Methoden dieser Klasse sind ausschließlich die „Getter“- und „Setter“-Methoden von Mode, ID und Action.

Downloads

• REDcms_05.zip

Wie schon im gestrigen Artikel geschrieben, ist die „Application“-Klasse die Hauptklasse meines Systems. Sie sorgt für den reibungslosen Ablauf beim Anfordern einer Seite.

Wie funktioniert nun so was? Eigentlich recht simple. Die „index.php“-Datei, die automatisch bei jedem Request, also beim Aufrufen einer Seite, gestartet wird, initialisiert die „Application“-Klasse und speichert sie in der Variable $app ab. Somit habe ich die Möglichkeit jeder Zeit weitere Methoden dieser Klasse aufzurufen. Obwohl, eigentlich brauche ich nur 2 Stück, und auch die könnten rein theoretisch reduziert werden.

„init()“-Methode

Was passiert bei der Instanziierung? Der Konstruktor ruft die private Methode „init“ auf und diese lädt die zusätzlich benötigten Objekte. Zuerst wird aber das Datumsformat mit „setlocale(LC_ALL, ‘de’);“ gesetzt.

Danach wird in die „config“-Variable die „Configuration“-Klasse instanziiert. Diese lädt die Konfiguration, die in der „configuration.ini“-Datei hinterlegt ist. Um später auch eine HTML-Ausgabe benutzen zu können, wird die „Template“-Klasse anschließend in die „tpl“-Variable geladen. Ihr wird die Konstante mit dem Pfad zum Template-Ordner übergeben.In einer lokalen Variablen wird aus der Konfiguration der Array mit den Verbindungsangaben für die Datenbank geladen. Und in einer 2. lokalen Variablen wird der String vorbereitet der später für den Aufbau einer Datenbank-Verbindung wichtig ist. Nun wird die Verbindung zur Datenbank hergestellt und in der „db“-Variable abgespeichert. Nach einer Fehlerüberprüfung ob die Verbindung zum Datenbankserver hergestellt werden konnte, werden zum Schluss die Datumsformate auf der Konfiguration in das System integriert.

private function init()

{

setlocale(LC_ALL, ‘de’);

$this->config = new Configuration(‘./configuration.ini’);

$this->tpl = new Template(TEMPLATEPATH);

$db = $this->config->getSection(‘Database’);

$dsn = ‘mysql://’.$db['user'].‘:’.$db['password'].‘@’.$db['host'].‘/’.$db['db'];

$this->db = Database::connect($dsn);

$this->db->setFetchMode(DB_FETCHMODE_OBJECT);

if($this->db->isError($this->db))

{

die($this->db->getMessage());

}

Date::setLongFormat($this->config->getValue(‘dateformatlong’, ‘Application’));

Date::setShortFormat($this->config->getValue(‘dateformatshort’, ‘Application’));

}

„main()“-Methode

Nach der Initialisierung wird über die „index.php“-Datei die „main()“-Methode aufgerufen. Als erstes in dieser Methode wird die „Request“-Klasse in die „request“-Variable geladen. Ihr werden die globalen Variablen $_GET und $_REQUEST übergeben. Dies wird benötigt um anschließend über eine „switch“-Verzweigung zu entscheiden welche Informationen in die Klassenvariable „content“ geladen werden. Zum Schluss wird in die Klassenvariable „sidebar“ die Informationen zum Anzeigen der Sidebar gespeichert.

public function main()

{

$this->request = new Request($_GET,$_REQUEST);

switch ($this->request->getMode())

{

case Request::MODE_BOX:

$this->content = $this->getBox($this->request->getId());

break;

case Request::MODE_MENU:

$this->content = $this->getMenu($this->request->getId());

break;

case Request::MODE_PAGE:

default:

$this->content = $this->getPage($this->request->getId());

break;

}

$this->sidebar = $this->getSidebar($this->request->getId());

}

„getBox()“-, „getMenu()“-, „getPage()“-Methode

Alle drei Methoden besitzen den gleichen Aufbau, weshalb ich hier nur die „getPage()“-Methode erklären möchte.

Als erstes wird die passende Klasse in eine Klassenvariable geladen. Ihr wird die Verbindung zum Datenbankserver mitgegeben. Als nächstes wird über die „request“-Variable und ihrer „getAction()“-Methode entschieden, welche Aktion nun folgen soll. Dabei gibt es 4 zur Auswahl.

• hinzufügen
• ändern
• löschen
• anzeigen

Wobei die letzte Aktion generell immer aufgerufen wird, wenn keine Aktion vorhanden sein sollte. Die habe ich mit eingefügt, falls das System mal keine Aktion in der „request“-Variable findet. Anschließend wird aus der jeweiligen Klasse der Titel für die Titelleiste des Browsers angefordert um ihn später mit dem Titel des Systems zu kombinieren.

private function getPage($id=1)

{

$this->page = new Page($this->db);

$content = ”;

switch ($this->request->getAction()) {

case Request::ACTION_ADD:

$content = $this->page->add();

break;

case Request::ACTION_EDIT:

$content = $this->page->edit($id);

break;

case Request::ACTION_DELETE:

$content = $this->page->delete($id);

break;

case Request::ACTION_UPDATE:

$content = $this->page->update();

break;

case Request::ACTION_SHOW:

default:

$content = $this->page->get($id);

break;

}

$this->titlebar = $this->page->getTitle();

return $content;

}

private function getBox($id=1)

{

$this->box = new Box($this->db);

$content = ”;

switch ($this->request->getAction()) {

case Request::ACTION_ADD:

$content = $this->box->add();

break;

case Request::ACTION_EDIT:

$content = $this->box->edit($id);

break;

case Request::ACTION_DELETE:

$content = $this->box->delete($id);

break;

case Request::ACTION_UPDATE:

$content = $this->box->update();

break;

case Request::ACTION_SHOW:

default:

$content = $this->box->get($id);

break;

}

$this->titlebar = $this->box->getTitle();

return $content;

}

private function getMenu($id=1)

{

$this->menu = new Menu($this->db);

$content = ”;

switch ($this->request->getAction()) {

case Request::ACTION_ADD:

$content = $this->menu->add();

break;

case Request::ACTION_EDIT:

$content = $this->menu->edit($id);

break;

case Request::ACTION_DELETE:

$content = $this->menu->delete($id);

break;

case Request::ACTION_UPDATE:

$content = $this->menu->update();

break;

case Request::ACTION_SHOW:

default:

$content = $this->menu->get($id);

break;

}

$this->titlebar = $this->menu->getTitle();

return $content;

}

„getSidebar()“-Methode

In der „getSidebar()“-Methode wird als erstes in der lokalen Variable „login“ die Anzeigebox für die Sidebar gespeichert. Danach wird das selbe mit der Navigationsbox gemacht.

Zum Schluss wird dann mit Hilfe der Variable „tpl“ ein Template gefüllt und an die „main()“-Methode zurückgegeben.

private function getSidebar($id=1)

{

$login = Login::getAdminBox();

$navi = $this->getMenuBox(0);

$this->tpl->load(‘sidebar.tpl.html’);

$this->tpl->set(‘##NAVIGATION##’, $navi);

$this->tpl->set(‘##LOGIN##’, $login);

return $this->tpl->get($id);

}

„getMenuBox()“-Methode

Hier wird einfach nur mit der „Menu“-Klasse der Navigationsbaum erstellt und an die „getSicebar()“-Methode zurückgegeben.

private function getMenuBox($page_id=1)

{

$content = ‘<h4>Navigation</h4>’;

$menu = new Menu( $this->db );

return $content.$menu->getTree( $page_id );

}

„display()“-Methode

Die letzte Methode innerhalb der „Application“-Klasse ist die „display()“-Methode. Auch diese wird ähnlich wie die „main()“-Methode von der „index.php“-Datei direkt aufgerufen. Hier laufen dann alle vorherigen Verarbeitungen zusammen.

Als erstes wird der Website-Titel aus der Konfiguration geladen. Danach wird dieser mit dem Seitentitel kombiniert.

Zum Schluss wird das Template geladen, mit den Informationen gefüllt und dann an die „index.php“-Datei zurückgegeben. Diese zeigt den Inhalt schließlich an.

public function display()

{

$website = $this->config->getSection(‘Website’);

$this->titlebar = $website['Title'].‘ – ‘.$this->titlebar;

$this->tpl->load(‘index.tpl.html’);

$this->tpl->set(‘##BASEURL##’, BASEURL);

$this->tpl->set(‘##TITLEBAR##’, $this->titlebar);

$this->tpl->set(‘##WEBSITETITLE##’, $website['Title']);

$this->tpl->set(‘##TAGLINE##’, $website['Tagline']);

$this->tpl->set(‘##CONTENT##’, $this->content);

$this->tpl->set(‘##SIDEBAR##’, $this->sidebar);

return $this->tpl->get();

}

Downloads

• REDcms_04.zip

Um ein flexibles aber dennoch stabiles Programmiergerüst zu bekommen, habe ich mich für das objekt-orientierte Programmieren entschieden. Das bedeutet, das die gesamte Funktionalität des Systems in Klassen gekapselt ist. Es gibt insgesamt 12 Klassen.

In den folgenden Tagen werde ich die einzelnen Klassen näher erklären. An dieser Stelle möchte ich euch erstmal nur eine kleine Übersicht über die verwendeten Klasen geben.

• Application
• Request
• Configuration
• Database
• Content
  • Page
  • Box
  • Menu
• Template
• Login
• Editor
• Date

Ich habe versucht möglichst wenige Klassen zu benutzen, um den Überblick bei der Entwicklung nicht zu verlieren. Wobei die „Application“-Klasse hier ein sehr zentrale Rolle spielt. Weitere wichtige Klassen sind „Page“, „Box“ und „Menu“. Sie beinhalten die eigentliche Verarbeitung der einzelnen Bereiche.

In der „Request“-Klasse werden die Angaben der URL, also der Adressierung verarbeitet. Um REDcms schnell anpassen zu können, habe ich mich für die Verarbeitung von einer externen INI-Datei entschieden. So bekommt der Administrator einen schnellen Zugriff auf die wichtigsten Einstellmöglichkeiten ohne großartig in den einzelnen Klassen suchen zu müssen.

Um eine einfache Trennung zwischen der Programmierung und den HTML-Dateien zubekommen benutze ich eine eigenen „Template“-Klasse. Sie stellt mir alle wichtigen Funktionen für das Verarbeiten zur Verfügung.

Mit der „Login“-Klasse wird die An- und Abmeldung am System geregelt. Weiterhin kann darüber geprüft werden ob ein Benutzer berechtigt, also angemeldet, ist eine Seite bzw. deren Informationen einzusehen.

Um die Datumsausgabe besser zu verarbeiten, habe ich mir eine Hilfsklasse „Date“ erstellt. Damit bin ich in der Lage den Timestamp in ein deutsche Datumsformat zu konvertieren.Und ich habe noch zwei weitere Hilfsklassen erstellt. Wobei ich bei der „Database“-Klasse nur eine Ableitung der „DB“-Klasse des PEAR-Framework und bei der „Editor“-Klasse eine Ableitung des FCKeditors.

Bei der Erstellung von moderen Websites spielt AJAX eine immer wichtigere Rolle. In diesem Tutorial möchte ich euch eine kleine JavaScript-Klasse vorstellen. Diese Klasse kann dann Grundlage für weiter tolle Webanwendungen sein kann.

Die einfache und trotzdem flexible Verwendung der erstellten Klasse lag mir dabei besonders am Herzen.
Diesen Beitrag weiterlesen »

Immer wieder brauche ich für das Erstellen von komplexeren Webanwendungen eine kleine Template-Engine. Ich könnte dann zwar auf bestehende Syteme wie z.B. Smarty oder PatTemplate. Ich habe mir schon vor langer Zeit ein kleines Script zusammengeschrieben und möchte es heute hier mit euch teilen. Es ist ja Weihnachten.

Diesen Beitrag weiterlesen »

Durch die Benutzung von Klassen und IDs kann man sehr effektiv auf die Strukturen von HTML-Seiten zugreifen. Doch leider wird dadurch auch der Quellcode der Seite vergrößert. In vielen Fällen ist das aber unnötig, denn oft werden Klassen aus Bequemlichkeit eingesetzt um schnell auf das Richtige zu zugreifen. CSS bietet über Selektoren mehr als nur den Zugriff auf Tags, Klassen und IDs.

Diesen Beitrag weiterlesen »