Auf meinem Nebenbildschirm läuft gerade noch die Pressekonferenz zu Google Instant, eine Suche, bei der bereits beim Eingeben die Ergebnisse angezeigt werden. Da jeder mit genau einem Buchstaben anfängt zu tippen, werden die Ergebnisse dazu natürlich relativ häufig angezeigt.

Aus diesem Grund hab ich für Deutschland mal eine Kleine Liste mit dem Alphabet gemacht, welche Seite in Deutschland zu welchem Buchstaben oben steht und somit von Google Instant profitiert.

• Amazon.de
• Bild.de
• Chip.de
• Das Örtliche
• Ebay
• Facebook
• GMX
• H & M
• Ikea
• Jappy
• Kino.to
• Leo
• MeinVZ
• Netto
• Otto
• Postbank
• QVC
• Map24
• SchülerVZ
• Das Telefonbuch
• UPS
• Volkswagen
• Wetter.com
• Xing
• YouTube
• ZDF

Wer selbst noch etwas testen möchte, kann dies unter http://google.com/instant/ machen.

Derzeit speichern wir die Seiten ja noch in Dateiform – Das änder sich heute! Wir können ja mitlerweile unterschiedliche Seitentypen erstellen, weswegen wir auch keine PHP-Tags unterstützten müssen. Durch die Speicherung in der Datenbank können wir später auch eine Suche erstellen.

Zunächst einmal brauchen wir eine neue Spalte in unserer pages-Tabelle: content als text.

Da wir in der Klasse Text darauf zugreifen, müssen wir auch hier den Inhalt auslesen. gebrauchen tuen wir es aber erst im Editor. Damit  wir später nicht auf dumme Ideen kommen, habe ich es in der Klasse editorContent genannt. Das Speichern und auslesen geht dann so: /system/classes/page.php:

<?PHP
class Page{
  public $id      = -1;
  public $alias   = "";
  public $title   = "";
  public $ownerid = -1;
  public $owner   = false;
  public $menu    = -1;
  public $meta    = null;
  public $editor  = null;
  private $editorContent = "";

