[Victorious]

Hallo,

ich hoffe das ist das richtige Board für diese Frage, wenn nicht bitte ins richtige verschieben.

Ich möcht gerne mein eignes CMS schreiben, bevor antworten kommen wie diese "wieso nen eignes CMS schreiben, wenn es schon dutzende davon im Web gibt" , sag ich im Vorfeld wieso ich ein eignes haben will. Der Grund ist ganz einfach und zwar möchte ich meine Kenntnisse in der Web Entwicklung vertiefen, ausbauen usw. In meinen Augen kann man das sehr gut bei einem CMS erlangen.

Persönnlich weiss ich selber, dass sehr viel Zeit in anspruch nimmt so etwas zu schreiben. Und nun zu meiner eigentlich Frage, bevor man ja überhaupt anfangen kann muss man ja wiessen, was das CMS alles können soll/muss. Im groben habe ich auch schon was im Kopf was es alles können soll.

• News bearbeiten/hinzufügen
• Naviagtion bearbeiten/hinzufügen
• Seiten bearbeiten/hinzufügen
• Member bearbeiten/hinzufügen
• Medienverwaltung(Bilder/video/downloads)
• Module hinzufügen
• Mehr Sprachig

Mehr wüsste ich gerade nicht im Kopf (Für jede Anregung erfeut). Hab schon in anderen threads gelesen das man sich das in ein Pflichtenheft oder ähnliches aufschreiben sollte. Ich hab nur keine Anhung wie man so ein Heft aufbaut, da ich noch nie eins angefertigt habe. Hab auch noch kein beispiel für sowas gefunden was ich gebrauchen könnte. Wäre vieleicht cool , wenn irgend jemand sowas hätte oder grob sagen könnte was da alles rein muss für so ein Projekt.

Zudem würde ich auch gerne wiessen was ich mir noch alles anschauen sollte bevor ich das CMS schreibe. Ich habe da auch nur grob eine Vorstellung.

• das ganze OOP zu gestalten
• Als Design Pattern MVC zu benutzen
• XML
• AJAX (Web 2.0 fähig)

Hab nur nicht so recht ne Ahnung wie ich XML mit php in Verbindung bringen soll, bisher auch noch nichts richtiges dazu gefunden. Ich weiss nur das man per XSLT aus XML Datein HTML Datein transformieren kann. Eignet sich das überhaupt gut für die View Schicht oder ist es vieleicht doch besser was anders als Template Engien zu verwenden.

Gruß
Victorious

[Ben]

Hi,
arbeite das hier mal durch: [Grundlagen] Entwicklung eines Projektkonzeptes

Ich persönlich denke, dass es sinnvoll ist, ganz simpel anzufangen.
Heißt, dass im ersten Schritt die folgenden Dinge implementiert werden sollten:

• Userauthentifizierung:
  Also das du dich als User anmelden kannst und dann je nach Anmeldestatus Dinge tun kannst. Eine Registrierung ist ja zunächst nicht erforderlich.
• Hinzufügen, Bearbeiten, Löschen und Anzeigen von Inhalt.

Wenn du dann das Hinzufügen, Bearbeiten und Löschen mit der Authentifizierung verbindest bist du eigentlich schon bei der ersten lauffähigen Version.
Du - und nur du, da passwortgeschützt - kannst Inhalte auf der Seite verwalten und diese werden dynamisch angezeigt.

Das Ganze ist nicht schön, aber es läuft.
Wenn du an der Stelle angekommen bist, kannst du weiterschauen.

Mach dir nicht so viele Gedanken, was man alles machen könnte. Nimm dir kleine Etappen vor.
In meinen Augen ist es sogar sinnvoll eventuell, je nach Erfahrung, zunächst auf ein Framework zurückzugreifen, welches dir grundlegende Features und Funktionalitäten bietet.

Will damit sagen, dass man sich zu Beginn einfach mal auf das Nötigste konzentrieren sollte, da man sonst sehr schnell im Kreis herum läuft.

[Victorious]

Welche Vorteile bietet mir den ein Framework genau? Und wie siehts aus mit der Rechtslage, also z.B man hat seine erste laufähige Version fertig gestellt und will sie nun verkaufen, darf man das den so einfach oder man bietet das ganze als opensource an. Auf was muss man da achten den?


Und was ist eigentlich besser bzw sicher bei einem Login sessions oder cookies oder vlt beides?

Das Ganze ist nicht schön, aber es läuft.
Wenn du an der Stelle angekommen bist, kannst du weiterschauen.

Was meinste da genau, das das Ganze nicht schön ist.

[Corvin]

Welche Vorteile bietet mir den ein Framework genau?

Wie Ben schon sagt, es bietet dir wichtige grundlegende Funktionen, es erspart dir also Arbeit. Weiterhin kann es für eine gute, übersichtliche Code-Struktur sorgen.

Und wie siehts aus mit der Rechtslage, also z.B man hat seine erste laufähige Version fertig gestellt und will sie nun verkaufen, darf man das den so einfach oder man bietet das ganze als opensource an. Auf was muss man da achten den?

Wenn du zum Beispiel ein Framework oder Template-System von jemden anderem verwendest, dann musst du darauf achten, was in den Lizenzbestimmungen steht. Steht das Ganze zum Beispiel unter der GPL, dann ist eine kommerzielle Nutzung verboten. Weiterhin musst du dein CMS dann ebenfalls auch unter die GPL stellen.
Wenn du nur eigenen Code verwendest steht es dir natürlich frei, welche Lizenz du verwendest und ob du Kopien deines CMS zum Verkauf anbietest oder nicht.

Und was ist eigentlich besser bzw sicher bei einem Login sessions oder cookies oder vlt beides?

[PHP] Sichere PHP-Web-Applikationen schreiben

[Basti]

Zitat von Corvin

Wenn du zum Beispiel ein Framework oder Template-System von jemden anderem verwendest, dann musst du darauf achten, was in den Lizenzbestimmungen steht. Steht das Ganze zum Beispiel unter der GPL, dann ist eine kommerzielle Nutzung verboten.

Das stimmt nicht. Die GPL verbietet nicht die kommerzielle Nutzung. Andernfalls gäbe es wohl keine Firmen, die mit Linux, MySQL, TYPO 3 und und und Kohle verdienen würden.

Leg am besten einfach mal für dich fest, fas für eine Lizenz du für dein Produkt anstrebst und dann schau, was dazu passt. Allerdings würde ich mir bei einem rein privaten Lernprojekt nicht gleich alle möglichen Wege verbauen, bloß weil es sein könnte, dass du in drei, vier Jahren das CMS mal verkaufen möchtest.

Ich hab mein CMS fast ausschließlich selbst geschrieben und verwende an „Fremdcode“ lediglich eine PEAR-Klasse zur E-Mail-Adressen-Validierung und eine Klasse zum Erstellen von Passwort-Hashes. Dazu eine angepasste Funktion zum rekursiven „mergen“ von Arrays und eine Funktion aus dem PHP-Bugtracker zum dealen mit der besch* magic_quotes-Implementierung.

Ich hab viel gelernt damit, z.B. ein ORM umzusetzen oder der lange Weg, bis ich eine MVC-Struktur hatte, die halbwegs passt – aber für den Anfang ist das sicherlich nichts – und ich sitze nun seit über 2 Jahren dran, betreibe zwar schon einige Kunden-Websites darauf, es ist aber immer noch nicht in dem Stadium, dass ich es veröffentlichen möchte – was mein Ziel ist.