  function loadProperties($alias){
    if ($alias == "") {
      $alias = "home";
    }
    $this->alias = $alias;
    $row = $GLOBALS['db']->ReadRow("SELECT * FROM {'dbprefix'}pages 
                           WHERE alias = '".$alias."'");
    $this->load($row);
  }

  function loadPropertiesById($id){
    $row = $GLOBALS['db']->ReadRow("SELECT * FROM {'dbprefix'}pages 
                           WHERE id = '".$id."'");
    $this->load($row);
  }

  function load($data){
    if($data){
      $this->id            = $data->id;
      $this->title         = $data->title;
      $this->ownerid       = $data->owner;
      $this->menu          = $data->menu;
      $this->alias         = $data->alias;
      $this->editorContent = $data->content;
      $this->meta          = new Meta();
      $this->meta->pageid  = $this->id;
      $this->meta->load();
      $this->editor = new $data->editor($this);
      if(!isset($_SESSION['user']) || !isset($_SESSION['user']->role) || !$_SESSION['user']->role->canAccess($this)){
        throw new AccessDeniedException("Access denied: ".$this->alias);
      }
    }
    else{
      throw new FileNotFoundException("File Not Found: ".$this->alias);
    }
  }

  function getContent(){
    EventManager::raiseEvent("content_top",".",$this);
    $this->editor->display();
    EventManager::raiseEvent("content_bottom",".",$this);
  }

  function getOwner(){
    if(!$this->owner){
      $alias = $GLOBALS['db']->ReadField("SELECT alias FROM {'dbprefix'}pages 
                                          WHERE id = '".$this->ownerid."'");
      if($alias){
        $this->owner = new Page();
        $this->owner->loadProperties($alias);
      }
    }
    return $this->owner;
  }

  function getBreadcrumb(){
    if(!$this->owner) $this->getOwner();
    if($this->owner){
      $breadcrump = $this->owner->getBreadcrumb();
    }
    $breadcrump[] = array($this->alias,$this->title);
    return $breadcrump;
  }

  function save(){
    $title   = $GLOBALS['db']->EscapeString($this->title);
    $alias   = $GLOBALS['db']->EscapeString($this->alias);
    $menu    = $GLOBALS['db']->EscapeString($this->menu);
    $id      = $GLOBALS['db']->EscapeString($this->id);
    $editorContent = $GLOBALS['db']->EscapeString($this->editorContent);
    $res = $GLOBALS['db']->Execute("UPDATE {'dbprefix'}pages SET
                                    title    = '".$title."',
                                    alias    = '".$alias."',
                                    menu     = '".$menu."' ,
                                    content  = '".$editorContent."' 
                                    WHERE id = '".$id."'");
    $this->meta->save();
    if($res){
      $args['title']   = $this->title;
      $args['alias']   = $this->alias;
      $args['menu']    = $this->menu;
      $args['id']      = $this->id;
      $args['content'] = $this->content;
      EventManager::raiseEvent("page_saved","../",$args);
    }
    return $res;
  }

  function create($dirpraefix,$alias,$editor){
    $res = $GLOBALS['db']->Execute("INSERT INTO {'dbprefix'}pages (alias,editor) VALUES ('".$alias."','".$editor."')");
    if($res){
      $res            = $GLOBALS['db']->InsertID();
      $args['id']     = $res;
      $args['editor'] = $editor;
      $args['alias']  = $alias;
      $admin = new Role();
      $admin->load(2);
      $admin->allowAccessByID($args['id']);
      EventManager::raiseEvent("page_created","../",$args);
    }
    return $args['id'];
  }

  function delete(){
    $res = $GLOBALS['db']->Execute("DELETE FROM {'dbprefix'}pages WHERE alias = '".$this->alias."'");
    if($res){
      $args['alias'] = $this->alias;
      EventManager::raiseEvent("page_deleted","../",$args);
    }
    return $res;
  }

  function getPagesTypes(){
    return $GLOBALS['db']->ReadRows("SELECT * FROM {'dbprefix'}pagetypes");
  }

  function displayBreadcrumb($separator,$class,$idpraefix){
    $this->editor->displayBreadcrumb($separator,$class,$idpraefix);
  }

  static function getPagesByDir($dir){
    $dir = $GLOBALS['db']->EscapeString($dir);
    if(substr($dir,0,1) == "/"){
      $dir = substr($dir,1);
    }
    return $GLOBALS['db']->ReadRows("SELECT * FROM {'dbprefix'}pages 
                           WHERE alias LIKE '".$dir."%'");

  }

  public function getEditorContent(Editor $editor){
    return $this->editorContent;
  }

  public function setEditorContent($content){
    $this->editorContent = $content;
  }
}

?>

Die Klasse /system/classes/wysiwyg.php kann nun sehr verkleinert werden. Wir brauchen keinen Dateizugriff und können einfach auf die eben hinzugefügte Variable zurückgreifen:

<?PHP
  class WYSIWYG extends Editor{
    function __construct($page){
      $this->page = $page;
    }

    public function display(){
      echo $this->page->getEditorContent($this);
    }

    function getHeader(){
    }

    public function getEditableCode(){
        $template = new Template();
        $template->load("control_wysiwyg");
        $template->assign_var("CONTENT",$this->page->getEditorContent($this));
        $template->assign_var("HOST",Settings::getInstance()->get("host"));
        $template->assign_var("ALIAS",$this->page->alias);
        $template->assign_var("URL",Settings::getInstance()->get("host")."admin/pageedit.html?site=".$this->page->alias);
        return $template->getCode();
    }

    public function save($newPage,$oldPage){
        $this->page = $newPage;
        $this->page->setEditorContent($_POST['content']);
        $this->page->save();
    }

  }
?>

Im Installer habe ich alle benötigten Inhalte in die content-Spalte eingetragen und die Dateien gelöscht (Verzeichnisse müssen erstmal noch dableiben, kommen aber auch bald weg). Außerdem habe ich Verweise auf das alte Backend gelöscht, was eine Änderung in den PageIDs ergab. Diese musste dann in den Menüs übernommen werden, so dass doch relativ viele Änderungen zusammenkamen. Deswegen bitte ich aus diesem Grund hoffentlich fürs letzte Mal um eine Neuinstallation. Alle Änderungen stehen in Revistion 65.

Da ich jetzt wieder einen neuen Testserver hab kann es mit ContentLion weitergehen Und zwar haben wir unsere englische Übersetzung noch nicht vollständig umgesetzt. Der Hauptpunkt dabei sind die Datenbankeinträge. Hier könnte man theoretisch eine Lang-Spalte anlegen und sich immer die Einträge ziehen, die der aktuellen Sprache entsprechen.

Ich habe mich für einen anderen Weg entschieden. Wie ihr alle wisst, können wir in den Templates über das Lang-Tag auf Übersetzungen zurückgreifen. So zum Beispiel {LANG:PAGE}. Diese Tags möchte ich in der Datenbank verwenden und ich gehe noch weiter und übersetze diese bereits in der MySQL-Klasse!

Da wir die Zeilen als Objekte zurückgeben, müssen wir alle Eigenschaften durchlaugen und nach LANG-Tags durchsuchen. Diese Funktion habe ich in die Language-Klasse eingebaut, weil man somit später auch Objekte außerhalb der Datenbank leicht übersetzten kann.  Hierfür musste auch ich meine PHP-Kenntnisse ein wenig erarbeiten. Vorab schonmal der neuen Funktion replaceLanguageTokensByObject der Klasse /system/classes/language.php:

    public function replaceLanguageTokensByObject($obj){
      foreach($obj as $key => $value) {
        preg_match_all("/{LANG:(.+)}/", $value, $tokens, PREG_SET_ORDER);
        foreach($tokens as $token){
          $translation = $GLOBALS['language']->getString($token[1]);
          $obj->{$key} = str_ireplace($token[0],$translation,$obj->{$key});
        }
      }
      return $obj;
    }

Zunächst einmal kann man die Eigenschaften mit einer ganz normalen foreach-Schleife durchlaufen. $key ist der Name der Eigenschaft und $value logischerweise der Wert. mit den geschweiften Klammern können wir die Eigenschaft über einen String abfragen. Der Rest ist bereits aus anderen Teilen der Language-Klasse bekannt.

In der Datenbankklasse habe ich diese Funktionalität in den derzeit benötigten Abfragen eingebaut. Später muss noch ReadField folgen. Außerdem muss es auch möglich sein, Ausnamen zu definieren, aber das machen wir erst, wenn es wirklich benötigt wird. Hier ist der neue Code der Klasse /system/classes/mysql.php:

<?PHP
  class MySQL extends DataBase{
    private $connection;

    public function Execute($sql){
      return $this->connection->query(str_replace("{'dbprefix'}",$this->Prefix,$sql));
    } 

    public function GetTables(){
      $res =  $this->connection->query("SHOW TABLES");
      while($row = $res->fetch_row()){
        $tables[] = $row[0];
      }
      sort($tables);
      return $tables;
    }

    public function GetColumns($table){
      $mysqlres = $this->Execute("SHOW COLUMNS FROM ".$table);
      while($row = $mysqlres->fetch_object()){
        $res[] = $row;
      }
      return $res;
    }

    public function ReadField($sql){
      $res = $this->Execute($sql);
      $row = $res->fetch_row();
      return $row[0];
    }

    public function ReadRow($sql){
      $res = $this->Execute($sql);
      return $GLOBALS['language']->replaceLanguageTokensByObject($res->fetch_object());
    }

    public function ReadRows($sql){
      $res = array();
      $mysqlRes = $this->Execute($sql);
      while($row = $mysqlRes->fetch_object()){
        $row = $GLOBALS['language']->replaceLanguageTokensByObject($row);
        $res[] = $row;
      }
      return $res;
    }

    public function InsertID(){
      return $this->connection->insert_id;
    }

    public function EscapeString($text){
      return $this->connection->real_escape_string($text);
    }

    public function Connect(){
      $this->connection = new mysqli($this->Host,$this->User,$this->Password,$this->Name);
    }

    public function Disconnect(){
      $this->connection->close();
    }
  }
?>

Ich bin dann heute die Komplette Datenbank durchgegangen und habe alles übersetzt. Bereits bestehende Übersetzungen mussten leicht verändert werden. Da so gut wie alle MySQL- und SQLite Datenbankeinträge geändert wurden, solltet ihr das komplette System neu installieren. Ich werde kein Update bereitstellen, aber ihr könnt alternativ auch die Einzelnen änderungen in Revision 62 und 63 abarbeiten.

Stehengeblieben sind wir im vorherigen Teil des Tutoirals beim Erstellen der Partitionierung. Und direkt zum dritten Teil dürfen wir uns ausruhen! Denn erstmal muss das Dateisystem erzeugt werden:

Erzeugen des Dateisystems

Als nächstes ist das Grundsystem an der Reihe:

Installation Grundsystem

Hier kannst du deinen Benutzernamen eingeben.  Da ich Stefan heiße, habe ich den bei mir auch “stefan” genannt:

Benutzernamen eingeben

Als Nächstes musst du dein Passwort eingeben. Da es sich bei mir nur um einen Testserver für ein OpenSource System handelt, habe ich einfach mal “geheim” genannt. Bei produktiven Systemen solltest du selbstverständlich ein weitaus komplizierteres Passwort nehmen:

Passwort eingeben

Passwort bestätigen

An dieser Stelle hast du die Möglichkeit, deinen persöhnlichen Ordner zu verschlüsseln. Da es bei meinem Rechner immer noch um einen Testrechner handelt und ich meinen persögnlichen Ordner sowieso nicht verwenden werde, ist auch keine Verschlüsselung nötig.

Persöhnlichen Ordner verschlüsseln

Als Nächstes können wir für den Paketmanager einen Proxy-Server auswählen. Da ich keinen habe, kann ich das einfach leer lassen.

Paketmanager - Proxy-Server einrichten

APT konfigurieren

Wähle aus, wie deine Software aktualisiert werden soll. Ich habe mich für die automatische Aktualisierung entschieden:

Aktualisierungen

Bitte warten...

Jetzt kommt ein sehr spannender Teil der Installation: Man kann sofort Softwarepakete installieren. Für unseren Fall ist Lamp eine gute Wahl! Ausgewählt wird mit der Leertaste (ich habe bei meiner Installation versehentlich Enter gedrückt, so dass ich Lamp später nachinstallieren durfte):

Softwahlauswahl Ubuntu Server

Bitte warten...

Jetzt wirst du gefragt, ob du dem Grub-Loader im Master Boot Record installieren möchtest. Das bedeutet, ob das System als erstes starten sollte. Da wir nur ein Betriebssystem auf unserem virtuellen Rechner haben, kannst du diese Frage getrost mit ja beantrorten:

Grub PC

Mit dem nächstem Klick schließt du die Installation ab und beendest damit erfolgreich das Tutorial. Herzlichen Glückwunsch!

Installation beenden

Vier Augen sehen mehr als Zwei – Beim Bloggen können dir immer wieder kleine Fehler passieren. Das können ganz normale Grammatik- oder Rechtschreibfehler sein. Aber auch größere Fehler, wie zum Beispiel falsche Logik sind relativ beliebt. Leider erkennt man selbst nicht jeden Fehler, da man zum Beispiel immer darüber hinwegliest oder schlicht und einfach davon ausgegangen ist, dass es gar kein Fehler ist.

Wäre es nicht schön, wenn wir Blogger einen Lektor hätten, der vor dem Veröffentlichen eines Artikels nocheinmal Korrektur liest? Dieser Lektor sollte sich im Thema auskennen, aber auch so vertrauenswürdig sein, dass er nicht einfach die Artikelidee stiehlt.

Korrektur Lesen für bessere Artikel

Für dieses Problem habe ich mir eine Lösung ausgedacht, die nur funktioniert, wenn auch viele Blogger mitmachen. Und zwar platziert einfach jeder Blogger, der sich als Lektor anbietet ungefähr Folgendes im Footer oder in der Sidebar seines Blogs:

Ich biete mich als Lektor für deine Blog-Artikel an. Sende mir einfach deinen Artikel und ich korrigiere ihn.

Unter den jeweiligen Artikeln wird dann als Dankeschön ein Link zurück zum Lektoren-Blog gesetzt. So hat der Artikel-Schreiber einen hochwertigeren Artikel und der Lektor einen (themenrelevanten) Backlink.

Wer mitmachen will, kann sich gerne im Kommentar melden, so hat man schon mal erste Anlaufquellen. Meinen Lektor-Satz werde ich dann gleich mal im Footer platzieren.

In diesem Beitrag setzen wir die Installation des Ubuntu Servers auf VirtualBox vor. Gestern haben wir bereits eine neue virtuelle Maschine angelegt und heute kümmern wir uns um die Installation von Ubuntu selbst.

Zu nächst einmal müssen wir die Sprache wählen. Da ich Deutsch am Besten verstehe, habe ich natürlich das genommen:

Sprache auswählen

Wenn du nun den Hauptbildschirm siehst, kannst du die Installation starten:

Hauptbildschirm Ubuntu Installation

Als nächstes möchte Ubuntu von dir die Region wissen, in der du wohnst. Wenn du eben Deutsch gewählt hast, kannst du hier Deutschland, Österreich & Co auswählen:

Sprachgebiet anpassen

Als nächstes wirst du geben, das Tastaturmodell anzugeben:

Tastaturmodell Hinweis

Um den Typ zu bestimmen musst du einfach die oben eingeblendeten Tasten nacheinander eingeben. Dort erkennt Ubuntu zum Beispiel an der Position des “y” welches Modell du benutzt:

Tastatur Test

Jetzt fängt so langsam das Warten an:

Hardware Erkennung

Komponenten werden geladen...

Nun musst du deinem Rechner einen Namen fürs Netzwerk geben. Ich habe meinen contentliontest genannt, aber wenn du das System einfach nur testen möchtest, kannst du es einfach bei ubuntu belassen:

Rechnername

Die Zeitzone wurde bei mir erfolgreich erkannt:

Zeitzone erkannt

Und wieder warten…

Partitionierungsprogramm laden

Weiter geht’s mit der Partitionierung. Hier kann die virtuelle Festplatte unterteilt werden. Da wir sowieso beliebig viele virtuelle Laufwerke anlegen können, können wir die komplette Festplatte mit LVM nehmen.

Partitionierung wählen

Bestätigen...

Nochmal bestätigen...

ALs nächstes kannst du angeben, wie viel der Festplatte du nutzen möchtest. Ich denke hier ist “max” die richtige Antwort, denn bei einer Partition macht der Rest keinen Sinn.

Partionierungsgröße

Bitte warten...

Übersicht Partitionierungseinstellungen

Der nächste Teil kommt in Kürze, bis dahin kannst du einfach den Zustand der Maschine speichern.

Ich benutze virtuelle Server, um meine Projekte, wie zum Beispiel ContentLion zu testen, ohne meinen Rechner mit XAMPP oder Ähnlichem auszustatten. Heute zeige ich dir, wie man den Ubuntu Server (Linux-Betriebssystem) auf VirtualBox installieren kann.

Ich habe mich für ein Linux-System entschieden, da man auch für virtuelle Rechner eine Lizenz benötigt und ich keine Lust habe für einen Testserver extra eine Windows-Lizenz zu kaufen. Außerdem kann man über Ubuntu sogar direkt bei der Installation Lamp mitinstallieren.

Mit VirtualBox kannst du mehrere virtuelle Rechner auf einem echten Rechner installieren. Somit kannst du deine Porjkte gut voneinander trennen und musst auch nicht alles immer gestartet haben. Der Schritt Eins ist also die Installation von VirtualBox.

Wenn du damit fertig ist, benötigst du die Installation von Ubuntu Server. Ubuntu Server ist, wie der Name schon sagt, speziell für Server ausgelegt. Er besitzt keine grafische Oberfläche. Wenn du nicht darauf verzichten kannst, kannst du auch das normale Ubuntu installieren.

Lade dir die Server-Installation als iso (CD) hier herunter:

http://www.ubuntu.com/server/get-ubuntu/download

Um die Iso, ohne sie auf eine CD zu brennen zu nutzen, kannst du mir Daemon Tools installieren. So habe auch ich das bei meiner Installation gemacht.

Hast du all das gemacht, kann es endlich los gehen! Wenn du VirtualBox startest, kommst auf  folgende Übersicht (ähnlich der Abbildung):

VirtualBox Übersicht

Nach dem Klick auf “Neu” kann das Erstellen der Maschine beginnen:

Neue Maschine erstellen

Mit dem Klick auf Weiter kannst du das Betriebssystem und den Namen deiner neuen virtuellen Maschine auswählen. Da ich auf meinem Testserver das CMS ContentLion installieren möchte, nenne ich ihn “Contentlion Testserver 1″. Als Betriebssystem musst du Linux Ubuntu auswählen:

Name und Typ des virtuellen Servers

Als nächstes kannst du die Größe des Arbeitsspeichers bestimmen. Normalerweise reicht der empfohlene Wert aus, ich habe aber trotzdem mal ein wenig drauf gehauen:

Speicher einstellen

Mit einem Klick auf weiter kommst du zum Festplaten Dialog. Hier kannst du auswählen, ob du eine neue virtuelle Festplatte erstellen oder eine Vorhandene nutzen möchtest. Da du wahrscheinlich noch keine hast, musst du hier eine neue Erzeugen:

Virtuelle Festplatte auswählen

Hier gibt es nun einen neuen Dialog, in welchem du festplatte bestimmen kannst. Zunächst wieder ein Begrüßungsdialog:

Begrüßungsdialog neue Festplatte

Es gibt zwei verschiedene Festplattentypen. Zum einen ein “dynamisch wachsendes Medium”, welches nur so viel Speicher in Anspruch nimmt, wie es wirklich benötigt und zum anderen ein “Medium fester Größe” was von Anfang an den Platz für sich beansprucht. Solltest du keinen besonderen Grund für eine feste Größe haben, solltest du am besten die dynamische Größe benutzen:

Festplattentyp

Die Größe der Festplatte kannst du für deinen Verwendungszweck anpassen. Ich hab mich mal für 10 GB entschieden, damit ich auch noch ausreichend Platz zum Testen mit großen Datenmengen habe:

Festplatten Lage und Größe

Herzlichen Glückwunsch, du hast nun die Festplatte für dein neues System erstellt:

Zusammenfassung Festplatte

Wer hätte es gedacht, auch dein virtueller Server ist aufgesetzt:

Virtualbox Zusammenfassung

Du kommst jetzt zurück zur Übersicht. Nun kannst du oben im Menü auf “Start” klicken und deine Maschine erweckt zum Leben:

Startassistent

Jetzt musst du quasi deine Ubuntu-CD einlegen. Wie gesagt, ich habe das mit Daemon Tools gemacht. Dort kannst du mit einem Rechtsklick die ISO als Laufwerk einbinden. Den Laufwerksbuchstaben musst du dann in VirtualBox auswählen:

CD Einlegen

Nun kann die eigentliche Installation losgehen:

Start Zusammenfassung

Bald geht’s weiter mit dem Teil 2 des Tutorials!

Derzeit ist das Erstellen, Bearbeiten und Löschen von Menüs nur im alten Backend möglich. Das wird sich heute ändern. Wir werden die komplette Funktionalotät übertragen.

Fangen wir an mit dem Erstellen des Menüs in der Klasse /system/classes/menucreatorpage.php:

<?PHP
  class MenuCreatorPage extends Editor{
    function __construct($page){
      $this->page = $page;
    }

    public function display(){
      $template = new Template();
      $template->load("menu_new");
      $template->show_if("NOTSUCCEEDED",!$_POST['name']);
      $template->assign_var("URL",Settings::getInstance()->get("host")."admin/newmenu.html");
      if($_POST['name']){
        $template->show_if("SUCCEEDED");
        $id = Menu::create($_POST['name'],$_SESSION['dir']);
        if($id){
          $template->assign_var("EDITURL",Settings::getInstance()->get("host")."admin/editmenu.html?menu=".$id);
        }
        else{
          $template->load("message");
          $template->assign_var("MESSAGE",$language->getString("MENU_NOT_CREATED"));
        }
      }
      $template->output();
    }
    function getHeader(){
    }

    public function getEditableCode(){
      return "<input name=\"save\" type=\"submit\" value=\"&Auml;ndern\" onclick=\"form.action='".$_SERVER['PHP_SELF']."?".$_SERVER['QUERY_STRING']."' ; target='_self' ; return true\" />";
    }

    public function save($newPage,$oldPage){
    }
  }
?>

Weiter geht’s mit dem Bearbeiten der Einträge. Das geschieht im /system/classes/menueditor.php:

<?PHP
  class MenuEditor extends Editor{
    function __construct($page){
      $this->page = $page;
    }

    public function display(){
      $template = new Template();
      $template->load("menu_edit");
      if($_POST['add']){
        if(trim($_POST['newtitle']) != ""){
          if(trim($_POST['newurl']) != ""){
            $entry        = new MenuEntry();
            $entry->menu  = $_GET['menu'];
            $entry->title = $_POST['newtitle'];
            $entry->type  = $_POST['type'];
            if($entry->type == 0){
              $entry->href  = $_POST['newPage'];
            }
            else if($entry->type == 1){
              $entry->href  = $_POST['newurl'];
            }
            else{
              $entry->href  = $_POST['newMenu'];
            }
            $res = $entry->save();
            if($res){
              $template->assign_var("MESSAGE",$GLOBALS['language']->getString("ENTRY_ADDED"));
            }
            else{
              $template->assign_var("MESSAGE",$GLOBALS['language']->getString("ENTRY_NOT_ADDED"));
            }
          }
          else{
            $template->assign_var("MESSAGE",$GLOBALS['language']->getString("ENTER_LINK_TARGET"));
          }
        }
        else{
            $template->assign_var("MESSAGE",$GLOBALS['language']->getString("ENTER_LINK_TITLE"));
        }
      }
      else if($_POST['save']){
        foreach($_POST as $param=>$value){
          if(strlen($param) >= 6){
            if(substr($param,-5,5) == "_href"){
              $entries[substr($param,0,-5)][href] = $value;
            }
            else if(strlen($param) >= 7 && substr($param,-6,6) == "_title"){
              $entries[substr($param,0,-6)][title] = $value;
            }
            else if(substr($param,-5,5) == "_type"){
              $entries[substr($param,0,-5)][type] = $value;
            }
          }
        }
        foreach($entries as $id=>$params){
          $entry        = new MenuEntry();
          $entry->id    = $id;
          $entry->menu  = $_GET['menu'];
          $entry->title = $params['title'];
          $entry->href  = $params['href'];
          $entry->type  = $params['type'];
          $entry->save();
        }
      }
      else{
        foreach($_POST as $param=>$value){
          if(strlen($param) >= 8){
            if(substr($param,-7,7) == "_delete"){
              Menu::deleteEntry($GLOBALS['db']->EscapeString($_GET['menu']),
                                $GLOBALS['db']->EscapeString(substr($param,0,-7)));
            }
          }
        }
      }

      $template->assign_var("URL",Settings::getInstance()->get("host").$this->page->alias.".html?menu=".urlencode($_GET['menu']));
      $template->assign_var("EDITABLEMENU",Menu::getEditableCode($GLOBALS['db']->EscapeString($_GET['menu'])));

      $selector = new MenueSelector();
      $selector->name  = 'newMenu';
      $selector->value = -1;
      $selector->style = 'width:200px;position:relative;left:-210px;visibility:hidden';
      $template->assign_var("MENUSELECTOR", $selector->getCode());

      $selector = new PageSelector();
      $selector->name  = 'newPage';
      $selector->value = -1;
      $selector->style = 'width:200px;position:relative;left:-415px;';
      $template->assign_var("PAGESELECTOR", $selector->getCode());

      $template->assign_var("MESSAGE","");
      $template->output();
    }
    function getHeader(){
    }

    public function getEditableCode(){
      return "<input name=\"save\" type=\"submit\" value=\"&Auml;ndern\" onclick=\"form.action='".$_SERVER['PHP_SELF']."?".$_SERVER['QUERY_STRING']."' ; target='_self' ; return true\" />";
    }

    public function save($newPage,$oldPage){
    }
}
?>

Der letzte Seitentyp ist die /system/classes/menudeletepage.php. Hier werden die Menüs gelöscht:

<?PHP
  class MenuDeletePage extends Editor{
    function __construct($page){
      $this->page = $page;
    }

    public function display(){
      $template = new Template();
      if(!$_GET['delete']){
        $template->load("menu_delete");
        $template->assign_var("CANCELURL","javascript:history.back()");
        $template->assign_var("DELETEURL",Settings::getInstance()->get("host").$this->page->alias.".html?menu=".urlencode($_GET['menu'])."&delete=true");
      }
      else{
        $template->load("message");
        if(Menu::delete($GLOBALS['db']->EscapeString($_GET['menu']))){
            $template->assign_var("MESSAGE",$GLOBALS['language']->getString("MENU_DELETED"));
        }
        else{
          $template->assign_var("MESSAGE",$GLOBALS['language']->getString("MENU_NOT_DELETED"));
        }
      }
      $template->output();
    }

    function getHeader(){
    }

    public function getEditableCode(){
      return "<input name=\"save\" type=\"submit\" value=\"&Auml;ndern\" onclick=\"form.action='".$_SERVER['PHP_SELF']."?".$_SERVER['QUERY_STRING']."' ; target='_self' ; return true\" />";
    }

    public function save($newPage,$oldPage){
    }
}
?>

Das erstellen von Menüs im Backend war bisher nur ohne Ordner möglich. Das ändert die Funktion create der Klasse /system/classes/menu.php:

  function create($name,$dir = ""){
    $name = $GLOBALS['db']->EscapeString($name);
    $dir = $GLOBALS['db']->EscapeString($dir);
    $res = $GLOBALS['db']->Execute("INSERT INTO {'dbprefix'}menu_names (name, dir) VALUES ('".$name."', '".$dir."')");
    if($res){
      $args['name']  = $name;
      EventManager::raiseEvent("menu_created","../",$args);
    }
    return $GLOBALS['db']->InsertID();
  }

Um die Funktion nutzen zu können müssen folgende SQL-Queries ausgeführt werden:

INSERT INTO `cms_menu` VALUES (14, 8, 'Menü', '16', 0);
INSERT INTO `cms_pages` VALUES (16, 'admin/newmenu', 'Neues Menü', 7, 0, 'menucreatorpage');
INSERT INTO `cms_pages` VALUES (17, 'admin/editmenu', 'Menü Bearbeiten', 7, 0, 'menueditor');
INSERT INTO `cms_pages` VALUES (18, 'admin/deletemenu', 'Menü Löschen', 7, 0, 'menuedeletepage');
INSERT INTO `cms_role_rights` VALUES (2,16);
INSERT INTO `cms_role_rights` VALUES (2,17);
INSERT INTO `cms_role_rights` VALUES (2,18);

Alle Änderungen stehen in den Revisonen 51, 52, 53, 54, 55 und 56.

Unser CMS ContentLion ist ja zum Großteil objektorientiert – Nur zum Großteil! Denn auf die Settings wird derzeit über die Funktionen getSetting und setSetting zugegriffen. Da in Kürze Erweiterungen in Richtung Multi-Domain Benutzung und Order bzw. Seitenspezische Einstellungen anstehen, ist jetzt der passende Augenblick, die Settings einmal zu überarbeiten.

Die alten Funktionen waren in der Datei /system/settings.php gespeicher, die am Ende des Beitrags gelöscht werden kann. Für jede Abfrage auf die Settings wurde eine Datenabfrage generiert. Bei Settings die häufiger gebraucht werden (root oder host) kann dies zu kleinen Performance-Problemen führen, weshalb ich in den neuen Settings extra darauf geachtet habe, dass wir jeden Setting nur einmal auslesen müssen.

Du erinnerst dich bestimmt, dass es neben den globalen Einstellungen auch Einstellungen für Plugins oder Skins geben kann. Hier werden die Spalten areaType und area verwendet -> default ist beides global. In der neuen Settings-Klasse gibt es eine statisches Array mit dem Namen instances. Hier werden alle Instanzen der Settings-Klasse gespeichert. Als keys werden areaType unda rea genommen, so dass wir sicherstellen können, dass für jeden areaType und für jede area nur eine Instanz vorhanden ist.

Die Hauptinstanz, die für alle Settings ist, wird über die Funktion getInstance zurückgegeben. Sie erstellt auch ein neues Settings-Objekt, falls noch keins vorhanden ist:

    public static function getInstance(){
      if(!isset(self::$instances["global"]["global"])){
        $res = new Settings();
        self::$instances["global"]["global"] = $res;
      }
      else{
        $res = self::$instances["global"]["global"];
      }
      return $res;
    }

Diese
Über diese Instanz kann man (gleich) schonmal die globalen Einstellungen auslesen. Möchte man nun eine Skinspezifische einstellung auslesen, kann man über specify eine passende Instanz bekommen:

    public function specify($areaType = "global",$area = "global"){
      if(!isset($this->$instances[$areaType][$area])){
        $res = new Settings();
        $res->parent = $this;
        $res->setAreaType($areaType);
        $res->setArea($area);
        $this->instances[$areaType][$area] = $res;
      }
      else{
        $res = $this->instances[$areaType][$area];
      }
      return $res;
    }

In dieser wwerden areaType und die area gespeichert. Außerdem gibt es einen verweis auf die übergeordnete Klasse, so dass wenn keine spezifische Einstellung erstellt wurde einfach auf die globalen Einstellungen zurückgegriffen werden kann.

In der Funktion get und  der privaten Funktion getFromDB kann man sich nun die jeweilige Einstellung heraussuchen. Der Quelltext ähnelt dem der alten getSetting():

    public function get($property){
      $res = null;
      if(isset($this->properties[$property])){
        $res = $this->properties[$property];
      }
      else{
        $res = $this->getFromDB($property);
        if(!$res && $this->parent != null){
          $res = $this->parent->get($property);
        }
        $this->properties[$property] = $res;
      }

      return $res;
    }

    protected function getFromDB($property){
      $area     = $GLOBALS['db']->EscapeString($this->area);
      $areaType = $GLOBALS['db']->EscapeString($this->areaType);
      $property = $GLOBALS['db']->EscapeString($property);
      $sql      = "";
      if(isset($_SESSION['user'])){
       $sql = "SELECT value FROM {'dbprefix'}settings WHERE role = '".$_SESSION['user']->role->ID."' AND area = '".$area."' AND areaType = '".$areaType."' AND property = '".$property."' UNION ";
      }
      $sql .= "SELECT value FROM {'dbprefix'}settings WHERE role = '3' AND area = '".$area."' AND areaType = '".$areaType."' AND property = '".$property."'";
      return $GLOBALS['db']->ReadField($sql);
    }

Die Funktion set ist ungefähr der Inhalt der alten setSetting:

    public function set($property,$value){
      $area     = $GLOBALS['db']->EscapeString($this->area);
      $areaType = $GLOBALS['db']->EscapeString($this->areaType);
      $property = $GLOBALS['db']->EscapeString($this->property);
      $value    = $GLOBALS['db']->EscapeString($this->value);
      $role     = $GLOBALS['db']->EscapeString($this->role);
      $allUserData = $GLOBALS['db']->ReadRow("SELECT * FROM  {'dbprefix'}settings WHERE area = '".$area."' AND areaType = '".$areaType."' AND property = '".$property."' AND role = '3'");
      if($GLOBALS['db']->EscapeString($allUserData->value) != $value or $role == 3){
        $exists = $GLOBALS['db']->ReadField("SELECT COUNT(*) FROM {'dbprefix'}settings WHERE area = '".$area."' AND areaType = '".$areaType."' AND property = '".$property."' AND role = '".$role."'") > 0;
        if($exists){
          $res = $GLOBALS['db']->Execute("UPDATE {'dbprefix'}settings SET value = '".$value."' WHERE area = '".$area."' AND areaType = '".$areaType."' AND property = '".$property."' AND role = '".$role."'");
        }
        else{
          $res = $GLOBALS['db']->Execute("INSERT INTO {'dbprefix'}settings (value,area,areaType,property,role,description,type) VALUES ('".$value."', '".$area."', '".$areaType."', '".$property."', '".$role."','".$allUserData->description."','".$allUserData->type."')");
        }
      }
      else{
        $GLOBALS['db']->Execute("DELETE FROM {'dbprefix'}settings WHERE area = '".$area."' AND areaType = '".$areaType."' AND property = '".$property."' AND role = '".$role."'") ;
      }
      return $res;
    }

Jetzt kommt der spaßige Teil der Änderung: Alle getSetting und setSetting-Aufrufe müssen an die neue Funktion angepasst werden. Für die globalen Einstellungen kann man zum Beispiel so den host bekommen: Settings::getInstance()->get(“host”).

Ich hoffe, ich habe in alle entsprechenden Aufrufe im Source geändert. Am besten ihr installiert ContentLion einmal neu, damit auch beim Update keine Datei vergessen wird.

Hier ist nochmal fürs Copy & Paste der komplette Code der neuen Settings-Klasse:

<?PHP
  class Settings{

    protected $area              = "global";
    protected $areaType          = "global";
    protected $parent            = null;
    protected $properties        = array();
    protected static $instances  = array();

    public function get($property){
      $res = null;
      if(isset($this->properties[$property])){
        $res = $this->properties[$property];
      }
      else{
        $res = $this->getFromDB($property);
        if(!$res && $this->parent != null){
          $res = $this->parent->get($property);
        }
        $this->properties[$property] = $res;
      }

      return $res;
    }

    protected function getFromDB($property){
      $area     = $GLOBALS['db']->EscapeString($this->area);
      $areaType = $GLOBALS['db']->EscapeString($this->areaType);
      $property = $GLOBALS['db']->EscapeString($property);
      $sql      = "";
      if(isset($_SESSION['user'])){
       $sql = "SELECT value FROM {'dbprefix'}settings WHERE role = '".$_SESSION['user']->role->ID."' AND area = '".$area."' AND areaType = '".$areaType."' AND property = '".$property."' UNION ";
      }
      $sql .= "SELECT value FROM {'dbprefix'}settings WHERE role = '3' AND area = '".$area."' AND areaType = '".$areaType."' AND property = '".$property."'";
      return $GLOBALS['db']->ReadField($sql);
    }

    public function set($property,$value){
      $area     = $GLOBALS['db']->EscapeString($this->area);
      $areaType = $GLOBALS['db']->EscapeString($this->areaType);
      $property = $GLOBALS['db']->EscapeString($this->property);
      $value    = $GLOBALS['db']->EscapeString($this->value);
      $role     = $GLOBALS['db']->EscapeString($this->role);
      $allUserData = $GLOBALS['db']->ReadRow("SELECT * FROM  {'dbprefix'}settings WHERE area = '".$area."' AND areaType = '".$areaType."' AND property = '".$property."' AND role = '3'");
      if($GLOBALS['db']->EscapeString($allUserData->value) != $value or $role == 3){
        $exists = $GLOBALS['db']->ReadField("SELECT COUNT(*) FROM {'dbprefix'}settings WHERE area = '".$area."' AND areaType = '".$areaType."' AND property = '".$property."' AND role = '".$role."'") > 0;
        if($exists){
          $res = $GLOBALS['db']->Execute("UPDATE {'dbprefix'}settings SET value = '".$value."' WHERE area = '".$area."' AND areaType = '".$areaType."' AND property = '".$property."' AND role = '".$role."'");
        }
        else{
          $res = $GLOBALS['db']->Execute("INSERT INTO {'dbprefix'}settings (value,area,areaType,property,role,description,type) VALUES ('".$value."', '".$area."', '".$areaType."', '".$property."', '".$role."','".$allUserData->description."','".$allUserData->type."')");
        }
      }
      else{
        $GLOBALS['db']->Execute("DELETE FROM {'dbprefix'}settings WHERE area = '".$area."' AND areaType = '".$areaType."' AND property = '".$property."' AND role = '".$role."'") ;
      }
      return $res;
    }

    public function setArea($area){
      $this->area = $area;
    }

    public function setAreaType($area){
      $this->areaType = $area;
    }

    public static function getInstance(){
      if(!isset(self::$instances["global"]["global"])){
        $res = new Settings();
        self::$instances["global"]["global"] = $res;
      }
      else{
        $res = self::$instances["global"]["global"];
      }
      return $res;
    }

    public function specify($areaType = "global",$area = "global"){
      if(!isset($this->$instances[$areaType][$area])){
        $res = new Settings();
        $res->parent = $this;
        $res->setAreaType($areaType);
        $res->setArea($area);
        $this->instances[$areaType][$area] = $res;
      }
      else{
        $res = $this->instances[$areaType][$area];
      }
      return $res;
    }

  }
?>

Alle weiteren Änderungen findest du in den Revisonen 47, 48,  49 und 50.

Wenn in unserem CMS derzeit eine Seite nicht gefunden oder der zugriff verweigert wurde, bekommen wir eine PHP-Meldung. Das sollte natürlich so nicht sein. Derzeit werden die Rechte direkt in der index.php bzw. neuerdings in der /content/index.txt überprüft, jedoch funktionierte das auch noch nicht so schön.

Erst habe ich den alten Fehler mit dem Zugriff-Verweigert ausgebssert und wollte Ähnliches für das Seite-Nicht-Gefunden machen. Doch da kam mir eine viel bessere Idee: Wir regeln das über Exceptions. So müssen wir in der index lediglich die Exceptions abfangen und die Fehlernachricht anzeigen.

Für alle ContentLion-Exceptions gibt es die neue Klasse /system/contentlionexception.php. In dieser wird neben der Standard-PHP-Exception auch eine Fehlerseite als Page-Objekt angelgt. So können wir eine sprechende Fehlermeldung auch über unser System anzeigen. Die Basisklasse die wir nun für alle über Contentlion geworfenen Exceptions benutzten sieht so aus:

<?PHP
  class ContentLionException extends Exception{
    protected $errorPage = null;

    public function getErrorPage(){
      return $this->errorPage;
    }

    public function setErrorPage(Page $page){
      $this->errorPage = $page;
    }
  }
?>

Jetzt erben wir von dieser Klasse in der neuen /system/classes/accessdeniedexception.php:

<?PHP
  class AccessDeniedException extends ContentLionException{

    public function __construct($message, $code = 0) {
      parent::__construct($message, $code);
      $page = new Page();
      $page->loadPropertiesById(getSetting("global","global","accessdenied"));
      parent::setErrorPage($page);
    }

  }
?>

Bei der AccessDeniedException können wir die Seite schön über die Datenbank laden. Bei der FileNotFound-Ecxeption sieht es anders aus, denn was passiert, wenn die Fehlerseite auch nicht gefunden werden kann? Richtig: Eine Endos-Schleife. Hier erstmal der Code der Exception (system/classes/filenotfoundexception.php):

<?PHP
  class FileNotFoundException extends ContentLionException{

    public function __construct($message, $code = 0) {
      parent::__construct($message, $code);
      $page = new Page();
      $page->editor = new BlankEditor($page);
      $page->editor->setContent("<h2>Seite nicht gefunden!</h2><p>Diese Seite konnte nicht gefunden werden!</p>");
      parent::setErrorPage($page);
    }

  }
?>

Hier wird eine neue Editor-Klasse verwendet. Ich habe diese sehr simpel aufgebaut, so dass man den Text zuweisen kann und werden Datenbankverbindung noch Zugriff auf Dateisystem benötigt. /system/classes/blankeditor.php:

<?PHP
  class BlankEditor extends Editor{
    protected $content = "";

    function __construct($page){
      $this->page = $page;
    }

    public function display(){
      echo $this->content;
    }

    public function setContent($content){
      $this->content = $content;
    }

    function getHeader(){
    }

    public function getEditableCode(){
    }

    public function save($newPage,$oldPage){
    }

    private function readContent(){
        $filename = getSetting("global","global","root")."content/articles/".$this->page->alias.".php";
        $handle = @fopen ($filename, "rb");
        if($handle && filesize($filename) > 0){
            $contents = fread ($handle, filesize ($filename));
            fclose ($handle);
        }
        else{
            $contents = "";
        }
        return $contents;
    }

    private function deleteContent(){
    }

    function writeContent($content){
    }

    function getBreadcrumb(){
    }

  }
?>

Die Exceptions selbst werden in der /system/classes/page.php ausgelöst. So können wir sicher sein, dass der User immer auch Zugriff auf eine Seite hat, egal wo die Page-Klasse verwendet wird. Da wir hier sowieso prüfen müssen, ob die Seite vorhanden ist, müssen wir auch hier die FileNotFound-Exception werfen:

  function loadProperties($alias){
    if ($alias == "") {
      $alias = "home";
    }
    $this->alias = $alias;
    $row = $GLOBALS['db']->ReadRow("SELECT * FROM {'dbprefix'}pages 
                           WHERE alias = '".$alias."'");
    $this->load($row);
  }

  function loadPropertiesById($id){
    $row = $GLOBALS['db']->ReadRow("SELECT * FROM {'dbprefix'}pages 
                           WHERE id = '".$id."'");
    $this->load($row);
  }

  function load($data){
    if($data){
      $this->id = $data->id;
      $this->title = $data->title;
      $this->ownerid = $data->owner;
      $this->menu = $data->menu;
      $this->alias = $data->alias;
      $this->meta  = new Meta();
      $this->meta->pageid = $this->id;
      $this->meta->load();
      $this->editor = new $data->editor($this);
      if(!$_SESSION['user']->role->canAccess($this)){
        throw new AccessDeniedException("Access denied: ".$this->alias);
      }
    }
    else{
      throw new FileNotFoundException("File Not Found: ".$this->alias);
    }
  }

Zu guter letzt kommt das Abfangen in der /content/index.txt. Diese Datei wurde vor Kurzem vom Daniel dahin verschoben, damit wir bei der Installation auch die index.php aufrufen können. Nach der Installation wird die index.txt zur index.php. Beim Abfangen der Exceptions tauschen wir einfach die aktuelle Seite mit der Seite aus der Exception aus:

<?PHP
  function __autoload($class_name){
      $imported = false;
      $namespaces = split("_",strtolower($class_name));
      if(sizeOf($namespaces) == 3){
        if($namespaces[0] == "plugin"){
          require_once "system/plugins/".$namespaces[1]."/classes/".$namespaces[2].".php";
          $imported = true;
        }
        else if($namespaces[0] == "skin"){
          require_once "system/skins/".$namespaces[1]."/classes/".$namespaces[2].".php";
          $imported = true;
        }
      }
      if(!$imported){
        require_once "system/classes/".strtolower($class_name).".php";
      }
  }
  session_start();
  include("system/settings.php");
  include("system/filterfilename.php");
  GetParamParser::parse();
  $db = new MySQL('system/dbsettings.php');
  $db->Connect();
  $language = new Language();
  if(!isset($_SESSION['user'])) $_SESSION['user'] = new User();
  if(file_exists(getSetting("global","global","root").$_GET['include'].".htm")){
    include(getSetting("global","global","root").$_GET['include'].".htm");
  }
  else if(file_exists(getSetting("global","global","root").$_GET['include'].".html")){
    include(getSetting("global","global","root").$_GET['include'].".html");
  }
  else{
    if(!isset($_GET['include'])){
      $_GET['include'] = '';
    }
    try{
      $currentpage = new Page();
      $currentpage->loadProperties($GLOBALS['db']->EscapeString($_GET['include']));
    }
    catch(ContentLionException $ex){
      $currentpage = $ex->getErrorPage();
    }
    if(!isset($_GET['skin'])){
      include(SkinController::getCurrentSkinPath()."/index.php");
    }
    else{
      include('system/skins/'.$_GET['skin']."/index.php");
    }
  }
?>

Alle weiteren Änderungen stehen bei Google Code in den Revisionen r38 r39 r40 r41 r42 r43 r44 und r45.