Mein Vorschlag für die Umsetzung:
- Definiere die Standard-Funktionen und schreibe Controller dafür: Seite hinzufügen, Seite löschen, Seite bearbeiten, Seite anzeigen – das sollte für den Anfang erstmal reichen.
- Von wegen Module kannst du ja erstmal jeder Seite einen Typ verpassen (Artikel, Seite mit News, Kontaktformular) und je Seite ein Template für die Darstellung, eines für das Formular zum Bearbeiten und einen speziellen Controller zum bearbeiten der Daten schreiben.
- Dann fängst du mit einem Seitentyp "HTML" an und hast hier als Eingabeformular nur ein Textfeld, in das du eben das HTML reinschreibst.
- Weiter kannst du dann z.B. Elemente ausklammern, die für alle Seiten gelten, wie z.B. die Überschrift, die Bezeichnung in den Menüs, Meta-Tags etc.
- Dann kopierst du dieses Modul und ersetzt das Textfeld durch einen WYSIWYG-Editor, womit du dann schon den zweiten Seitentyp für eine einfache Textseite hast.
- Dann würde ich mir überlegen, wie du das bearbeiten des Seitenbaumes angehst, also das rumschieben von Seiten. Ich hab das alles z.B. ganz ohne Backend umgesetzt, aber da gibt es ja viele Möglichkeiten.
- Dann noch ein LogIn einfriemeln, also auch die Funktionen Benutzer anmelden, Benutzer abmelden, dann kannst du damit schon online gehen.

Mit einem Framework hast du halt eine ganze Menge an Gedöhns weniger, aber ohne lernst du halt eine Menge mehr. Mein Tipp dazu: Sobald du anfängst einen Code zweimal zu schreiben, überdenke deine Konstruktion und schau, ob du da nicht etwa was ausklammen kannst.

Beispiel:

PHP-Code:

<?php

$sPage = $this->Sitemap->getHomepage();

if (isset($_REQUEST['page'])) {

    $sPage = $_REQUEST['page'];
    if (!preg_match('/^[a-zA-Z][a-zA-Z0-9\-_]*$/D'))
        throw new Blabla;
}

Daraus wird dann halt schnell eine eigene Request-Klasse, die du allen Controllern übergibst:

PHP-Code:


$sPage = $this->Request->get('page');

if (is_null($sPage))
    $sPage = $this->Sitemap->getHomepage();

if (!preg_match('/^[a-zA-Z][a-zA-Z0-9\-_]*$/D'))
    throw new Blabla; 


Damit wirst du zwar wohl lange unterwegs sein, aber du kommst letztlich dahinter, was Sinn macht, welche Code-Teile sich wie sinnvoll ordnen lassen, welche Informationen sie brauchen und wie sie miteinander kommunizieren sollten. Das Ganze im UML-Designer zu entwerfen ist für den Anfang wahrscheinlich illusorisch, auch wenn es ein guter Ansatzpunkt ist und dir eine Menge an Arbeit ersparen kann, da Konflikte etc. sich schneller ablesen lassen.

Viel Spaß.
Bastian

[Corvin]

Zitat von Basti

Das stimmt nicht. Die GPL verbietet nicht die kommerzielle Nutzung.

Gut zu wissen.. ich war seit ein paar Jahren in dem Glauben, dass die GPL eine komerzielle Nutzung explizit verbietet.

[Ben]

Morje Basti,
das was du schreibst ist sicherlich richtig. Man kann das alles alleine schreiben.
Aber du wirst doch sicher auch schon die Erfahrung gemacht haben, dass man, wenn man ganz am Anfang steht, relativ schnell Ergebnisse sehen will, da einen sonst die Motivation verlässt.

Wenn man sich dann noch mit dem ganzen Gedöhnse (Controller und Konsorten) befassen muss ... also ich bezweifle einfach, dass das der richtige Weg für jemanden ist, der sein erstes wirkliches Projekt erstellen will.

Demnach sehe ich es als günstiger an, dass man halt erstmal etwas auf Basis von etwas "Fertigem" bastelt und dann, wenn man es für notwendig hält, z.B. weil man an dem verwendeten "Framework" (es kann ja auch einfach 'ne Klassensammlung à la PEAR verwendet werden!) irgendetwas nicht ausreichend für die eigenen Bedürfnisse findet, sich nochmal hinsetzt und etwas Eigenes bastelt.

Das geht dann auch leichter von der Hand, weil man bereits Erfahrung gesammelt hat.

So seh ich das ..

[Basti]

Zitat von Corvin

Gut zu wissen.. ich war seit ein paar Jahren in dem Glauben, dass die GPL eine komerzielle Nutzung explizit verbietet.

http://www.gnu.org/licenses/gpl-faq....PLCommercially

Auch interessant die umgekehrte Frage:

http://www.gnu.org/licenses/gpl-faq.html#NoMilitary

Bastian

[Basti]

Zitat von Ben

Morje Basti,
das was du schreibst ist sicherlich richtig. Man kann das alles alleine schreiben.
Aber du wirst doch sicher auch schon die Erfahrung gemacht haben, dass man, wenn man ganz am Anfang steht, relativ schnell Ergebnisse sehen will, da einen sonst die Motivation verlässt.

Wenn man sich dann noch mit dem ganzen Gedöhnse (Controller und Konsorten) befassen muss ... also ich bezweifle einfach, dass das der richtige Weg für jemanden ist, der sein erstes wirkliches Projekt erstellen will.

Demnach sehe ich es als günstiger an, dass man halt erstmal etwas auf Basis von etwas "Fertigem" bastelt und dann, wenn man es für notwendig hält, z.B. weil man an dem verwendeten "Framework" (es kann ja auch einfach 'ne Klassensammlung à la PEAR verwendet werden!) irgendetwas nicht ausreichend für die eigenen Bedürfnisse findet, sich nochmal hinsetzt und etwas Eigenes bastelt.

Das geht dann auch leichter von der Hand, weil man bereits Erfahrung gesammelt hat.

So seh ich das ..

Jo – ich seh das nicht so eng. Wenn die Pläne drei Nummern zu groß sind, dann wird er oder sie das ohnehin in den ersten Wochen merken und hat dennoch einiges dabei gelernt. Auf der anderen Seite hab ich bei noch keinem der vielen, die derartige Anfragen gestartet haben ein freudiges „Oh ja, dann fange ich erstmal klein an oder benutze ein Framework“ gehört.

Außerdem ist das keine so große Sache nach dem von mir vorgeschlagenen Herangehen und führt eben auch gleich zu Ergebnissen. Die Frage ist halt, wie weit du schon abstrahierst oder ob du erstmal ganz pragmatisch rangehst und das Ding dann nach und nach erweiterst und dafür entsprechend umbaust.

Noch einfacher könnte das etwa so aussehen:

PHP-Code:

<?php

// cms.php

error_reporting(E_ALL);

$Request = new Request($_REQUEST);

$sController = 'page';

if (isset($_REQUEST['controller']))
    $sController = $_REQUEST['controller'];

$sAction = 'display';

if (isset($_REQUEST['action']))
    $sAction = $_REQUEST['action'];

if (!isValidIdentifier($sController, $sAction))
    die('bad request');

$sControllerClass = 'Controller_' . $sController;
$sMethod = 'action_' . $sAction;

if (!class_exists($sControllerClass))
    die('bad request');

if (!method_exists($sControllerClass, $sMethod))
    die('bad request');

$Controller = new $sControllerClass;

if (!($Controller instanceof Controller))
    die('bad request');

$Result = $Controller->$sMethod();

if($Result instanceof Redirect) {

    // session_write_close();
    $Result->run();
    die();
}

if($Result instanceof View) {

    $Result->display();
    die();
}

die();

function isValidIdentifier()
{
    $aArgs = func_get_args();
    foreach ($aArgs as $sVar)
        if !preg_match('/^[a-zA-Z][a-zA-Z0-9\-_]$/D', $sVar)
            return false;

    return true;
}

function __autoload($sClassName)
{
    $aParts = explode('_', $sClassName);
    array_pop($aParts);
    $sFileName = '../lib/' . implode('/', $aParts) . '/' . $sClassName . 'php';
    include $sFileName;
}

// lib/Controller/Controller_Page.php

class Controller_Page extends Controller
{
    public function action_display()
    {
        if(!isset($_REQUEST['page']))
            return new Redirect('startseite');

        $sPageName = $_REQUEST['page'];

        $View = new View('page_display');
        $View->set('page', $sPageName);

        return $View;
    }
}

class View
{
    protected $sTemplateId;
    protected $aValues;

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

    public function set($sVar, $mValue)
    {
        $this->aValues[$sVar] = $mValue;
    }

    public function display()
    {
        $sTempateFile = getDir('templates/' . $this->sTemplateId . '.php');

        if (!file_exists($sTemplateFile))
            die('template not exists');

        extract($this->aValues);
        include($sTemplateFile);
    }
}

// templates/page_display.php

echo $sPageName;

Damit hast du schonmal ein ganz simples Grundgerüst. Hab das natürlich jetzt nicht getestet.

Und von da gibts natürlich unzählige Möglichkieten und Herausforderungen: Wie komme ich an die Daten? Kann ich da vielleicht ein bestehendes ORM benutzen oder baue ich mir was selber? Wie kann ich die Fehler gescheit behandeln? Wie escape ich die Werte für die Ausgabe oder nehme ich gleich ein fertiges Template-System? Eine Reuqest-Klasse zu bauen macht Sinn und eben immer so weiter.

Bastian

[Victorious]

Danke schon mal an die vielen guten antworten. Das mit dem Framework ist schon garned mal schlecht hab mir mal nen tutorial zu zend angeschaut.Aber so ganz gefiel mir das dann doch ned, bietet zwar sehr viele dinge, aber das mit dem view usw gefiel mir am meisten dort ned.

Ich denke ich werde doch erstmal ganz klein anfangen und alles selber schreiben bzw so gut wie alles.^^

Eins habe ich noch nicht so ganz verstanden wie das mit dem MVC Prinzip in php geht.Gibt ja dazu schon etliche diskussionen, will nun auch ned das hier auch so aus artet, aber eine frage noch dazu. Meine Template Engine ist mein View richtig? Die Datenbankklasse das Model? Der Controller bzw die Controllers dann die sich die Daten aus der Datenbank holen verarbeiten und dann ans Template weiterleiten, die dann das ganze Ausgiebt?

PS: Alles garned so einfach, wenn man vorher nur so einfache dinge geschrieben hat wie ein und ausgabe und das ganze ohne oop.

[Basti]

Hallo „Victorious“.

Die View-Schicht kannst du sicher erstmal mit deiner Template-Engine plus den Templates gleichsetzen, aber die Modell-Schicht ist mehr als nur die klasse, die den Datenzugriff regelt. Die Modell-schicht repräsentiert deine Daten auch innerhalb der Anwendung und enthält alle Methoden, die Daten zu manipulieren. Die Klasse Page zum Beispiel ist Teil der Datenmodell-Schicht.

Was die Contoller angeht, so bespicken sie im klassischen MVC die „Templates“ nicht mit Daten, sondern reagieren einfach nur auf die Eingaben des Benutzers und veranlassen, dass der Status sowohl der gespeicherten Daten, als auch der Oberfläche geändert wird. Aber die View-Ebene holt sich die Daten selbst aus der Model-Schicht, entweder auf Anweisung der Controller, oder indem es die Daten beobachtet und veränderungen selbst mitbekommt.

Das macht in PHP-Anwendungen aber nicht wirklich Sinn, daher ist es geschickter, du schreibst die Daten direkt aus den Controllern in die Views/Templates.

Bastian

[electonic]

Hallo Leute!
ich hatte mir das bis jetzt immer folgendermaßen gedacht:

Der PHP-Controller wird 'gestartet'.
Er verarbeitet Benutzereingaben und greift auf Funktionen des Models zurück.
Diese wiederum greifen auf die DB zu.
Zum Schluss wählt der Controller eine ihm passende View, übergibt ihr Daten wie die aktuelle Sprache (z.B. 'de' oder 'en') plus sonstige nötige Infos.

Die View greift dann ebenfalls auf die DB zu, holt sich Daten, für die sie programmiert ist, formatiert sie und gibt sie aus.
____________

Eigentlich ganz einfach, auch wenn evtl. ein doppelter DB Zugriff erfolgt.

Ein aktives Beispiel:
Die Views zur Ausgabe eines Forums:

1.View: Übersicht über die Foren
2.View: Threadübersicht
3.View: Threadansicht

[Basti]

Zitat von electonic

Eigentlich ganz einfach, auch wenn evtl. ein doppelter DB Zugriff erfolgt

Genau das ist einer der Punkte, weshalb es in der Regel einfacher ist, die Daten direkt aus dem Controller in die View zu packen. Das kann man natürlich mit einem ORM umgehen, das einfach die beriets gebauten Objekte zurückgibt, anstatt sie nochmal aus den Daten der DB zu bauen.

Ein anderer Punkt ist der, dass du dann entweder außer den Templates noch Objekte brauchst, die die Daten aus der Datenbank (bzw. Modell-Schicht) ziehen oder du musst das direkt aus den Templates machen, was nicht gerade freundlich gegenüber den Template-Designern zu ist.

Und, anstatt da nochmal eine Schicht dazwischen zu setzen, kann man es auch gleich in den Controller packen. Es spricht eigentlich nichts dagegen außer eben, dass in jedem Template nur genau die daten ausgegeben werden können, die vorher an andrer Stelle bereitgetsellt wurden, womit eben immer auch eine Änderung an den Controllern nötig wird, um weitere Daten zur Verfügung zu stellen.

Bastian

[electonic]

Also was die Templates, wohlgemerkt PHP-Templates angeht könnte man das so machen:

Die View (enthält weder Klassen noch Funktionen) wird includiert.
Der Code wird runtergerattert.
Zugriff aufs Model, Formatierung und Ausgabe

Fertig (nach dem Motto: Warum denn ständig OOP? Hier muss es doch gar nicht sein)

Doppelte DB-Qs wären übr. nicht so oft wie man vllt erwartet.
Der Controller muss sich ja nur selten die Daten holen die auch die View braucht.

[Basti]

Zum Thema push- vs. pull-Mechanismus gibts einen Beitrag im WACT-Wiki – allerdings nicht wirklich ergiebig.

Natürlich kannst du auch direkt die (nur lesenden) DB-Queries in deine Templates schreiben, aber das schafft alt eine direkte Abhängigkeit zwischen den Templates und dem Datenbanksystem und der Datenstruktur und die Abfragen sind ja oft nicht gerade trivial und die Aufbereitung auch recht aufwändig – also ziemlich viel Stoff in den Templates. Dazu kommt, dass die Daten ja nicht nur in der Datenbank liegen, sondern auch in Dateien, auf fremden Servern, im Request oder der Session.

Hier würde ich also dazu raten, den ganzen Krempel aus den Templates rauszuhalten und lieber noch eine View-Klasse davorzuschalten, die die Daten für das template ausliest und aufbereitet.

Bastian

[electonic]

Also DB-Querys in der View meinte ich eigentlich nicht.
Ich meinte vielmehr, dass die View klassisch auf die Model-Klasse zugreift und die wiederum aufs DTS/DBS und fremde Server.

Die Frage ich nur, ob man den Code-Teil der View als Klasse schreibt oder prozedural 'runterrattert'.

Prozedural hätte meines Erachtens (kürzt man das mit m.E. ab?) den Vorteil, dass nicht schon wieder eine Klasse bemüht werden muss.
Man kann also wieder ganz entspannt coden und das ist nach so vielen Klassen bestimmt mal nötig.

Oder was sagst du dazu?

[Basti]

Zitat von electonic

Die Frage ich nur, ob man den Code-Teil der View als Klasse schreibt oder prozedural 'runterrattert'.

Prozedural hätte meines Erachtens (kürzt man das mit m.E. ab?) den Vorteil, dass nicht schon wieder eine Klasse bemüht werden muss.
Man kann also wieder ganz entspannt coden und das ist nach so vielen Klassen bestimmt mal nötig.

Oder was sagst du dazu?

Du meinst in etwa die beiden folgenden Alternativen?

PHP-Code:

<?php

class View_Forum_DisplayThread extends View
{
    protected $Thread;

    public function display()
    {
        $this->Thread = $this->Persistence->getManager('Forum')->getThread($this->Request->get('thread_id'), $this->Request->get('start'), $this->Config->get('Forum', 'threads_per_page'));
    }
}

oder

$Thread = Persistence::getManager('Forum')->getThread(Request::get('thread_id'), Request::get('start'), Config::get('Forum', 'threads_per_page'));

Entspannter finde ich es, den Code in eine Klasse zu schreiben, da ich hier ganz klar hab, welche Werte ich setze (hier ausschließlich View_Forum_DisplayThread::$Thread) und auf welche Werte ich zugreifen kann (View::$Persistence, View::$Request und View::$Config).

Im anderen Fall erbst du halt immer noch was aus dem einbindenen Skript und hinterlässt eben auch Spuren. Letztlich müsstest du den Code, diese Datei einzubinden auch wieder in eine separate Funktion schreiben, aber wie kommst du dann an die Wete ran? Müsstest also ein spezielles Array dafür bereitstellen.

So hab ich das in meinem ersten „echten“ Auftrag gemacht, als ich noch nie irgendwas von MVC, Templates oder sonstwas gehört hatte. Jede „action“ hatte eine Datei und hat am Ende eine Variable mit dem Namen des „Templates“ gefüllt und eine Variable mit den Daten, die da reinkamen.

Geht natürlich, aber ich würde hier schon ganz entspannt die Vorteile von OOP nutzen.

Bastian

[Victorious]

hi so ich hab mich mal bissel versucht. Es ist auch etwas bei raus gekommen, zwar noch nicht viel, aber immerhin etwas. Bisher steht ein Grundgerüst, bzw wenn man das so nen kann, soll eigentlich nur der versuch sein das MVC Prinzip umzusetzen. Würd nun gerne von euch hören was da gut ist und was nicht, was ich besser machen kann/sollte usw, bevor ich weiter mache.

So sieht der code aus.

index.php

PHP-Code:

<?php
include("template.php");
include("mySQL.php");


error_reporting(E_ALL);



$sController = 'index';

if (isset($_REQUEST['controller'])){
    $sController = $_REQUEST['controller'];
}


$sAction = 'display';

if (isset($_REQUEST['action'])){
    $sAction = $_REQUEST['action'];
}


if (!isValidIdentifier($sController, $sAction)){
    die('bad request');
}


$sControllerClass = 'Controller_' . $sController;
$sMethod = 'action_' . $sAction;
$sModelClass = 'Model_'. $sController;

if (!class_exists($sControllerClass)){
    die('bad request');
}


if (!class_exists($sModelClass)){
    die('bad request');
}


if (!method_exists($sControllerClass, $sMethod)){
    die('bad request');
}


$Controller = new $sControllerClass;

if (!($Controller instanceof Controller)){
    die('bad request');
}


$Result = $Controller->display($Controller,$sMethod);


if($Result instanceof Template) {

    $Result->out();
    die();
}



function isValidIdentifier() {
    $aArgs = func_get_args();
    foreach ($aArgs as $sVar)
     
    if (preg_match('/^[a-zA-Z][a-zA-Z0-9\-_]$/D', $sVar)){
        return false;
    }
    
    return true;
}

function __autoload($sClassName) {

    $sControllerName =  $sClassName . '.php';
    include $sControllerName;
    
}

controller.php

PHP-Code:

<?php
class Controller {

    public function display($className,$sMethod) {
        
        $tpl = new Template();
        
        $tpl->load("index.tpl");
        
        $tpl->cache("index",3700,false);
        
        $tpl->assign("content", $className->$sMethod());
        
        return $tpl;
    }
}

controller_index.php

PHP-Code:

<?php

class Controller_index extends Controller {
    
    public function action_display() {
    
        $pageName = $_REQUEST['controller'];
            
        $tpl = new Template();