SilverStripe · Steven Broschart, Ingo Schommer SilverStripe 1295.book Seite 1 Mittwoch, 4. Februar...

Steven Broschart, Ingo Schommer

SilverStripe

1295.book Seite 1 Mittwoch, 4. Februar 2009 12:33 12

Auf einen Blick

1 Einführung .......................................................................... 29

2 Einrichtung ......................................................................... 39

3 Architektur .......................................................................... 61

4 Erste Schritte ...................................................................... 101

5 Entwicklung: Stellenangebote ............................................ 145

6 CRM-Erweiterung ............................................................... 209

7 Sicherheit ............................................................................ 275

8 Betriebssicherung ............................................................... 289

9 Testing ................................................................................ 311

10 Lokalisierung ...................................................................... 327

11 Rezepte ............................................................................... 341

12 Erweitern ............................................................................ 395

A Weitere Module ................................................................. 417

B Inhalt der CD ...................................................................... 431


5

Inhalt

Geleitwort von Sigurd Magnusson ................................................................ 17Vorwort ........................................................................................................ 21

1 Einführung ................................................................................ 29

1.1 Warum SilverStripe? .................................................................... 291.1.1 Klare Trennung der Strukturen ........................................ 301.1.2 Benutzerfreundliches Backend ......................................... 331.1.3 Flexibles Management von Inhalten ................................ 331.1.4 Volle Kontrolle über die Ausgabe .................................... 341.1.5 Erweiterbarkeit und Modularität ..................................... 34

1.2 Entwickler und Entwicklung ......................................................... 341.3 Historie ........................................................................................ 361.4 Ausblick ....................................................................................... 371.5 Zusammenfassung ........................................................................ 38

2 Einrichtung ............................................................................... 39

2.1 Systemvoraussetzungen ............................................................... 392.2 Vorbereitung ............................................................................... 40

2.2.1 SilverStripe-Download .................................................... 412.2.2 Webserver als Komplettpaket ......................................... 412.2.3 Webserver aus Einzelkomponenten ................................. 41

2.3 Installation .................................................................................. 432.3.1 Windows: WAMP-Installation ......................................... 432.3.2 Mac OS X: MAMP-Installation ........................................ 462.3.3 Webhosting und Webinstaller ......................................... 48

2.4 Entwicklungsumgebungen ........................................................... 522.4.1 Eclipse ............................................................................ 532.4.2 Aptana ............................................................................ 542.4.3 NetBeans ........................................................................ 56

2.5 Datenbankverwaltung .................................................................. 572.5.1 phpMyAdmin .................................................................. 572.5.2 MySQLDumper ............................................................... 572.5.3 Kommandozeile .............................................................. 57

2.6 Support ....................................................................................... 582.6.1 Forum ............................................................................. 58


Inhalt

6

2.6.2 IRC-Chat ......................................................................... 582.6.3 Fehler melden ................................................................. 59

2.7 Zusammenfassung ........................................................................ 59

3 Architektur ............................................................................... 61

3.1 Einleitung .................................................................................... 613.2 MVC – Model View Controller ..................................................... 62

3.2.1 Grundsätzliches ............................................................... 623.2.2 Umsetzung in SilverStripe ................................................ 64

3.3 ORM – Object Relational Mapping .............................................. 713.3.1 Mapping-Konventionen .................................................. 723.3.2 Definition ........................................................................ 723.3.3 Zugriff ............................................................................. 733.3.4 Relationen ...................................................................... 733.3.5 Datenbankstruktur .......................................................... 78

3.4 Ordnerstruktur ............................................................................ 793.4.1 Mysite ............................................................................. 793.4.2 Themes ........................................................................... 793.4.3 Assets ............................................................................. 803.4.4 Cms ................................................................................ 803.4.5 Sapphire ......................................................................... 803.4.6 Jsparty ............................................................................ 803.4.7 Weitere Ordner ............................................................... 81

3.5 Module und Widgets ................................................................... 813.5.1 Unterscheidungsmerkmale .............................................. 813.5.2 Installation ...................................................................... 823.5.3 Deinstallation .................................................................. 82

3.6 Themes ........................................................................................ 833.7 System-Architektur ...................................................................... 84

3.7.1 Dispatcher ...................................................................... 843.7.2 Sapphire ......................................................................... 853.7.3 Backend .......................................................................... 90

3.8 Konfiguration .............................................................................. 933.8.1 _config.php ..................................................................... 943.8.2 Betriebsarten ................................................................... 953.8.3 Environments .................................................................. 97



Inhalt

7

4 Erste Schritte ........................................................................... 101

4.1 Unser Projekt: Usergroup mit Jobbörse ........................................ 1014.2 Seitenstruktur anlegen ................................................................. 103

4.2.1 Das CMS-Interface .......................................................... 1044.2.2 Erste Änderungen ........................................................... 1064.2.3 Neue Seiten erstellen ...................................................... 1094.2.4 Entwurf und Veröffentlichung ......................................... 1104.2.5 Drag & Drop ................................................................... 111

4.3 Seiteninhalt einfügen ................................................................... 1134.3.1 Einbinden von Text ......................................................... 1144.3.2 Verlinkungen .................................................................. 1174.3.3 HTML-Ansicht ................................................................. 119

4.4 Verwaltung von Dateien und Bildern ........................................... 1204.4.1 Dateien ansehen und editieren ........................................ 1214.4.2 Hochladen von Dateien ................................................... 1234.4.3 Einfügen eines Bildes in den Inhalt .................................. 126

4.5 Versionierung .............................................................................. 1284.6 Kommentarfunktion .................................................................... 130

4.6.1 Formular auf der Webseite .............................................. 1314.6.2 Moderation im CMS ........................................................ 132

4.7 Einfaches Kontaktformular ........................................................... 1334.7.1 Modul »userforms« installieren ........................................ 1334.7.2 Verfügbare Felder ........................................................... 1344.7.3 Formular zusammenstellen .............................................. 136

4.8 Neue Benutzer anlegen ................................................................ 1374.8.1 Rollenbasierte Rechtevergabe ......................................... 1384.8.2 Gruppen und Benutzer im CMS ....................................... 1384.8.3 Berechtigungen ............................................................... 139

4.9 Themes ........................................................................................ 1414.9.1 Unser eigenes Theme »mysite« ........................................ 1414.9.2 Seitentitel im Template verändern ................................... 1424.9.3 Änderungen am Stylesheet .............................................. 142


5 Entwicklung: Stellenangebote ................................................. 145

5.1 Jobkategorie als eigener Seitentyp ............................................... 1455.2 Job als DataObject ....................................................................... 1505.3 Relationen zwischen DataObjects ................................................ 153

5.3.1 Mehrere Stellenangebote als has_many ........................... 154


Inhalt

8

5.3.2 Benachrichtigungen als many_many ................................ 1555.3.3 Relationen über ComponentSet ....................................... 156

5.4 Definition des Interfaces .............................................................. 1575.4.1 Auflistung von Datensätzen ............................................. 1575.4.2 Detailansicht im eigenen Fenster ..................................... 1615.4.3 Verknüpfung von Übersicht und Detailansicht ................. 1635.4.4 Aktualisierung der Datenbankstruktur ............................. 1645.4.5 Erste Datensätze ............................................................. 165

5.5 Templates erstellen ...................................................................... 1655.5.1 Grundlagen ..................................................................... 1655.5.2 Platzhalter ....................................................................... 1675.5.3 Bedingte Anweisungen .................................................... 1705.5.4 Blöcke und Schleifen ....................................................... 1725.5.5 Menüblöcke .................................................................... 1765.5.6 Wiederverwendung über Includes ................................... 1775.5.7 Templates für Jobkategorien ........................................... 1785.5.8 Login-Funktionalität im Menü ......................................... 181

5.6 Eigene Formulare ......................................................................... 1825.6.1 Controller vorbereiten ..................................................... 1835.6.2 Template vorbereiten ...................................................... 1875.6.3 Speichern des Autors ...................................................... 188

5.7 E-Mail-Benachrichtigung ............................................................. 1905.7.1 Benachrichtigungen als Relation ...................................... 1915.7.2 Aktivierung der Benachrichtigung .................................... 1925.7.3 Versand der E-Mail ......................................................... 194

5.8 Integration des Blog-Moduls ........................................................ 1975.9 Suchmaschinenoptimierung ......................................................... 199

5.9.1 Seiteninhalt ..................................................................... 2025.9.2 Tabellenlose Templates ................................................... 2035.9.3 Valider Code ................................................................... 2045.9.4 Metatags ......................................................................... 2045.9.5 URL-Format und Links .................................................... 2055.9.6 Google Sitemap ............................................................... 2055.9.7 Offsite-Optimierung ........................................................ 206


6 CRM-Erweiterung .................................................................... 209

6.1 Wo wollen wir hin? ..................................................................... 2106.1.1 Profilverwaltung im Frontend .......................................... 2106.1.2 Profilverwaltung im Backend ........................................... 210


Inhalt

9

6.2 Datenmodell ................................................................................ 2116.2.1 Entwickler ....................................................................... 2116.2.2 Fähigkeiten ..................................................................... 2136.2.3 Referenzen ...................................................................... 2146.2.4 Übersicht der Datenbankänderungen .............................. 215

6.3 Verwaltung mit ModelAdmin ...................................................... 2176.3.1 Eigene Unterklasse: CommunityAdmin ............................ 2186.3.2 Menüeintrag und URL-Routing ....................................... 2196.3.3 Aufruf des neuen Backends ............................................. 2206.3.4 Lokalisierte Formularfelder .............................................. 222

6.4 Mehrseitiges Registrierungsformular ............................................ 2256.4.1 Seite 1: Benutzerdetails ................................................... 2256.4.2 Seite 2: Referenzen ......................................................... 2276.4.3 Das Multiform-Modul ..................................................... 2286.4.4 RegistrationMultiForm .................................................... 2286.4.5 RegistrationDetailsStep ................................................... 2296.4.6 RegistrationReferenceStep .............................................. 2316.4.7 Einbindung in RegistrationPage ....................................... 2326.4.8 Feintuning der Formularfelder ......................................... 2336.4.9 Speichern aller Formulareingaben ................................... 236

6.5 Fähigkeiten als Tags ..................................................................... 2386.6 Datei-Upload für Referenzen ....................................................... 240

6.6.1 Datei als has_one-Relation .............................................. 2416.6.2 Upload über ein Formularfeld ......................................... 2416.6.3 Bildmanipulation und Thumbnails ................................... 2436.6.4 Grafikoperationen für Bildobjekte ................................... 245

6.7 Suche in DataObjects ................................................................... 2466.7.1 Definition der durchsuchbaren Attribute ......................... 2476.7.2 Eigenes Suchverhalten über SearchFilter .......................... 2486.7.3 Dropdown-Suche nach Region ........................................ 250

6.8 Generische Views über CollectionController ................................ 2526.8.1 Das Genericviews-Modul ................................................ 2536.8.2 CollectionPage für Entwickler .......................................... 2536.8.3 CollectionPage für Referenzen ......................................... 2576.8.4 Anpassen der Detailansicht ............................................. 2586.8.5 Anpassung des Formulars ................................................ 259

6.9 Zugriffsberechtigungen definieren ................................................ 2616.9.1 Methoden in DataObject ................................................ 2616.9.2 Sichere Jobs .................................................................... 2636.9.3 Eigene Permission-Codes ................................................ 264


Inhalt

10

6.10 Webservice über RESTfulServer .................................................... 2656.10.1 REST-Architektur ............................................................. 2666.10.2 Öffnen der Objekte ......................................................... 2686.10.3 Lesezugriff ....................................................................... 269


7 Sicherheit ................................................................................. 275

7.1 Cross-Site Scripting (XSS) ............................................................. 2757.1.1 Feldtypen ........................................................................ 2767.1.2 Escape-Typen .................................................................. 2767.1.3 BBCode ........................................................................... 278

7.2 Cross-Site Request Forgery (CSRF) ............................................... 2797.3 SQL Injection ............................................................................... 280

7.3.1 Validierung ..................................................................... 2817.3.2 Automatische Maskierung ............................................... 2817.3.3 Manuelle Maskierung ...................................................... 2827.3.4 Casting in PHP ................................................................ 282

7.4 Directory Traversal ....................................................................... 2837.4.1 Zugriffsrechte .................................................................. 2837.4.2 Einschränkung nutzbarer Dateitypen ............................... 2847.4.3 Filtern von Dateipfaden ................................................... 2847.4.4 Deaktivieren von PHP in Unterordnern ........................... 285

7.5 Sessions ....................................................................................... 2867.5.1 Session Hijacking ............................................................. 2867.5.2 Session Fixation .............................................................. 287


8 Betriebssicherung .................................................................... 289

8.1 Versionskontrolle mit Subversion ................................................. 2898.1.1 Konzeption ..................................................................... 2908.1.2 Terminologien ................................................................. 2908.1.3 Software ......................................................................... 2908.1.4 Das SilverStripe-Repository ............................................. 2918.1.5 Subversion unter Eclipse ................................................. 2928.1.6 Subversion unter Netbeans ............................................. 293

8.2 Backup ........................................................................................ 2948.2.1 Datenbank ...................................................................... 2948.2.2 Dateisystem .................................................................... 297


Inhalt

11

8.3 Upgrade ...................................................................................... 2978.4 Fehlerbehandlung ........................................................................ 299

8.4.1 Apache ........................................................................... 2998.4.2 PHP ................................................................................ 3008.4.3 Logging in SilverStripe ..................................................... 3008.4.4 Eigene Fehlerseiten ......................................................... 302

8.5 Performance ................................................................................ 3038.5.1 Bytecode Caches ............................................................. 3048.5.2 Komprimierung von JavaScript und CSS .......................... 3048.5.3 Generierung statischer Seiten .......................................... 308


9 Testing ...................................................................................... 311

9.1 Test-Driven Development ............................................................ 3129.2 Installation von PHPUnit .............................................................. 3139.3 Ausführung von Tests .................................................................. 314

9.3.1 Web-Interface ................................................................. 3149.3.2 Kommandozeile .............................................................. 315

9.4 Unit-Tests des Modells ................................................................ 3169.4.1 Einfache Annahmen ........................................................ 3169.4.2 Testdaten mit Fixtures ..................................................... 319

9.5 Functional Testing des Controllers ............................................... 3219.5.1 Templateausgaben überprüfen ........................................ 3229.5.2 Ein Testformular absenden .............................................. 324


10 Lokalisierung ............................................................................ 327

10.1 Zeichensätze und Unicode ........................................................... 32710.1.1 ISO 8859 ........................................................................ 32810.1.2 Unicode .......................................................................... 329

10.2 Übersetzung in Templates und Code ............................................ 33010.2.1 Konfiguration .................................................................. 33010.2.2 Die _t()-Funktion ............................................................ 33110.2.3 Übersetzung in PHP-Code ............................................... 33310.2.4 Übersetzung in Templates ............................................... 33310.2.5 Übersetzung in JavaScript ................................................ 33310.2.6 Sprachtabellen mit i18nTextCollector .............................. 334

10.3 Translatable: Übersetzung von Seiteninhalten .............................. 33510.3.1 Konfiguration .................................................................. 336


Inhalt

12

10.3.2 Benutzung ....................................................................... 33610.3.3 Selbst definierte Attribute ............................................... 337

10.4 Sprachwahl .................................................................................. 33810.5 Zusammenfassung ........................................................................ 339

11 Rezepte ..................................................................................... 341

11.1 Voraussetzungen ......................................................................... 34111.2 Seitenspezifische Banner .............................................................. 341

11.2.1 Eine neue Relation BannerImage ..................................... 34211.2.2 Skalieren von Image-Objekten ........................................ 34311.2.3 Vererbung der Banner im Seitenbaum ............................. 34411.2.4 Einbindung ins Template ................................................. 344

11.3 Branding des CMS-Interfaces ....................................................... 34511.3.1 Name und Logo .............................................................. 34611.3.2 Ladebildschirm ................................................................ 34611.3.3 Farben und Schrift über Stylesheets ................................. 347

11.4 Volltextsuche für Webseiten ........................................................ 34811.4.1 Formular einrichten ......................................................... 34911.4.2 Sammeln der Suchergebnisse .......................................... 35011.4.3 Ausgabe der Suchergebnisse ........................................... 35211.4.4 Paginierung der Suchergebnisse ...................................... 353

11.5 Weiterleitung alter URLs .............................................................. 35411.5.1 Das neue Attribut »LegacyURL« ....................................... 35511.5.2 Unterklasse für ModelAsController .................................. 35611.5.3 Überschreiben des Routing-Systems ................................ 35711.5.4 Vermeiden von URL-Konflikten ....................................... 357

11.6 Einfache Statistiken mit TableListField ......................................... 35811.6.1 Referrer-Objekte mit Page verknüpfen ............................ 35911.6.2 Tracking beim Seitenaufruf .............................................. 36011.6.3 Auswertung über TableListField ...................................... 362

11.7 Kontextnavigation ....................................................................... 36611.7.1 Vorbereitung ................................................................... 36711.7.2 Datenmodell ................................................................... 36711.7.3 CMS-Eingabemaske ......................................................... 36811.7.4 Finden der Geschwister- und Elternseiten ....................... 37011.7.5 Ausgabe im Template ...................................................... 37111.7.6 Finden von Seiten nach Stichworten ................................ 37211.7.7 Finden von Seiten nach Tags ........................................... 37311.7.8 Finden nach Suchmaschinen-Referrer .............................. 37411.7.9 Sammeln aller Kriterien ................................................... 374


Inhalt

13

11.8 CSV-Import über CSVBulkLoader ................................................. 37511.8.1 Datenmodell ................................................................... 37611.8.2 Einfaches Administrations-Interface ................................. 37711.8.3 Implementierung des Importers ...................................... 378

11.9 Flash Integration über XML ......................................................... 38111.9.1 Zielsetzung ...................................................................... 38111.9.2 Seitenbaum als XML ....................................................... 38211.9.3 Seitenbaum in Flash ........................................................ 38511.9.4 Inhalt als XML ................................................................. 38811.9.5 Inhalt in Flash ................................................................. 38911.9.6 CSS-Stylesheets in Flash .................................................. 39111.9.7 Einbinden in SilverStripe-Templates ................................ 39211.9.8 Zusammenfassung ........................................................... 394

12 Erweitern .................................................................................. 395

12.1 Anwendungsbereiche .................................................................. 39612.2 Kernfunktionalität erweitern ........................................................ 396

12.2.1 Vererbung ....................................................................... 39612.2.2 Decorator Pattern ........................................................... 39812.2.3 Statische Variablen in SilverStripe .................................... 40212.2.4 Callbacks und Hooks ....................................................... 404

12.3 Eigenes Modul erstellen ............................................................... 40412.3.1 Modul-Definition ............................................................ 40512.3.2 Anpassung ...................................................................... 406

12.4 Eigenes Widget erstellen .............................................................. 40712.4.1 Widget-Vorbereitungen .................................................. 40812.4.2 Eigentliche Widget-Implementierung .............................. 410


Anhang ........................................................................................... 415

A Weitere Module ..................................................................................... 417B Inhalt der CD .......................................................................................... 431

Index ............................................................................................................ 433


29

»Ich kann dir nur die Tür zeigen. Hindurchgehen musst du alleine.« (Matrix)

1 Einführung

Open-Source-basierte Software-Projekte gelten schon lange nicht mehr als Spiel-wiese gelangweilter Hobby-Programmierer, sondern sind fester Bestandteil vielerIT-Strukturen und kommerzieller, professioneller Services.

So haben sich gerade in den letzten Jahren viele auf Content-Management-Sys-teme spezialisierte Agenturen entwickelt, die Open-Source für sich als Verkaufs-argument entdeckt haben. Das breite Serviceangebot und die damit einherge-hende Werbepräsenz sorgten schließlich auch für ein Umdenken in denChefetagen großer Unternehmen, sodass sich Open-Source-Lösungen auch zurRealisierung von Internetauftritten auf Enterprise-Ebene etablieren konnten.

Open-Source Content-Management-Systeme sind also heute mehr denn je einheißes Thema für Agenturen und deren Zielgruppe.

Die meisten Entwickler haben jedoch ihre persönlich favorisierten Systeme, diesie zur Bewältigung der alltäglichen Aufgaben nutzen. Warum sollte man sich alsomit einem neuen System auseinandersetzen? Genau dieser Frage werden wir indiesem Kapitel nachgehen.

1.1 Warum SilverStripe?

Um eins vorweg zu nehmen: SilverStripe ist nicht die Antwort auf alle Probleme,die im Alltag eines Web-Programmierers auftreten können. Es lassen sich sicher-lich viele Aufgabenstellungen auch mit anderen Techniken und Systemen lösen.Jedoch können typische, immer wiederkehrende Probleme mit SilverStripe we-sentlich einfacher angegangen werden, da man als Programmierer hier nun aufein ausgefeiltes Framework zurückgreifen kann und mit diesem das Rad nicht fürjede Applikation neu erfinden muss.

Für eine weitere Evaluierung sehen wir uns genauer an, was SilverStripe ist, wases zu leisten vermag und ob beziehungsweise wie es diesen Leistungsanforderun-


30

Einführung1

gen gerecht werden kann. Im Folgenden erhalten Sie also – ohne sich hier in tech-nische Details zu verstricken – einen kurzen Überblick über die Vorzüge des Sys-tems.

1.1.1 Klare Trennung der Strukturen

Wie bereits angedeutet ist SilverStripe eine sehr gut aufeinander abgestimmteSymbiose von Content-Management-System und einem Framework namens sap-phire. Durch die Strukturierung in verschiedene Einheiten (siehe Kasten »ModelView Controller als zentrales Konzept«) ist im Vergleich zu vielen anderen Syste-men eine saubere Trennung zwischen inhaltlichen Strukturen und Business-Logikgewährleistet. Auszugebende Inhalte können dem Framework aus verschiedenenQuellen zugänglich gemacht werden (beispielsweise aus eigenen Erweiterungenoder dem Content-Management-System).

Wenn wir im Folgenden von CMS-Funktionalitäten sprechen, sind damit die Be-reiche des Systems gemeint, über die sich Inhalte eingeben und verwalten lassen– im Prinzip also das komplette Backend, das sich dem Redakteur nach dem Login

Model View Controller als zentrales Konzept

Das MVC-Konzept gehört zu den sogenannten Design-Patterns (engl. für Entwurfsmusteroder Architekturmuster) und beschreibt eine strukturierte Vorgehensweise, geläufigenAufgabenstellungen systematisch zu begegnen. Da es sich bei MVC um eine wichtigestrukturelle Eigenschaft bei SilverStripe handelt, haben wir diesem Thema ein gesonder-tes Kapitel in diesem Buch gewidmet. Zum besseren Verständnis möchten wir Ihnen dieKerneigenschaften schon einmal nennen:

MVC steht für Model, View und Controller und beschreibt damit die einzelnen Einheiten,in die eine Applikation aufgeteilt wird.

� Die Model-Einheit ist für alles verantwortlich, was mit dem direkten Zugriff derDatenbank zu tun hat.

� Die Controller-Einheit beinhaltet die eigentliche Programmlogik und kann bei BedarfDaten von der Model-Schicht anfordern, speichern oder an die View-Einheit weiter-leiten.

� Die View-Einheit erhält ihre Daten vom Controller und kümmert sich schließlich umderen Ausgabe.

Alle drei Einheiten arbeiten in einer Applikation eng zusammen. Ein expliziter Daten-austausch ist nicht erforderlich, denn die Daten stehen ohne Umwege direkt in den an-deren MVC-Einheiten zur weiteren Bearbeitung zur Verfügung.

Sollte sich das für Sie an dieser Stelle noch zu abstrakt anhören, dann machen Sie sichbitte (noch) keine allzu großen Sorgen. Sie sollten im ersten Schritt nur grob wissen,worum es sich beim MVC-Entwurfsmuster handelt. Alles weitere klären wir noch aus-führlich an anderer Stelle.


31

Warum SilverStripe? 1.1

eröffnet. Das sapphire-Framework besitzt kein direktes Backend, sondern ist nurder Unterbau für CMS und eigene Applikationen.

Was sich zunächst nach einer doch etwas umständlichen Art und Weise der Auf-teilung anhört, erweist sich in der späteren Praxis jedoch als enormes Plus.

Diese sauber von einander getrennten Bereiche sorgen für Ordnung bei der Ver-gabe von Rechten und Rollen sowie für einen eindeutig definierten Datenfluss.Der Entwickler kann dem Redakteur so beispielsweise über entsprechende Code-Implementierungen angepasste oder ganz neue Eingabemasken zur Verfügungstellen, über welche die Inhalte für die spätere Ausgabe verwaltet werden kön-nen.

Der Entwickler hat natürlich nicht nur Einflussmöglichkeiten auf das Backend,sondern kann ebenso einfach Benutzereingaben validieren lassen beziehungs-weise auf diese in irgendeiner Art reagieren.

Abbildung 1.1 SilverStripe-Grundstruktur

Ein ganz besonderes SilverStripe-Feature ist die elegante Unterstützung zur Ab-bildung und Verwaltung relationaler Datenstrukturen über das Object RelationalMapping (ORM), welches wir in Abschnitt 3.3, »ORM«, noch näher beschreiben.Ein paar Zeilen Code genügen, um später die Daten neuer Tabellen über das Back-end verwalten zu können und eine entsprechende Ausgabe für das Frontend vor-zubereiten. Außerdem lassen sich mit dem Framework hervorragend ein- undmehrseitige Formulare komfortabel erstellen und verwalten – eine Fähigkeit, diebisher kaum ein anderes System anbieten kann.

MVC-Framework CMS/Backend Ausgabe/FrontendEntwickler Redakteur Nutzer

Nutzer-Interaktion


32

Einführung1

Das Zusammenspiel von CMS-Funktionalitäten und MVC-Framework scheint ge-lungen. Damit die Freude nicht getrübt wird, sind bei SilverStripe wirklich nursehr wenig zu konfigurierende Parameter notwendig. Das System folgt auch hiereinem aus anderen modernen Frameworks bekannten Grundsatz: Konvention vorKonfiguration. SilverStripe geht dabei von vordefinierten Annahmen aus. Nurwenn man von diesen Annahmen abweichen möchte, ist zusätzlicher Code ein-zubinden.

Dieses Konzept macht sich wie bereits angesprochen auch im Backend bemerk-bar: Denn anders als bei vielen anderen Systemen, findet man nach dem Einlog-gen nur sehr wenige Bereiche mit Optionen oder Konfigurationsparametern.Keine Angst, denn wie Sie später noch sehen werden, ergeben sich für die Ent-wicklung dadurch keine Nachteile.

In diesem Zusammenhang sollten wir unbedingt auf das Stichwort Agile Software-entwicklung eingehen: Durch den geringen Konfigurationsaufwand und flexibleEntwicklungsmöglichkeiten passt SilverStripe gut in eine Umgebung, in der Ent-wickler und Projektmanager schnell und effizient auf Kundenwünsche eingehenwollen (siehe Kasten »Agile Softwareentwicklung«).

Agile Softwareentwicklung

Unter dem Namen der Agilen Softwareentwicklung bündeln sich die Bemühungen, auchnach Abschluss der Planungsphase als Entwickler »wendig« genug auf sich ändernde An-forderungen eingehen und diese zeitnah umsetzen zu können. Das Prinzip der agilenEntwicklung bezieht dabei sogar sich ständig ändernde Zielvorgaben mit ein und zielt soauf ein im Dialog mit dem Kunden entstehendes Endprodukt.

Dieser Ansatz der Entwicklung scheint logisch und überfällig, gab es erste Überlegungenhierzu doch bereits Anfang der neunziger Jahre. Die Ausgestaltung am »lebenden Ob-jekt« für praxistaugliche Prozesse ergänzt somit eine detaillierte Vorplanung, an die mansich ohnehin nur in den seltensten Fällen in vollem Umfang halten kann. Bildlich gespro-chen lässt sich anhand einer Bauzeichnung auch nur schwer bestimmen, ob das Bild derLiebsten an der zu bauenden Wand schön in Szene gesetzt werden kann. Möglicher-weise hatte man ja den Lichteinfall nicht einberechnet?

Eigentlich definiert sich die agile Softwareentwicklung über Werte, Prinzipien und Me-thoden. Die Werte definieren dabei die Prinzipien, aus denen sich dann technische Ein-zelmethoden ableiten. Der sogenannte agile Prozess beschreibt letztendlich den eigent-lichen Entwicklungsprozess unter Zuhilfenahme überwiegend agiler Methoden.

In der Praxis und insbesondere im Bereich der Web-Entwicklung wird von Agilitätimmer dann gesprochen, wenn ein System einfache, nachträgliche Strukturänderungenunterstützt.

Weitere Informationen zu diesem Thema finden Sie unter http://agilemanifesto.org undhttp://agilealliance.org.


33

Warum SilverStripe? 1.1

Zu guter Letzt sollten wir für eine erste Bewertung noch die technischen Voraus-setzungen betrachten: Auf welchem Server sollte SilverStripe betrieben werden?Bei der Auswahl eines geeigneten Providers dürfte es keine Probleme geben. Al-lerdings sollten Sie bei der Verwendung von Shared-Hosting-Paketen darauf ach-ten, hier nicht das kleinste Paket zu wählen und mindestens 48 MB Ram zugesi-chert zu bekommen.

Letzten Endes hängt die Wahl des Providers aber vom eigentlichen Einsatzzweckab. Mit SilverStripe lassen sich sicherlich auch sehr große und komplexe Webprä-senzen erstellen, die dann schon etwas mehr Rechenleistung und Speicher fürsich in Anspruch nehmen können.

1.1.2 Benutzerfreundliches Backend

Der Redakteur hat über das Backend Zugriff auf alle Funktionen zur Verwaltungvon Inhalten. Eines der zentralen Elemente ist hier der eben erwähnte Seiten-baum, über den sich die Hierarchie der angelegten Webseiten verwalten lässt.

Im Vergleich zu anderen Systemen präsentiert sich das Interface sehr aufgeräumtund unterstützt damit eine wirklich intuitive Benutzung ohne lange Einarbeitung.Wie sich bereits in der Praxis bewiesen hat, gehören langwierige Schulungendamit endlich der Vergangenheit an.

Für das Backend setzt SilverStripe stark auf JavaScript und AJAX, um gewisse Be-reiche neu zu laden, ohne das komplette Backend neu anzufordern. So kann zumBeispiel der Seitenbaum über Drag & Drop umsortiert werden, wobei Änderun-gen direkt ohne erneutes Laden sichtbar werden.

Bilder und Dokumente lassen sich ebenfalls einfach und sauber über einen geson-derten Bereich im Backend verwalten.

Vorbildlich gelöst: Das Backend kann dank des konsistenten Einsatzes von CSS aneigene Bedürfnisse angepasst werden.

1.1.3 Flexibles Management von Inhalten

SilverStripe bietet ein einfaches Staging-System an. Jede Änderung einer Seitewird zunächst als Entwurf gespeichert, der nur für angemeldete CMS-Benutzerzur Voransicht verfügbar ist. Erst ein explizites Publizieren dieses Entwurfesbringt die Änderung wirklich auf die öffentliche Webseite.

Zur Wiederherstellung alter Speicherstände bietet das System für jede Seite undihre Inhalte eine Versionierung an. Einzelne Änderungen können somit nachvoll-zogen, verglichen und gezielt rückgängig gemacht werden.


34

Einführung1

1.1.4 Volle Kontrolle über die Ausgabe

SilverStripe stellt innerhalb des sapphire-Frameworks eine eigene Template-En-gine bereit, die für eine einfache Ausgabe beliebiger Daten aus dem Innerensorgt. Die Template-Engine übernimmt im Rahmen des MVC-Architekturmustersdie Ausgabe für die View-Einheit.

Das System lässt dem Entwickler alle notwendigen Freiheiten zur Ausgestaltungdes Codes, sodass die Form der HTML-Ausgabe zu 100 % kontrollierbar wird.Eine Aufbereitung für spezielle Anforderungen, wie beispielsweise Suchmaschi-nenoptimierung oder XHTML-Validität, ist also kein Problem.

Wie auch schon aus anderen Systemen bekannt, unterstützt SilverStripe zur Steu-erung der Ausgabe die Verwendung von schachtelbaren Bedingungen und Schlei-fenkonstrukten.

Auf der SilverStripe-Webseite finden sich bereits viele vorgefertigte Layouts inForm von Themes, die sich ganz einfach installieren und für eigene Zwecke nutzenlassen (siehe http://silverstripe.org/themes).

Über die Template-Engine und die gerade eben beschriebenen Möglichkeiten las-sen sich zudem automatisch generierte Menüs in die Seite einbinden, die Silver-Stripe auf Basis des im Backend zusammengestellten Seitenbaumes erstellenkann. Die Ausgabe des Menüs und der einzelnen Einträge lässt sich nach Beliebenkonfigurieren.

1.1.5 Erweiterbarkeit und Modularität

SilverStripe ist sehr modular aufgebaut und kann deshalb über vom Kern unab-hängige Komponenten, die Module, erweitert werden. Genau genommen ist dasCMS selbst ein eigenes Modul. Unter http://silverstripe.org/modules finden Sie be-reits eine Menge an vorgefertigten und sehr nützlichen Modulen.

Ähnlich wie Module sind Widgets bei SilverStripe kleinere, gekapselte Funktions-bereiche, deren Platzierung für die Ausgabe im Backend über einfaches Drag &Drop erfolgt. Über Widgets lässt sich beispielsweise die Anzeige zu neuestenKommentaren im Blog-Modul steuern.

1.2 Entwickler und Entwicklung

Natürlich ist auch die Garantie auf konsequente Weiterentwicklung und Anpas-sung an praxisorientierte Anforderungen ein wichtiges Entscheidungskriterium


35

Entwickler und Entwicklung 1.2

für ein neues System. Keine Agentur kann sich beispielsweise leisten, Sicherheits-risiken aufgrund ausbleibender Updates einzugehen. Um so besser, dass die Ent-wicklung von SilverStripe durch eine solide Entwicklungsstruktur gesichert wird.

SilverStripe unterliegt als Open-Source-Softwareprodukt der BSD-Lizenz und istdamit frei für Erweiterungen und Modifikationen jeglicher Art, ohne Service-Agenturen oder Dienstleister zu verpflichten, eigene Modifikationen unter dergleichen Lizenz öffentlich verfügbar zu machen.

Obwohl SilverStripe mit dieser Open-Source-Lizenz dem Community-Gedankenfolgt, wird die eigentliche Entwicklung zentral vom gleichnamigen Entwickler-studio in Wellington (Neuseeland) gesteuert. Die SilverStripe Limited ist dabeiständig auf weltweiter Suche nach fähigen Programmierern, die ihr Können in dieSystementwicklung einfließen lassen möchten.

Genau diese zentrale Verwaltungsstruktur garantiert neuen Anwendern einenkommerziellen Support-Service, der bei Bedarf für jegliche Fragen in Anspruchgenommen werden kann. Diese Tatsache kann insbesondere bei professionellerNutzung des Systems eine entscheidende Rolle spielen. Zwar soll die Leistungsfä-higkeit der SilverStripe-Community an dieser Stelle nicht geschmälert werden,für unter Zeitdruck stehende Projekte müssen manche Fragen aber einfachschnell und in einer zuverlässigen Qualität beantwortet werden können. DieserSupport wird – natürlich gegen entsprechendes Entgelt – über die SilverStripe Li-mited sichergestellt.

BSD-Lizenz

BSD steht für Berkeley Software Distribution, einem sehr liberalen Lizenzmodell. DieBSD-Lizenz erlaubt das Kopieren, Verändern und Verbreiten von Software, ohne dassder Quellcode zugänglich gemacht werden muss. Lediglich der ursprüngliche Urheber-vermerk darf nicht gelöscht werden.

Für die Praxis bedeutet dies, dass Agenturen, die kundenspezifische Erweiterungen ent-wickelt haben, nicht dazu verpflichtet sind, diese ebenfalls offen zu legen. Der geleisteteintellektuelle Aufwand verbleibt damit beim Dienstleister.

Nach unserem Wissensstand ist SilverStripe zur Zeit der Drucklegung das einzige unterBSD-Lizenz befindliche PHP-basierte CMS. Konkurrierende Systeme setzen hier in derRegel auf die restriktivere GPL-Lizenz.

Den genauen Wortlaut der Lizenz erfahren Sie unter http://www.opensource.org/licen-ses/bsd-license.php.


36

Einführung1

1.3 Historie

Nachdem Sie nun ungefähr wissen, auf was Sie sich mit SilverStripe aus techni-scher Sicht einlassen, ist es natürlich noch sehr interessant zu erfahren, von wemund woher es genau kommt und welche Entwicklung das Produkt bisher durch-laufen hat.

Im Vergleich zu anderen, bereits lange etablierten Open-Source-Lösungen ist Sil-verStripe noch ein echter Junior. Als CMS für das eigene Klientel wurde das Sys-tem zunächst von der SilverStripe Limited lediglich kommerziell vermarktet.

Erst im Jahr 2005 entschied man sich für eine komplette Runderneuerung desSystems auf PHP5-Basis und damit zum ersten Mal auch für eine Open-Source-Lizenz. Durch die freie Verfügbarkeit sollten Synergie-Effekte erreicht werden,die SilverStripe noch besser machen sollten. Die Codequalität sollte dabei vorallem im Vordergrund stehen. Außerdem versprach man sich durch ein größerenPublikum auch ein qualifiziertes Feedback und Anregungen für weitere Verbes-serungen.

Die Rechnung ging auf, denn Anfang 2007 wurde die Google Inc. auf den Neuenaus Übersee aufmerksam und sprach sich für eine Teilnahme von SilverStripebeim Google Summer of Code aus.

SilverStripe Limited

Der Web-Dienstleister SilverStripe Limited wurde im Jahr 2000 in Wellington/Neusee-land von Tim Copeland, Sam Minnée und Sigurd Magnusson gegründet. Das Unterneh-men ist – neben der Entwicklung des eigenen Content-Management-Systems – als Full-Service-Webagentur tätig und begleitet international Kunden vom Consulting zur Ent-wicklung bis hin zum Hosting einer Internetpräsenz.

Zur Zeit der Drucklegung beschäftigt das Unternehmen zwei Dutzend Mitarbeiter inWellington, die einen Teil ihrer Arbeitszeit auf das Open-Source-Produkt SilverStripeverwenden können. Viele neue Features finden aber auch als direkte Auftragsarbeit füreinen Kunden ihren Anfang.

Google Summer of Code

Es gibt eigentlich kaum etwas, was Google nicht macht: Aus der Verbundenheit derGründer zur Open-Source-Software, die sie während des Studiums nach eigenen Anga-ben selbst für die verschiedensten Zwecke eingesetzt hatten, unterstützt Google dieEntwicklung freier Software-Projekte über den Google Summer of Code, oder auch kurzGSOC genannt. Dieser Name ist angelehnt an den »Summer of Love« des Jahres 1967 inSan Francisco und möchte wohl ähnliche jungrevolutionäre Kräfte suggerieren.


37

Ausblick 1.4

Diese Zusammenarbeit mit Google brachte SilverStripe nicht nur einen weiterenEntwicklungsschub, sondern sorgte auch für ein gutes Stück Öffentlichkeitsar-beit. Schließlich wurde das System nun indirekt von dem weltweit größten Such-maschinenbetreiber unterstützt und weckte damit entsprechende Erwartungen.

SilverStripe ist also nun mit etwas »Schützenhilfe« auch in Europa, in Deutsch-land angekommen und hat es zum Zeitpunkt der Drucklegung bis zur Version 2.3geschafft.

1.4 Ausblick

SilverStripe ist ein noch recht junges Content-Management-System. Hier und dagibt es gelegentlich Dinge, die noch nicht ganz so rund laufen. Allerdings werdengemeldete Probleme meistens sehr kurzfristig vom Entwicklerteam gelöst.

Insgesamt lässt sich eine recht flotte Entwicklungsgeschwindigkeit feststellen, diedas Produkt zu dem gemacht hat, was es heute ist. Auch zukünftig wird sich die-ses Tempo nicht verlangsamen, sondern durch die täglichen Bedürfnisse und An-forderungen immer wieder neu definiert werden.

Aus diesem Grund ist es besonders für SilverStripe recht schwer, einen verbind-lichen Zeitplan für einen längeren Zeitraum anzugeben, der morgen schon wie-der überholt sein könnte.

Wir haben uns deshalb auch entschieden, diesem Buch keine detaillierte Silver-Stripe-API beizufügen, sondern verweisen hier auf die aktuelle Online-Quellehttp://api.silverstripe.com. Nur so ist wirklich garantiert, dass Sie in diesem Au-genblick auch mit aktuellen Informationen arbeiten und mit Ihrer Implementie-rung zum weiteren Erfolg von SilverStripe beitragen können.

Betrachtet man die Entwicklung der Downloadzahlen, kann man in jedem Fallvon einem solchen ausgehen. Das stetig wachsende Interesse ist auch an der Tat-sache zu erkennen, dass es inzwischen auch in Deutschland erste Agenturen gibt,

Der GSOC ist ein seit 2005 jährlich vergebenes, dreimonatiges Stipendium, bei demmehrere hundert Studenten ihre Fähigkeiten für eines der teilnehmenden Open-Source-Projekte einsetzen können. Vertreter der Projekte treten dabei als Mentoren in Erschei-nung, die am Ende der Laufzeit auch die Erfüllung zuvor definierter Ziele prüfen.

Bei erfolgreichem Abschluss des Projektes eines speziellen Studenten zahlt Google einePrämie an den Teilnehmer.

Weitere Informationen zum GSOC finden Sie bei Google unter folgender Adresse: http://code.google.com/soc/


38

Einführung1

die Services rund um SilverStripe in ihr Portfolio aufgenommen haben. Silver-Stripe ist gerade im Begriff, den Sprung von der »geheimen« Agenturwaffe zueiner breit angewendeten Open-Source-Lösung zu vollziehen.

1.5 Zusammenfassung

SilverStripe macht bereits als CMS eine sehr gute Figur. Mit seinem MVC-Unter-bau entpuppen sich aber erst seine wirklichen Stärken – und wissen durchaus zubeeindrucken.

Zwar kann es noch nicht mit dem Pool von Erweiterungen »alteingesessener« Sys-teme mithalten, muss es aber auch nicht, denn die zugrunde liegende Architekturkompensiert und relativiert hier einiges. Alles was fehlt, kann in den meisten Fäl-len in kurzer Zeit realisiert und nachgerüstet werden.

Die BSD-Lizenz macht es zudem besonders für Service-Agenturen interessant, diefür ihre Kunden eigene Erweiterungen entwickeln wollen.

SilverStripe punktet auf ganzer Linie, wenn es um die Wirtschaftlichkeit einerEntwicklung geht, denn Web-Applikationen sind nicht nur sehr schnell mit indi-viduellen Funktionen ausgestattet, sondern lassen sich auch agil modifizieren.Diese Wendigkeit kann ein entscheidender Wettbewerbsvorteil sein.

Das System fordert zwar ein wenig Serverleistung, hält sich aber im Vergleich zurKonkurrenz noch stark zurück.

SilverStripe hat damit durchaus das Potenzial, als neue Alternative zu Alteingeses-senem in Betracht gezogen zu werden. Und bei dem aktuellen Entwicklungs-tempo dürfen wir gespannt auf alles sein, was da noch kommt.


61

»Schluckst du die blaue Kapsel, ist alles aus; du glaubst, was du glauben willst. Schluckst du die rote Kapsel, bleibst du am Leben. Bedenke, alles was ich dir anbiete ist die Wahrheit.« (Matrix)

3 Architektur

Mit dem vorherigen Kapitel haben wir alle Vorbereitungen abgeschlossen, umSilverStripe nun endlich etwas näher zu kommen. Doch halt: Damit Sie das wei-tere Vorgehen und die Beschreibungen besser verstehen, möchten wir Sie zu-nächst mit den zugrunde liegenden Paradigmen und Techniken vertraut machen.

Wir werden deshalb im Folgenden Model View Controller (MVC), Object RelationalMapping (ORM) und noch einiges mehr beschreiben. Auch wenn Sie bereits ersteErfahrungen mit diesen Techniken gesammelt haben, empfehlen wir Ihnen trotz-dem die Lektüre dieses Kapitels, da wir hier auch auf die genaue Art der Imple-mentierungen innerhalb des Frameworks eingehen werden.

3.1 Einleitung

Die moderne Software- und auch Web-Applikationsentwicklung bedient sich in-zwischen immer häufiger bewährter Strategien zur Lösung von geläufigen Aufga-benstellungen. Man greift also auf standardisierte Verfahren zurück, die schnellund modular einen möglichst fehlerfreien und sicheren Aufbau einer Applikationunterstützen. Solche Verfahren werden auch Entwurfsmuster oder Architektur-muster (engl.: Design Patterns) genannt.

Die Software-Entwicklung hat im Laufe der letzten Jahre eine Vielzahl von Ent-wurfsmustern hervorgebracht. Viele sind aus der alltäglichen Programmierarbeitnicht mehr wegzudenken.

Die Wahl des Entwurfsmusters hängt immer von der Art der zu lösenden Aufgabeab. An erster Stelle steht also immer eine genaue Identifizierung, um ein passen-des Entwurfsmuster auswählen zu können.


62

Architektur3

Gerade für Web-Applikationen und die damit verbundenen typischen Eigenartenscheint das Model View Controller (MVC) Pattern eine ideale Basis für ein schnelles,produktives und übersichtliches Arbeiten darzustellen.

3.2 MVC – Model View Controller

Das MVC-Entwurfsmuster haben wir schon des Öfteren erwähnt. Und in der Tatist es die maßgebliche strukturgebende Komponente. Wir erläutern nun ausführ-lich, worum es sich dabei genau handelt und wie SilverStripe dieses Konzept um-gesetzt hat.

3.2.1 Grundsätzliches

Wie bereits in Abschnitt 1.1.1, »Klare Trennung der Strukturen«, kurz umrissenwurde, ist MVC die Kurzschreibweise von Model View Controller. Diese drei Be-griffe benennen die unterschiedlichen logischen Einheiten, die dieses Modell füreine Applikation definiert.

Eine Einheit besteht in diesem Kontext physikalisch gesehen – wie sollte es an-ders sein – aus einer oder mehreren Dateien. Die Inhalte und damit auch dieFunktionen dieser Dateien folgen einer zweckgebundenen Aufgabenverteilung.So wird beispielsweise eine Einheit nur für die Anzeige von Inhalten eingerichtet,die ihre Daten selbst wiederum aus einer anderen Einheit erhält.

Damit haben wir bereits eine wichtige Voraussetzung des MVC-Konzeptes ge-nannt: die Fähigkeit zur Kommunikation. Die Einheiten müssen in der Lage sein,Informationen schnell und ohne großen Aufwand austauschen zu können.

Die Gründe für eine solche Aufgabenverteilung liegen auf der Hand: Eine nachglobalen Aufgaben getrennte Kapselung soll eine übersichtlichere Entwicklungmit einfacher zu wartendem Code unterstützen. Im Team können Mitarbeiter soauch besser gemäß ihren Fähigkeiten eingesetzt werden, ohne die Arbeit des an-

Konvention vor Konfiguration

Konvention vor Konfiguration (Convention over Configuration) bedeutet für den Entwicklerein Minimum an (meist lästiger) Konfiguration. Es werden nur die Eigenschaften undVerhaltensweisen konfiguriert, die von den voreingestellten Basisannahmen abweichen.

Eine Basisannahme ist beispielsweise die Benennung von Datenbanktabellen anhandder Klassennamen in den PHP-Dateien. Sie definieren also nur die Klasse und müssendiese Benennung nicht explizit für die Datenbank wiederholen – das Framework setzteinfach nachvollziehbare Standardwerte.


63

MVC – Model View Controller 3.2

deren störend zu beeinflussen. Ein weiterer großer Vorteil ist die Austauschbar-keit und Wiederverwendbarkeit einzelner Einheiten.

Traditionelle Content-Management-Systeme basieren in der Regel auf einemzweigliedrigen Model, bei dem eine Template-Engine für die HTML-Ausgabe zu-ständig ist und vom eigentlichen Rest der Applikation getrennt wird. Mit »Rest«ist hier die Logik zur Verwaltung der Daten, zum Entgegennehmen der Benutzer-eingaben und zur Aufbereitung der Ausgabe gemeint.

Die Nutzung eines solchen Systems ist sicherlich in einem webevolutionärenKontext zu sehen: In den Anfangszeiten des Internets musste man sich über dieVerteilung von Aufgaben ohnehin keine Gedanken machen, denn Programmlo-gik wurde nur sehr eingeschränkt für Webseiten implementiert. Es gab also inden meisten Fällen nur eine funktionelle Einheit. Erst für die Verwaltung vongrößeren Webseiten, die inhaltlich von vielen Nicht-Programmierern betreutwerden sollten, wuchs das Bedürfnis nach Trennung von Programmcode und dar-zustellendem Inhalt.

Nachdem nun so zunächst die primären Bedürfnisse des Kunden befriedigt wer-den konnten, formte man das bereits in den 1970er Jahren entworfene MVC-Ent-wurfsmuster auch für die Entwicklung von Web-Applikationen aus. Mit den dreiEinheiten sollte jetzt auch den Bedürfnissen des Entwicklers entgegengekommenwerden.

Im Vergleich zum Aufbau mit nur zwei funktionellen Einheiten wurden nun auchBusinesslogik und Datenverwaltung voneinander getrennt. Die einzelnen Einhei-ten übernehmen dabei folgende Aufgaben:

Abbildung 3.1 MVC-Entwurfsmuster

Ausgabe: View

Businesslogik: Controller

Datenbank: Model


64

Architektur3

� Die Model-Einheit kümmert sich um die Definition und Verwaltung derDatenstrukturen.

� Die View-Einheit ist die Ausgabe-Schicht und am ehesten mit einer Template-Engine vergleichbar.

� Die Controller-Einheit enthält die eigentliche Steuerung der Anwendung. DerController ist die erste logische Anlaufstelle und setzt beim Aufruf einer Seitedie Ausgabe zusammen. Dafür kann er Daten vom Model anfordern, die erdann aufbereitet an die View-Einheit schickt.

Tätigt der Nutzer auf der ausgegebenen Seite eine Eingabe (beispielsweise überein Formular), werden die Daten zunächst an den Controller geschickt, der dann»entscheidet«, was mit ihnen geschehen soll. Sollen Daten in der Datenbank ge-speichert werden, werden diese an das Model übergeben.

Streng genommen übernimmt der Controller zwei Aufgaben: Zum einen kann erEingaben verarbeiten, zum anderen setzt er die Ausgabe zusammen. Für eine sau-bere logische Trennung müsste man also eigentlich ein Modell mit vier Einheitenanstreben. Da aber bei Web-Applikationen die Verarbeitung der Eingabe sehreng an die Ausgabe gekoppelt ist, würde eine weitere Trennung an dieser Stellekeine wirklichen Vorteile für die Entwicklung bringen.

Mit dem MVC-Entwurfsmuster zeichnet sich momentan ein deutlicher Trend amCMS-Markt ab: Content-Management-Systeme müssen heutzutage nicht nur vomRedakteur benutzbar, sondern auch technisch auf der Höhe der Zeit sein undauch bleiben. CMS-Entwickler setzen deshalb verstärkt auf den Einsatz vonFramework mit MVC-Unterstützung. Der frühe Vogel fängt den Wurm: Silver-Stripe war hier eines der ersten Content-Management-Systeme mit MVC-Archi-tektur und ist deshalb schon recht praxiserprobt.

3.2.2 Umsetzung in SilverStripe

Da der CMS-Bereich von SilverStripe auf das MVC-Framework aufgesetzt wurde,werden wir zum besseren Verständnis der Architektur ein wenig ausholen bezie-hungsweise dem anschließenden Kapitel ein wenig vorgreifen müssen.

DRY – Don't repeat yourself

Mit der logischen Aufgabenteilung, welche durch Entwurfsmuster wie MVC erreichtwird, können einzelne Einheiten leichter bearbeitet oder ausgetauscht werden: Sie wer-den oft nur ein einziges Mal in Codeform hinterlegt. Der Verzicht auf redundanten Codeunterstützt die Übersichtlichkeit, reduziert den Speicherbedarf und sorgt für eine gerin-gere Fehleranfälligkeit.


65


Wenn Sie später im Backend des CMS eine neue Seite anlegen, müssen Sie diesereine Funktion oder Aufgabe zuweisen. Dies geschieht über die Angabe des Sei-tentyps (Page type). Für die Standardausgabe von Inhalten stellt SilverStripe »out-of-the-box« den Seitentyp »Page« bereit.

Die Bezeichnungen für den Seitentyp korrespondieren mit im Code hinterlegtenKlassennamen. Der eigentliche Code und die Funktionalität zur Beschreibung die-ses Seitentyps befinden sich also, nach dem MVC-Entwurfsmuster gekapselt, indefinierten Ordnern. Nachdem wir im letzten Kapitel ja so weit alles betriebsbe-reit installiert hatten, werfen wir nun einen ersten Blick in genau diese Ordner-struktur:

Wie Sie in Abbildung 3.3 erkennen können, finden Sie im SilverStripe-Ordner soeinige Unterordner, von denen uns momentan allerdings nur wenige interessie-ren sollen.

Wie schon im Kasten »Konvention vor Konfiguration« beschrieben, werden zu-sammengehörige Bereiche einer MVC-Definition über gleichlautende Dateina-men definiert. In unserem Beispiel war das »Page«.

Controller und Model

Im Gegensatz zu einigen anderen Frameworks verwaltet SilverStripe den Codefür Controller und Model in einer gemeinsamen Datei. Alle Controller-/Model-Definitionen liegen als normale PHP-Dateien im Unterordner code. Dieser liegt inder Standardinstallation im Ordner mysite, kann aber auch an jedem anderen Ortabgelegt werden. Eine Controller-/Model-Definition hat dabei in den meisten Fäl-len die folgende Grundstruktur:

Abbildung 3.2 Einstellung des Seitentyps im Backend


66

Architektur3

<?phpclass Page extends SiteTree {

// Definition der Model-Eigenschaften und -Methoden}class Page_Controller extends ContentController {

// Definition der Controller-Eigenschaften und -Methoden}?>

Listing 3.1 Aufbau einer Controller/Model-Definition (Beispiel: mysite/code/Page.php)

Abbildung 3.3 Model, View und Controller in der Verzeichnisstruktur

Namensgebung von Model und Controller

SilverStripe folgt hier auch codeintern einer konsequenten Namensgebung, die unbe-dingt einzuhalten ist. Die Model-Klasse ist dabei gleichlautend mit dem Dateinamen (inunserem Beispiel »Page«). Für die Benennung des zugehörigen Controllers wird dem Da-teinamen einfach noch ein »_Controller« angefügt und damit unter dem Namen »Page_Controller« deklariert.

Wird dieses Schema nicht beachtet, wird das Framework die Klasse nicht erkennen, undsie wird damit nicht zur Verfügung stehen.

Controller& Model

View


67


Wie Sie sehen, erben Page und Page_Controller von bereits definierten Klassen,die aus dem sapphire-Framework stammen. Beide Klassen werden dadurch be-reits mit allen Eigenschaften ausgestattet, um beispielsweise direkt auf die Daten-bank oder Eingabefelder des Backends zugreifen zu können.

View

Die Dateien der View-Einheit folgen einer gewissen Order- und Namenskonven-tion, welche Einsatz und Vererbung regelt. Wie Sie ja bereits gesehen haben,bringt die Standardinstallation von SilverStripe für diese Einheit bereits ein vor-gefertigtes Layout mit dem Namen »BlackCandy« mit, das sich im Ordner themesbefindet.

Der Ordner templates enthält – wie der Name schon vermuten lässt – alle HTML-Strukturen, die sich auch über mehrere Template-Dateien für die Ausgabe zusam-mensetzen lassen. Die Template-Dateien tragen bei SilverStripe die Endung .ss.

Auch in der View-Einheit sind wieder spezielle Namenskonventionen zu beach-ten. Gleichlautende Dateinamen gehören auch hier wieder automatisch zusam-men.

Page.ss (in der Abbildung ist der letzte Eintrag der Verzeichnisstruktur gemeint)stellt die HTML-Grundstruktur, das Basis-Template für die Ausgabe bereit.

Abbildung 3.4 Template-Konzept der View-Einheit

HTML-Grundstruktur

<html><head>...</head><body>

<% include Footer %>

</body></html>

$Layout

<% include Navigation %>

<h1>$Title</h1>

$Content$Form$Comments

Individueller Content


68

Architektur3

In dieser Datei befinden sich in der Regel neben normalem HTML-Code auch Platz-halter, Kommandos, Bedingungen und Schleifenkonstrukte des sapphire-Frame-works, die eine gezielte Ausgabesteuerung ermöglichen. In der obigen Abbildungwird so beispielsweise der HTML-Code für den Footer über <% include %> einge-bunden. Das System greift mit dieser Anweisung im Ordner Includes auf die DateiFooter.ss zurück. Damit das Framework solche Kommandos korrekt verarbeitenkann, müssen diese in spitze Klammern mit Prozentzeichen (<% ... %>) gekleidetwerden.

Page.ss enthält einen Platzhalter mit dem Namen $Layout. An seine Stelle werdendie Inhalte der Datei geschrieben, die das System im Ordner Layout unter glei-chem Namen (also nochmal »Page«) finden kann. Auch diese Datei Layout/Page.sskann neben HTML-Code ebenfalls die oben beschriebene Elemente zur Ausgabe-steuerung enthalten. Im Beispiel kommen die Inhalte für die Platzhalter $Title,$Content, $Form und $Comments später aus der Datenbank, die dort vorher überdas CMS abgelegt worden sein müssen.

Vererbung

Durch die Aufteilung der View-Einheit in eigentlich drei weitere Unterstrukturenwird der Grundsatz »Don't repeat yourself« unterstützt. Eine Dopplung von glei-chem Code wird damit weitgehend überflüssig. Sie müssen also nicht für jedeSeite aufs Neue HEAD- und BODY-Tag definieren, wenn diese für alle Ausgabeseitenidentisch sein sollen, sondern nur ein einziges Mal.

Möchten Sie nun beispielsweise eine Seite erzeugen, die zwar größtenteils mitPage identisch ist, allerdings keine Navigation enthalten soll, können Sie wie folgtvorgehen:

Zunächst müssen Sie (im Controller und Model) einen neuen Seitentyp (»Mini-Page«) definieren:

<?phpclass MiniPage extends Page {

// Definition der Model-Eigenschaften und -Methoden}class MiniPage_Controller extends Page_Controller {

// Definition der Controller-Eigenschaften und -Methoden}?>

Listing 3.2 Definition eines neuen Seitentyps: mysite/code/MiniPage.php

Model und Controller von MiniPage erben in diesem Beispiel alle Eigenschaftenvon Page und sind in ihrer Funktion damit zunächst identisch.


69


Nun fehlt noch das passende Layout-Template. Hierzu können Sie nun /Layout/Page.ss kopieren und im gleichen Ordner unter dem Namen MiniPage.ss abspei-chern.

Jetzt müssen wir nur noch im Quellcode der Datei MiniPage.ss die unerwünschteNavigation (<% include Navigation %>) herauslöschen.

Fertig!

Wenn nun der Seitentyp »MiniPage« im Backend des CMS einer Seite zugewiesenwird, versucht sapphire für die Ausgabe zunächst auch auf die Template-Dateienmit gleichem Namen zuzugreifen. Existiert keine entsprechende Datei, wendetsich das System an die Elternklasse, also an Page.

In diesem Beispiel wird also templates/Page.ss als Basis-Template und templates/Layout/MiniPage.ss als Layout-Template genutzt.

Kommunikation

Die Kommunikation zwischen den jeweiligen MVC-Einheiten verläuft anders, alsSie das vielleicht von Template-Engines her kennen. Für eine Ausgabe müssen dieDaten nicht explizit an View übertragen werden. Sowohl der verwendete Con-troller als auch das Model stehen für eine direkte Ausgabe in der View-Einheitzur Verfügung. Das erleichtert die Arbeit ungemein.

Wir möchten das anhand des folgenden Codebeispiels erläutern:

<?phpclass Category extends Page {

// Model-Definition ...}class Category_Controller extends Page_Controller {

function LatestCustomers() {return DataObject::get(

"Customer","`Customer`.CategoryID = $this->ID","`Customer`.Created DESC",null,

Abbildung 3.5 Vererbung bei Templates


70

Architektur3

10);

}}?>

Listing 3.3 Sammeln der Daten über Controller für die Templateausgabe

Wie Sie sehen, erben das Category-Model und der Category_Controller auchhier wieder von den unter Page definierten Klassen. Für uns ist hier momentanvor allem der Controller interessant. Auch wenn Sie noch nicht alles verstehen,so können Sie doch erkennen, dass die Funktion LatestCustomers() einen Rück-gabewert ausliefert. Sie werden es vermuten: Es handelt sich in diesem Fall umeine Datenbankabfrage auf das hier nicht weiter definierte Objekt Customer, des-sen Ergebnis anschließend im Template über LatestCustomers abgreifbar ist:

<% if LatestCustomers %><ul class=“customers“>

<% control LatestCustomers %><li>

<img src="'$Image.URL" alt=“$Image.Title“ />Name: $Name<br />Email: <a href="mailto:$Email">$Email</a>

</li><% end_control %>

</ul><% else %>

<p>Keine Daten vorhanden!</p><% end_if %>

Listing 3.4 Ausgabe der gesammelten Daten im Template

Die Template-Kommandos in diesem Beispiel sind beinahe selbsterklärend: Zu-nächst wird über die IF-Anweisung überprüft, ob LatestCustomers überhaupt Da-tensätze zurückgeliefert hat. Sollte dies nicht der Fall sein, wird der Hinweis»Keine Daten vorhanden!« ausgegeben. Ansonsten wird mit dem Aufbau derListe fortgefahren, die die Ergebnisse der Datensätze anzeigen soll. Dazu wirdüber <% control LatestCustomers %> ... <% end_control %> ein Schleifenkörperdefiniert, der jeden einzelnen Datensatz durchläuft und die Daten über die Platz-halter $Name, $Image und $Email ausgibt. Die Bezeichnung »Platzhalter« ist andieser Stelle nicht ganz treffend, denn es handelt sich hier eigentlich um Objekte,deren Eigenschaften über Punktnotation adressierbar sind. So wird beispiels-weise über $Image.URL die Adresse eines Image-Objekts ausgegeben, das vorherim CMS einem Customer-Objekt zugeordnet wurde.


71

ORM – Object Relational Mapping 3.3

Sie sehen, wie einfach und effektiv die Kommunikation zwischen den MVC-Ein-heiten ist. Im Beispiel hatten wir nun schon ersten Kontakt mit einem Datenbank-zugriff. Da wir uns bisher nur auf die in SilverStripe verbauten MVC-Grundzügekonzentrieren wollten, ist der bisher entworfene Code in vorliegender Formnoch nicht wirklich funktionsfähig, denn wir haben die konkrete Definition desModels ausgespart.

Im Folgenden widmen wir uns diesem sehr wichtigen Thema in einem eigenenKapitel ausführlicher.

3.3 ORM – Object Relational Mapping

Der Datenbankzugriff der Model-Einheit erfolgt bei SilverStripe über das ObjectRelational Mapping. Wie der Name schon sagt, handelt es sich hierbei um einenKonnektor, der den objektorientierten Ansatz von PHP-Klassen an relationaleDatenbanken wie MySQL andockt. Vielleicht kennen Sie diesen Ansatz auch vomActiveRecord-Entwurfsmuster.

Das ORM fungiert eigentlich als eine Art Abstraktionsschicht, die es erlaubt, ohnespezifische Kenntnisse über die Datenbank Daten zu speichern, abzurufen, zu ma-nipulieren oder zu löschen. Dieser Ansatz erlaubt sogar einen späteren Austauschdes Datenbanksystems, ohne dass die Funktion der Applikation dadurch beein-trächtigt werden würde.

Die Grenzen der Template-Syntax

Die Template-Syntax von SilverStripe wird durch einfaches Umschreiben von bestimm-ten Begriffen innerhalb der charakteristischen Klammern (<% %>) in PHP-Anweisungenerreicht. Das Spektrum nutzbarer Befehle ist aus diesem Grunde begrenzt, Anweisungenund Abfragen sind nicht beliebig kombinier- und verschachtelbar. In den allermeistenFällen lässt sich das Template jedoch derart umschreiben, dass die Logik mit gültigerSyntax formuliert werden kann.

Beispiel für ungültige Syntax (zu tiefe Verschachtelung):

$Person.Image.URL

Alternative gültige Schreibweise:

<% control Person %> $Image.URL<% end_control %>

Eine vollständige Auflistung der SilverStripe-Template-Syntax finden Sie unter http://doc.silverstripe.com/doku.php?id=templates.


72

Architektur3

SilverStripe besitzt zurzeit noch keine vollwertige Abstraktionsschicht und unter-stützt aktuell auch nur den MySQL-Datenbankserver. Es gibt trotzdem Überle-gungen, diese »Hartverdrahtung« in absehbarer Zeit aufzulösen und SilverStripeauch mit MSSQL, PostgreSQL und SQLite nutzbar zu machen.

3.3.1 Mapping-Konventionen

Über das ORM kann nun innerhalb des Frameworks in objektorientierter Manierauf die Inhalte der Datenbank zugegriffen werden. Dabei gelten folgende Regeln:

� Tabelle wird in Klasse überführt.

� Tabellenzeile wird in Objekt überführt.

� Spalte wird in Attribut überführt.

Auch wenn diese Auflistung hier noch etwas abstrakt erscheint, behalten Sie siebitte im Hinterkopf.

3.3.2 Definition

Damit die Datenbankstruktur vom Entwickler nicht manuell angelegt oder ange-passt werden muss, stellt das sapphire-Framework eine komfortable Möglichkeitbereit, dies automatisch durchführen zu lassen. Die Spalten werden dabei – wiesehr häufig in SilverStripe – über eine statische Variable definiert. Dazu wird $dbein Array mit den Spaltennamen und deren Typ zugewiesen.

<?phpclass Employee extends DataObject {

static $db = array('Name' => 'Text','Comment' => 'HTMLText',

);}?>

Listing 3.5 Definition eigener Datenbankstrukturen

CRUD – Create, Read, Update, Delete

Das Akronym CRUD setzt sich aus den Anfangsbuchstaben der Basisoperationen zusam-men, die im Zusammenspiel mit einer Datenbank durchgeführt werden:

� C = Create (Datensatz anlegen)

� R = Read (Datensatz auslesen)

� U = Update (Datensatz aktualisieren)

� D = Delete (Datensatz löschen)


73


In diesem Beispiel werden Name und Comment als Spalten in der Tabelle Employeedefiniert. Damit diese nun auch so in der Datenbank angelegt werden, müssenSie die folgende URL in Ihren Browser eingeben:

http://localhost/dev/build

Merken Sie sich diese Zeile gut, denn Sie werden sie in der weiteren Entwicklungeiner SilverStripe-Anwendung noch häufiger verwenden. Jedes Mal, wenn Sieetwas an der Datenbankstruktur ändern, übernimmt SilverStripe die neuen Infor-mationen erst nach einer solchen Datenbankaktualisierung.

Datenbankstrukturen können Sie nur dann ändern, wenn Sie als Administratoreingeloggt sind (es sei denn, das System befindet sich im Developer-Modus, sieheAbschnitt 3.8.2, »Betriebsarten«). Sollten Sie nicht eingeloggt sein, wird Silver-Stripe Sie zunächst also zu seinem Login-Dialog umleiten.

3.3.3 Zugriff

Für den Zugriff der Daten stehen unter anderem folgende statische Methoden zurVerfügung:

$records = DataObject::get($class,$filter,$sort,$join,$limit);$record = DataObject::get_by_id($class,$id);$record = DataObject::get_one($class,$filter);

Dabei stehen die Variablen genau für diejenigen Informationen, die Sie schonvermuten: für Fragmente eines SQL-Statements.

Bei Bedarf kann das ORM aber auch umgangen und SQL-Abfragen direkt ausge-führt werden.

3.3.4 Relationen

Über Relationen geben Sie in einer relationalen Datenbank die Verknüpfungmehrerer Tabellen untereinander an. Bei einer klassischen SQL-Abfrage, die sich

Parameter Beschreibung

$class Klassenname des Models

$filter WHERE-Klausel (optional)

$sort ORDER BY-Kriterium (optional)

$join JOIN-Definition (optional)

$limit Begrenzung der Datensatzanzahl (optional)

Tabelle 3.1 Parameter beim Datenbankzugriff


74

Architektur3

auf mehrere Tabellen bezieht, definieren Sie diese Verknüpfungsinformationenin der Regel immer wieder aufs Neue. Das ist nicht sonderlich effizient und ent-spricht auch nicht dem DRY-Prinzip.

Bei SilverStripe hinterlegen Sie diese Relationen zentral an nur einer Stelle, eineinziges Mal. Das System kennt dabei drei unterschiedliche Relationstypen:

has_one

Eine klassische 1:1-Relation wäre beispielsweise die ausschließliche Zuordnungeines einzigen Firmenwagens (CompanyCar) zu einem Mitarbeiter (Employee). Inder Praxis kommt diese Art der Relation wohl nur selten vor, da man solcheDaten meistens in einer gemeinsamen Tabelle verwalten kann.

Auch Relationen werden bei SilverStripe über statische Variablen definiert. ZurFestlegung der beschriebenen Relation müsste im Model von Employee stehen:

class Employee extends DataObject {static $has_one = array("Car" => "CompanyCar",

);}

Listing 3.6 Definition einer 1:1-Beziehung

Dadurch definieren wir über den Klassennamen, dass die Daten der Mitarbeiterin der Tabelle Employee abgelegt werden. Die Existenz der statischen Variable$has_one bestimmt den Typ der Relation. Der Inhalt des assoziativen Arrays be-

Abbildung 3.6 1:1-Beziehung

Parent Child

Employee Company Car

has_one

1:1


75


schreibt mit Car den Namen dieser Relation. Der zugewiesene Wert CompanyCarist der Name der zu verknüpfenden Tabelle.

Den Namen der Relation benutzt das Framework zur Benennung von zusätzli-chen Spalten zur Abbildung der Relation in der Datenbank. Er dient aber auch derReferenzierung in PHP:

$employee = DataObject::get_one('Employee', „Name = 'John'“);$car = $employee->Car();

Das System erstellt in der Datenbank nämlich hierfür eine zusätzliche Spalte inder Tabelle auf Seiten der has_many-Relation mit dem Namen eben dieser Rela-tion und fügt diesem noch den Zusatz »ID« an. In unserem Beispiel wäre das alsoCarID.

Die hier aufgeführten Beispiele befassen sich mit jeweils nur einer Relation. Inder Praxis sind aber oft mehrere Relationen notwendig. Wie Sie noch im weiterenVerlauf des Buches sehen werden, können diese dann innerhalb einer einzigenKlasse nach gleichem Schema definiert werden.

has_many

Für die Definition einer 1:n-Relation müssen wir nur unwesentlich mehr Auf-wand betreiben. In unserem Beispiel definieren wir, dass ein Mitarbeiter (Employ-ee) mehrere Kunden (Clients) betreut.

Um später über beide »Enden« auf die Daten zugreifen zu können, sollten wir dieRelation auch in beiden Model-Klassen, Employee und Client, definieren:

Abbildung 3.7 1:n-Beziehung

Parent Child

Employee Client

has_many

1:n


76

Architektur3

class Employee extends DataObject {static $has_many = array("Clients" => "Client",

);}class Client extends DataObject {

static $has_one = array("Employee" => "Employee",

);}

Listing 3.7 Definition einer 1:n-Beziehung

Wie Sie sehen, nutzen wir auf der Seite von Employee eine $has_many-Zuweisung(er betreut ja mehrere Kunden), wobei auf der Seite der Kunden eine $has_one-Relation definiert wurde (jeder Kunde hat nur einen Ansprechpartner bei derFirma).

Ähnlich wie bei einer 1:1-Relation legt SilverStripe auch hier eine neue Spalte mitgleichem Namen an. Allerdings wird diese jetzt in die Client-Tabelle eingefügt.Eine Zuweisung mehrerer Client-Objekte innerhalb einer einzelnen Daten-bankspalte auf Employee ist kaum möglich. Logisch: Die Spalte mit den Relations-schlüsseln muss auf der has_one-Seite liegen.

In PHP können Sie die beiden Seiten der Relation wie folgt benutzen:

// alle Kunden für einen Mitarbeiter$employee = DataObject::get_one('Employee', "Name = 'John'");$clientsForEmployee = $employee->Clients();// ein Mitarbeiter für einen speziellen Kunden$client = DataObject::get_one('Client', "Name = 'Jane'");$employeeForClient = $client->Employee();

Bitte beachten Sie: Für die Referenzierung der Relation wird der Name der Rela-tion verwendet, nicht die verknüpfte Klasse. Daher schreiben wir $employee->Clients() in der Mehrzahl.

many_many

Das Beispiel für diesen letzten Relationstypen geht davon aus, dass die Mitarbei-ter auch schon mal gemeinschaftlich Artikel (Article) für das Intranet verfassen,sodass jeder einzelne Mitarbeiter Autor mehrerer Artikel sein kann, diese aberwiederum auch mehreren Mitarbeitern zugeordnet werden können. Diese m:n-Verknüpfung wird unter SilverStripe auch als many_many-Relation bezeichnet.


77


Eine Abbildung der m:n-Beziehung könnte damit wie folgt aussehen:

class Employee extends DataObject {static $many_many = array(

'Articles' => 'Article',);

}class Article extends DataObject {

static $belongs_many_many = array('Employees' => 'Employee',

);}

Listing 3.8 Definition einer m:n-Beziehung

Beachten Sie bitte, dass auf einer Seite der Relation die statische Variable nicht$many_many, sondern $belongs_many_many heißen muss. Es ist hierbei irrelevant,welche Seite beziehungsweise Klasse hierfür gewählt wird.

Bei m:n-Relationen wird eine zusätzliche Tabelle benötigt, die die Spalten mit denjeweiligen Schlüsseln als Wertepaar trägt. Auch diese Tabelle wird von Silver-Stripe automatisch angelegt. Der Name dieser Tabelle setzt sich aus dem Namender many_many-Klasse, einem Unterstrich und dem Namen der Relation zusam-men. In unserem Beispiel würde diese Tabelle also Employees_Articles heißen.

Abbildung 3.8 m:n-Beziehung

Parent Child

Employee Article

many_many

m:n


78

Architektur3

3.3.5 Datenbankstruktur

Wie schon in der Einleitung zu MVC und ORM beschrieben, erzeugt jede Unter-klasse von DataObject eine eigene Tabelle in der Datenbank, inklusive benötigterRelationstabellen. SilverStripe legt in seiner Standardinstallation einige DutzendTabellen an.

Im Folgenden beschreiben wir den Sinn und Zweck der meisten Standardtabel-len. Nutzen Sie zum Nachvollziehen am besten ein entsprechendes Hilfsmittelwie phpMyAdmin.

� SiteTree, SiteTree_versions, SiteTree_Live: Sie gehören zu den Kerntabellen desCMS. Sie tragen den eigentlichen Inhalt einer Seite. Das System kennt hierdrei Tabellen, jeweils eine für die Live-Version, den Entwurf und die Verwal-tung verschiedener Versionen. Alle Datensätze der Klasse Page werden hiergespeichert, da sie von der Klasse SiteTree erbt.

� ErrorPage, RedirectorPage, VirtualPage: Dies sind Unterklassen von Site-Tree, die spezielle Attribute in Ihrer eigenen Tabelle speichern. Sie erfüllenFunktionen wie die Darstellung von Fehlerseiten, Weiterleitung auf andereSeiten oder die Ausgabe von Inhalten anderer Seiten.

� PageComment: Jede SilverStripe-Seite kann mit einer Blog-typischen Kom-mentarfunktion ausgestattet werden. Die hinterlegten Kommentare werdenin dieser Tabelle gespeichert.

� File, Folder: Über diese Tabellen werden alle in den Ordner assets hochgela-denen Daten erfasst. Sie werden vom System eigenständig aktualisiert.

� Group: Gruppen werden über das Admin-Interface »Sicherheit« bestimmt. Siekönnen über die Relationstabelle Group_Members mehrere Einträge aus derTabelle Member aufnehmen.

� Member: Enthält alle Nutzer, die sich am System anmelden können, sowiederen Passwort und persönliche Einstellungen.

� Permission: Hier werden die Rechte der angelegten Gruppen definiert.

� Widgets, WidgetArea: »Widgets« sind kleine visuelle Helfer für die Frontend-Ansicht. Eine genauere Beschreibung der Funktionalität finden Sie inAbschnitt 3.5, »Module und Widgets«.

� Sie sehen also, dass sich eine in PHP definierte Klassenvererbung auch in derDatenbank auswirkt. So hat beispielsweise die Klasse RedirectorPage, dievon SiteTree erbt, ein zusätzliches Attribut ExternalURL. Daher wird eineneue Datenbanktabelle RedirectorPage mit dieser Spalte erstellt. Alle vonSiteTree geerbten Attribute werden aber weiterhin in der ursprünglichen Ta-belle SiteTree gespeichert. Ein einziger Datensatz verteilt sich also auf mehrereTabellen, die über den primären Datenbankschlüssel ID zusammengehören.


79

Ordnerstruktur 3.4

3.4 Ordnerstruktur

SilverStripe organisiert sich größtenteils auf oberster Ebene im Basisverzeichnisder Installation. Grundsätzlich gilt, dass jeder Ordner auf der Hauptebene ein ei-genes Modul darstellt, also ein Stück gekapselte Funktionalität. Was ein Modulgenau ist, verraten wir in Abschnitt 3.5, »Module und Widgets«. Im Folgendenbeschreiben wir den Zweck der Hauptordner, die sich nach einer Standardinstal-lation von SilverStripe auf Ihrer Festplatte befinden sollten.

3.4.1 Mysite

Der Ordner mysite ist der Dreh- und Angelpunkt für Ihr Projekt: Alle PHP-Da-teien, die sie selbst erstellen, sollten sich in diesem Ordner wiederfinden. DerOrdner hat aber noch eine weitere Funktion: Er gibt Ihrem Projekt seinen Na-men, der auch in mysite/_config.php durch die Variable $project definiert wird.Der Projektname wiederum hat verschiedene Aufgaben: Beispielsweise dient erals Standardwert für den Datenbanknamen. Generell können Sie diesen Ordneralso umbenennen, solange Sie auch die Variable $project anpassen.

3.4.2 Themes

Mit dem Begriff Theme wird eine gekapselte Definition der Darstellung einerWebseite bezeichnet. Ein Theme besteht aus SilverStripe-Templates (meist inHTML), CSS-Stylesheets, Bildern und manchmal auch JavaScript. Jedes Themewird durch einen oder mehrere Unterordner dargestellt. In der Standardinstalla-tion finden Sie das Theme BlackCandy, welches in zwei Ordnern repräsentiertwird: themes/blackcandy und themes/blackcandy_blog. In blackcandy_blog wer-den spezielle Templates für ein (optional installierbares) Blog-Modul abgelegt.

Weitere Informationen zu Themes finden Sie in Abschnitt 3.6, »Themes«.

Datenbankaktualisierung ohne Datenverlust

Einmal angelegte Datenbankstrukturen werden durch Modifikationen am Model nichtgelöscht. Diesen Sachverhalt sollten Sie unbedingt beachten, da es sonst bei der Ent-wicklung zu unerwarteten Verhaltensweisen Ihrer Applikation kommen kann. MöchtenSie Spalten einer Tabelle wirklich löschen, müssen Sie dies manuell über ein entspre-chendes Datenbank-Tool durchführen, wie beispielsweise mit phpMyAdmin.


80

Architektur3

3.4.3 Assets

Der Begriff Assets lässt sich in etwa mit Bestand oder Anlage übersetzen. Wie derName schon vermuten lässt, verwaltet das Framework hier alle vom Nutzer hoch-geladenen Inhalte. Unterhalb dieses Ordners können also Anwender, die über dieentsprechenden Zugriffsrechte verfügen, über das Backend (Dateien & Bilder) ei-gene Ordner anlegen und befüllen.

Es besteht hier aber auch die Möglichkeit, beliebige Daten via FTP hochzuladen.Damit man solche Dateien auch im Backend des Systems verwenden kann, mussdas Framework auch von deren Existenz erfahren. Bei jedem Aufruf des Manage-ment-Interfaces wird der Seitenbaum automatisch mit der Datenbank synchroni-siert. Je nach Anzahl der abgelegten Daten kann dieser Vorgang recht speicher-intensiv sein. Es kann durchaus passieren, dass Sie in solchen Fällen eineentsprechende Fehlermeldung erhalten. Sie sollten also immer auf eine ausrei-chende Dimensionierung des Hauptspeichers achten (siehe auch Abschnitt 2.1,»Systemvoraussetzungen«).

3.4.4 Cms

In diesem Ordner befindet sich das CMS-Modul, also das System, mit dem Sie alsRedakteur arbeiten, um Inhalte einzupflegen und zu verwalten.

3.4.5 Sapphire

Das Framework sapphire ist das Herzstück von SilverStripe: Ohne diesen Ordnerwürde nichts funktionieren, das CMS-Modul ist abhängig von der Existenz desFrameworks. Hier finden sich die MVC- und ORM-Implementierung sowie denGroßteil der zugrunde liegenden Schnittstellen. Dieser Ordner beinhaltet zudemauch weitere interessante Skripte. Seine genaue Betrachtung verhilft in jedem Fallzu einem besseren Über- und Einblick in das System. Mit dem kommenden Ab-schnitt 3.7, »System-Architektur«, werden wir gleich einen ersten Schritt in dieseRichtung wagen.

3.4.6 Jsparty

SilverStripe greift nicht nur auf eigene JavaScript-Funktionen zurück, sondernimplementiert auch Bibliotheken von Drittherstellern. Im Ordner jsparty findetsich neben dem prototype-Framework und der script.aculo.us-Bibliothek auch derRichtext-Editor TinyMCE, den SilverStripe zur Bearbeitung der Seiteninhalte imCMS-Backend einsetzt. Ebenfalls hier zu Hause ist die Reiter-Verwaltung TabStripsowie SWFUpload (Flash-basierte Upload-Funktion) und noch ein paar weitereJavaScript-Erweiterungen.


81

Module und Widgets 3.5

3.4.7 Weitere Ordner

SilverStripe ist einfach erweiterbar, daher ist auch die Struktur und Anzahl derOrdner im Hauptverzeichnis nicht begrenzt. Jedes Modul findet hier als OrdnerPlatz. In der Standardinstallation ist das zum Beispiel das Modul googlesitemaps.

3.5 Module und Widgets

Module entstammen eigentlich keiner speziellen SilverStripe-Terminologie fürErweiterungen in spezieller Form. Im Prinzip kann alles, was sich außerhalb dessapphire-Ordners befindet, eine funktionelle Erweiterung und damit ein Modulsein. Genau genommen ist selbst das CMS ein Modul, das sich des sapphire-Frameworks bedient und das CMS-Interface formt.

Eine SilverStripe-Installation kann also neben sapphire aus beliebigen weiterenKomponenten, den Modulen, bestehen. Eine Übersicht vorgefertigter Modulefinden Sie übrigens unter http://www.silverstripe.org/modules/ sowie viele wei-tere direkt im Subversion-Repository unter http://open.silverstripe.com/browser/modules. Die interessantesten Module dieser Adressen stellen wir übrigens inunserem Appendix vor.

3.5.1 Unterscheidungsmerkmale

Widgets sind rein technisch gesehen kaum von Modulen zu unterscheiden. Auchsie werden meist in eigenen Ordnern verwaltet, die im Hauptverzeichnis von Sil-verStripe abgelegt werden. Die Installation erfolgt auf dem gleichen Weg: Einmalan die richtige Stelle kopiert, müssen Sie nur noch eine Datenbankaktualisierungausführen, um das neue Widget nutzen zu können.

Unterschiede zu den Modulen gibt es nur in der Art der Aufgabe, die ein Widgetübernimmt: In erster Linie handelt es sich dabei um gekapselte Funktionsberei-

Prototype und script.aculo.us

Bei Prototype handelt es sich um ein freies JavaScript-Framework. Es wird unter derMIT-Lizenz (Massachusetts Institute of Technology) geführt, die auch Ursprung derBSD-Lizenz ist, unter der SilverStripe geführt wird. Das Framework dient in erster Liniezur Vereinfachung von JavaScript-Entwicklungen.

script.aculo.us ist eine auf Prototype aufbauende Bibliothek für visuelle Effekte, wie Ein-blendungen, Skalier- und Bewegungseffekte.

SilverStripe setzt für das Backend einige der bereitgestellten Funktionen ein, wie bei-spielsweise für die Drag & Drop-Bedienbarkeit.


82

Architektur3

che, die – meistens in einer Seitenleiste – für die Ausgabe ins Template integriertwerden. Je nach Programmierung lässt sich das Erscheinungsbild per Drag &Drop im Backend konfigurieren. Widgets können auch als Erweiterung bestehen-der Module konzipiert und eingesetzt werden. Dementsprechend fällt der Codeeines Widgets wesentlich schmaler aus als der eines Moduls.

Auf der SilverStripe-Seite unter http://www.silverstripe.org/widgets/ finden Sie be-reits einige fertige Widgets, die Sie wie beschrieben installieren können.

3.5.2 Installation

Dank der automatischen Klassenerkennung in SilverStripe ist die Installationeines Moduls sehr leicht. Falls keine speziellen Installationsanweisungen für dasgewünschte Modul vorliegen, folgen Sie diesen Schritten:

� Laden Sie das gewünschte Modul als Archiv herunter.

� Extrahieren Sie das Archiv im Hauptverzeichnis Ihrer SilverStripe-Installation.Der Ordner mit dem Modulnamen sollte sich nun auf derselben Ordnerebenewie cms und sapphire befinden und zumindest einen Unterordner <meinmo-dul>/code und die Datei <meinmodul>/_config.php enthalten.

� Anschließend aktualisieren Sie über http://localhost/dev/build die Datenbank-struktur, welche bei Bedarf neue Tabellen für das Modul anlegt.

Die ManifestBuilder-Klasse scannt bei der Aktualisierung alle Ordner des Haupt-verzeichnisses und erkennt schließlich hier auch den neuen Ordner mit unseremModul. Somit ist das neue Modul direkt einsatzbereit. In der Regel müssen Siezur Inbetriebnahme keine Konfiguration vornehmen. Sollte dies trotzdem erfor-derlich werden, finden Sie im jeweiligen Hauptordner des Moduls eine Datei mitdem Namen _config.php, die Sie mit Ihrem Editor an individuelle Bedürfnisse an-passen können.

3.5.3 Deinstallation

Zur Deinstallation gehen Sie ähnlich vor: Löschen Sie den Ordner des Modulsund führen Sie erneut eine Aktualisierung der Datenbankstruktur durch. Nichtmehr benötigte Datenbanktabellen werden mit dem Präfix _obsolete markiert,Datenbankspalten bleiben bestehen. Damit wird gewährleistet, dass durch eineunachtsame Deinstallation keine Nutzdaten verloren gehen. Tabellen und Spaltenmüssen Sie bei Bedarf manuell löschen.


101

»Dann wirst du sehen, dass nicht der Löffel sich biegt, sondern du selbst.« (Matrix)

4 Erste Schritte

Nach den ersten Kapiteln mit viel Theorie und Vorbereitungsarbeiten, soll es nunetwas praktischer werden. Wir entwickeln mit Ihnen zusammen auf den folgen-den Seiten die erste Beispielapplikation.

In diesem Kapitel beschreiben wir vorwiegend die Arbeiten zum Einrichten undzur Nutzung üblicher Content-Management-Funktionalität. Wir zeigen, wie Siegrundlegende Funktionen nutzen, Seitenstrukturen anlegen und Inhalte und Lay-outs verwalten können. Mit den Kapiteln 5 und 6 arbeiten wir uns schließlich zukomplexeren Ufern vor und erweitern unsere Beispielapplikation um individu-elle Funktionen.

4.1 Unser Projekt: Usergroup mit Jobbörse

Sicherlich ist es nicht ganz einfach, eine Beispiel-Applikation zu finden, derenEntwicklung alle relevanten Themenbereiche abdeckt, die zur umfassenden Be-schreibung eines Content-Management-System wie SilverStripe erforderlich wä-ren.

Was bietet sich allerdings mehr an, als SilverStripe an dieser Stelle selbst zu the-matisieren? Wir werden aus diesem Grund auf den folgenden Seiten eine Web-site (Applikation) entwickeln, die SilverStripe-Entwicklern und ausschreibendenFirmen, die nach fähigen Programmierern suchen, eine Kommunikationsplatt-form bietet.

Bevor wir zum praktischen Teil kommen, sollten wir uns zunächst über die Struk-tur unserer Seite klar werden. Wie soll unsere Applikation später aussehen undwas soll sie alles können?

Mit den folgenden Anforderungen wollen wir die Funktionalität der Beispiel-applikation abstecken, die wir Laufe des Buches entwickeln werden:


102

Erste Schritte4

Darstellung statischer Seiten

Unsere Web-Applikation soll später natürlich »statische« Inhalte darstellen. Mit»statisch« ist hier die reine Darstellung von Text- und Bildmaterial gemeint, dieauf Interaktionen mit dem Benutzer verzichtet und inhaltlich auch über einen län-geren Zeitraum kaum variiert. Technisch gesehen handelt es sich natürlich nichtum statische, also bereits in ihrer Endform geschriebene Dokumente, da sie beijedem Seitenaufruf zusammengesetzt werden müssen und damit dynamischerNatur sind (auch wenn sie aus dem Cache kommen).

Für unsere Beispielapplikation möchten wir Dokumente mit allgemeinen Infor-mationen zum Thema bereitstellen.

Kommentarfunktion

Für einige ausgewählte Seiten soll es dem Besucher möglich sein, diese auch zukommentieren. Hierfür soll eine Form gewählt werden, wie sie auch von Blog-Systemen her bekannt ist.

Bereitstellung eines Kontaktformulars

Natürlich soll auch ein Kontaktformular integriert werden. SilverStripe bietethierzu bereits vorbereitete Funktionalitäten in Form einer Erweiterung über so-genannte Module. Mit Modulen sowie dem weiteren Ausbau zur Realisierungeiner Job-Vermittlungsplattform werden wir uns allerdings erst in den nächstenKapiteln befassen. Zu einem solchen Ausbau gehören:

Registrierung & Authentifizierung

Voraussetzung für unsere Vermittlungsplattform ist eine funktionierende Nutzer-Registrierung und ein Authentifizierungsmechanismus, da wir nur angemeldetenNutzern spezielle Funktionen zur Verfügung stellen möchten.

Stellenangebot-Katalogsystem

Kernstück unserer Applikation ist die Verwaltung der Stellenangebote: Hier kön-nen sich nicht angemeldete Besucher nach neuen Stellenangeboten umsehen. DieAngebote sind dabei speziellen Kategorien zugeordnet, die ein Auffinden erleich-tern sollen.

Registrierte Nutzer sollen in der Lage sein, Stellenausschreibungen im Systemschnell und einfach zu hinterlegen.


103

Seitenstruktur anlegen 4.2

Usergroup

Mit dem Zugriff auf die Stellenausschreibungen haben wir bereits einen Kommu-nikationskanal zwischen dem Bietenden und dem Suchenden geschaffen. Wirwollen hier allerdings noch einen Schritt weiter gehen und den Informationsflussauch in die Gegenrichtung öffnen. Dazu soll der Suchende ebenfalls eine Darstel-lungsmöglichkeit an die Hand bekommen und nach seiner Registrierung sein Pro-fil in Form eines Steckbriefes bereitstellen können. Projektvergebende Firmenhaben so eine weitere Möglichkeit, sich bereits vorab über die Fähigkeiten undKonditionen potenzieller Mitarbeiter zu informieren und auf diese zuzugehen.

Nachdem Sie nun wissen, was wir im Laufe des Buches noch alles umsetzen wer-den, möchten wir jetzt endlich mit den ersten Arbeiten für unsere Projektvermitt-lung beginnen. Dabei gehen wir davon aus, dass Sie zuvor eine »frische« Silver-Stripe-Installation mit dem Standard-Theme BlackCandy durchgeführt haben.

Falls Sie sich schon einmal das Endergebnis dieses Kapitels anschauen wollen, fin-den Sie ein fertiges SilverStripe-Projekt auf der Buch-CD im Verzeichnis 4_erste_schritte/. Im Ordner 4_erste_schritte/database.sql liegt ein Export der Datenbank,die Sie über ein Verwaltungstool wie phpMyAdmin in Ihre Datenbank überfüh-ren können. Der dort hinterlegte Administrator-Account hat den Benutzernamen»admin« und das Passwort »password«. Bitte denken Sie daran, Ihre eigene Da-tenbankkonfiguration über die _ss_environment.php-Datei anzugeben (siehe Ab-schnitt 3.8.3, »Environments«).

4.2 Seitenstruktur anlegen

Bevor wir nun erste Überlegungen zur Struktur und zu den Inhalten anstellen,sehen wir uns an, was der SilverStripe-Installer bereits eingerichtet hat. Rufen Siealso die Startseite Ihrer SilverStripe-Installation mit http://localhost/ auf:

Abbildung 4.1 SilverStripe-Startseite im BlackCandy-Theme


104

Erste Schritte4

Wie Sie an der Navigation im Kopfbereich der Seite erkennen können, wurdenmit der Installation bereits drei Seiten eingerichtet: Home, About Us und Con-

tact Us. Wir wollen nun überlegen, welche Seiten wir für unsere Webseite be-nötigen.

Unsere Vermittlungsplattform soll die folgende Navigationsstruktur erhalten:

� Home

� Jobs

� Entwickler

� Kontakt

Auf der Startseite Home sollen ein paar einführende Worte, eine kurze Vorstel-lung des Projektes hinterlegt werden. Über Jobs sollen später die ausgeschriebe-nen Projekte verwaltet werden können. Die Profile registrierter Programmiererwerden unter dem Punkt Entwickler abgelegt. Wie zu erwarten: Unter Kontakt

werden wir das Impressum und ein Mail-Kontaktformular einbinden.

4.2.1 Das CMS-Interface

Im ersten Schritt werden wir diese Struktur im SilverStripe-Backend anlegen.Loggen Sie sich dazu bitte als Administrator in das System ein.

Abbildung 4.2 SilverStripe-Backend – Startseite


105


Das Backend ist aufgeteilt in drei grundlegende Bereiche: die Hauptnavigation inder oberen Leiste, den Seitenbaum links und den Hauptbereich rechts. DerHauptbereich dient zur Ansicht und Bearbeitung von Daten und nimmt den größ-ten Teil der Seite ein.

Hauptnavigation

Über die Hauptnavigation erreichen Sie die grundlegenden Funktionen des Sys-tems: Über Site Content lassen sich alle Ihre Seiteninhalte pflegen. Files &

Images beherbergt das zentrale Dokumenten-Management-System, über welchessich die in den Ausgabeseiten eingebundenen Dateien verwalten lassen. Über Se-

curity gelangen Sie zum Benutzer-Management und über Comments können Siedie Kommentare der Benutzer verwalten, sofern Sie diese zugelassen haben.

Seitenbaum

Wie viele andere Content-Management-Systeme, organisiert SilverStripe ange-legte Seiten ebenfalls in Form eines Seitenbaumes. Das Framework nutzt dieseDaten auch zur automatischen Erstellung der Navigation für die zu generierendenSeiten.

Von einem »Baum« (also einer hierarchischen Verschachtelung) können wir zwarzum jetzigen Zeitpunkt noch nicht wirklich sprechen, das wird sich allerdingsbald ändern. Momentan finden Sie dort nur die Einträge zu den bereits auf derWebseite gesichteten Seiten Home, About Us und Contact Us. Zur Seite Page

not found kommen wir später noch.

Zur Umsetzung der besprochenen Seitenstruktur müssen wir nun die bestehen-den Seiten abändern beziehungsweise den Seitenbaum erweitern.

Deutsches Backend

Bevor wir mit den weiteren Arbeiten fortfahren, sollte die Backend-Sprache von Eng-lisch auf Deutsch umgestellt werden. Klicken Sie dazu am rechten unteren Rand auf Pro-

file und wählen in dem sich öffnenden Fenster unter Interface Language die ge-wünschte Sprache aus, also German (Germany). Speichern Sie die neue Einstellung miteinem Klick auf den Save-Button und schließen Sie das Fenster anschließend über Close.

Spätestens nach erneutem Laden der Seite (F5) sollte das Backend in deutscher Spracheerscheinen. Wir beziehen uns mit den folgenden Beschreibungen ebenfalls auf die deut-schen Bezeichnungen.

Abbildung 4.3 Deutsche Navigation


106

Erste Schritte4

4.2.2 Erste Änderungen

Der erste Punkt Home kann schon so bleiben, wie er ist, da unsere Startseite jaebenfalls »Home« heißen soll. Sehr gut.

Unser zweiter Navigationspunkt soll »Jobs« lauten. Dafür nehmen wir nun un-sere erste wirkliche Modifikation vor. Damit später nicht viel umsortiert werdenmuss, nutzen wir gleich die bestehende Seite About Us. Im Hauptbereich werdenIhnen nach dessen Auswahl diverse Editiermöglichkeiten zu Inhalt und Funktiondieser Seite angeboten.

Abbildung 4.4 SilverStripe-Backend – Inhalt

Dieser unterteilt sich in diverse Reiter, von denen für uns momentan aber nurzwei wichtig sind. Wir beschränken uns auf den standardmäßig geöffneten Be-reich Inhalt (Hauptteil und Metadaten).

Zunächst möchten wir die Seite About Us lediglich in »Jobs« umbenennen. DieImplementierung der notwendigen Programmlogik für diese Seite beschreibenwir erst im nächsten Kapitel.


107


Von URLs, Namen, Titeln und Navigationsbezeichnungen

SilverStripe kann insgesamt drei unterschiedliche Angaben zum Namen einer Seite ver-arbeiten: Seiten Name, Navigationsbezeichnung und Titel. Diese werden über die ReiterHauptteil und Metadaten verwaltet.

Wichtig ist zu verstehen, wie das Framework mit diesen Daten arbeitet. Hier zunächstdie Ausgabe, die aus diesen Beispieleingaben resultiert:

Abbildung 4.5 Seiteninformationen im Backend

Abbildung 4.6 Seiteninformationen im Frontend


108

Erste Schritte4

Sollten Sie es inzwischen noch nicht getan haben, so klicken Sie bitte jetzt in dasFeld Seiten Name, geben dort »Jobs« ein und bestätigen die Frage nach der Kor-rektur der URL mit OK. Den Eintrag unter Navigationsbezeichnung können Sieentweder löschen oder ebenfalls zu »Jobs« umbenennen. Beide Vorgehensweisenführen wie beschrieben zur selben Ausgabe.

Zum Speichern der Eingaben finden Sie rechts unten die Buttons Speichern und

Veröffentlichen sowie Speichern. Sie haben an dieser Stelle also die Wahl, obdie Änderungen anschließend auch sofort online zu sehen sind oder ob diese zu-nächst nur als Entwurf gespeichert werden sollen. Klicken Sie jetzt einfach aufSpeichern und Veröffentlichen.

Seiten Name

Dieser Parameter trägt (natürlich immer in Abhängigkeit des verwendeten Templates)die Überschrift einer Seite. Im BlackCandy-Theme wird diese Angabe in ein <h2> geklei-det. Wird hier keine Angabe hinterlegt, wird die Eingabe des Feldes Navigationsbezeich-

nung verwendet.

URLDie Suchmaschinen wird es freuen: SilverStripe bietet ausschließlich selbstsprechende,parameterlose URLs zur Adressierung der hinterlegten Seiten an. Diese Adresse könnenSie über den Reiter Metadaten für jede Seite individuell bestimmen. Sinnvollerweiseversucht das System hier, einen Abgleich mit den Namen der Seiten durchzuführen: So-bald Seiten Name abgeändert wird, möchte SilverStripe wissen, ob auch die zugehörigeURL gleichlautend verändert werden soll. Wird dies mit Ja bestätigt, führt eine Ände-rung des Seitennamens »Jobs« zur URL http://localhost/jobs/.

Momentan können leider noch keine URLs definiert werden, die eine weitere Adressie-rung in die »Tiefe« zulassen. Die Unterstützung von verschachtelten URLs mit komple-xeren Hierarchien ist allerdings in Vorbereitung.

NavigationsbezeichnungDie hier hinterlegte Bezeichnung wird zur Generierung der Navigation genutzt. Dies giltnicht nur für die Navigation im Frontend, sondern auch für den Seitenbaum im Backend.Wird für dieses Feld keine Angabe vorgenommen, wird die Angabe des Feldes Seiten

Name genutzt.

TitelDen Titel einer Seite erreichen Sie über den Reiter Metadaten. Der hier hinterlegte Sei-tentitel wird ausschließlich für das TITLE-Tag der jeweiligen Seite verwendet. Wird die-ses Feld nicht ausgefüllt, verwendet das Framework auch hier wieder die Angabe vonSeiten Name.

Hinweis: Die Vergabe doppelter Seitennamen, Navigationsbezeichnungen und Titel istzwar möglich, aber nicht zuletzt aus suchmaschinentechnischer Sicht auf keinen Fallempfehlenswert (mehr zu diesem Thema in Abschnitt 5.9, »Suchmaschinenoptimie-rung«). Die Definition doppelter URLs lässt das System (natürlich) nicht zu und versiehtdiese in einem solchen Fall mit einer fortlaufenden Zahl.


109


Zur Einrichtung des folgenden Navigationspunktes Entwickler gehen wir analogvor. Benennen Sie dazu die Seite Contact Us entsprechend um.

4.2.3 Neue Seiten erstellen

Jetzt fehlt noch ein letzter Navigationspunkt: Kontakt. Dazu muss eine weitereSeite in den Seitenbaum eingefügt werden.

Das Anlegen einer neuen Seite ist simpel: Klicken Sie auf den Button Seite erstel-

len. Unterhalb des Buttons wird nun ein Dropdownfeld eingeblendet.

Über dieses Eingabefeld können Sie bestimmen, von welchem Typ die neue Seitesein soll. Wie Sie sicherlich aus Kapitel 3, »Architektur«, noch in Erinnerung ha-ben, ist Page Standard für die Ausgabe einer regulären HTML-Seite. Da wir dieBackend-Sprache vorhin auf Deutsch umgestellt hatten, erscheint im Dropdown-feld der Seitentyp »Page« in deutscher Sprache und heißt damit »Seite«. Wir wer-den das Thema »Seitentyp« im nächsten Abschnitt noch genauer betrachten.

Zum Anlegen einer Seite wählen Sie also den Seitentyp »Seite« aus. Anschließendmüssen Sie dem Backend noch mitteilen, wohin die neue Seite abgelegt werdensoll. Dazu klicken Sie im Seitenbaum auf das Element, dem die neue Seite unter-geordnet werden soll. Da wir nun zwei Navigationspunkte einfügen möchten, diemit den anderen auf einer Hierarchie-Ebene liegen sollen, müssen Sie Seitenin-

halt auswählen.

Abbildung 4.7 Seitenbaum

Abbildung 4.8 Neue Seite anlegen


110

Erste Schritte4

Wenn Sie jetzt auf Los klicken, wird eine neue Seite des Typs »Seite« angelegt,die, Seiteninhalt untergeordnet, auf gleicher Ebene mit den anderen Seiten liegt.

Nach dem Anlegen wird die neue Seite automatisch selektiert, sodass Sie dieneuen Daten direkt in den Hauptbereich eintragen können.

4.2.4 Entwurf und Veröffentlichung

Bevor wir die neuen Daten eintragen, sollten Sie einen kurzen Blick auf die Ent-wurfsfunktionen von SilverStripe werfen. Sie mussten sich eben zwischen denButtons Speichern und Speichern und Veröffentlichen entscheiden. Silver-Stripe unterstützt also die Speicherung einer Entwurfsversion, die nur für CMS-Redakteure sichtbar ist. Unter der Haube speichert das System jede Änderung alsneue Version. Eine Seite kann also parallel in einer veröffentlichten Version undeiner Entwurfsversion existieren. Diese Funktionalität ist automatisch für alle Sei-tentypen verfügbar und stellt somit den Grundstein für ein einfaches Workflow-System zwischen verschiedenen Redakteuren dar.

Wie Ihnen sicherlich schon aufgefallen sein dürfte, ist der Eintrag unserer soebenneu angelegten Seite orange eingefärbt. Der Legende am unteren Ende des Sei-tenbaumes können Sie entnehmen, was es hiermit auf sich hat:

� Orange steht hier für »neu« und weist darauf hin, dass diese Seite zwar als Ent-wurf existiert, aber noch nicht für Besucher der Website zu sehen ist.

� Wurde eine Seite gelöscht, erscheint diese im Seitenbaum zunächst durchge-strichen in Rot. Diese Seite ist noch online zu sehen.

Abbildung 4.9 Markieren des Wurzelelementes

Abbildung 4.10 Neue Seite unterhalb des Wurzelelementes

Abbildung 4.11 Seitenbaum-Legende


111


� Wurde der Inhalt einer bestehenden Seite geändert, diese Änderungen bisheraber nur als Entwurf gespeichert, erscheint der entsprechende Eintrag im Sei-tenbaum in Grün.

Im Prinzip können Sie sich also merken: Erscheint ein Eintrag im Seitenbaumnicht in Schwarz, so enthält der Entwurfsbereich andere Inhalte, als diejenigen,die aktuell veröffentlicht (publiziert) sind.

Auch wenn eine Seite noch nicht online ist, können Sie eine Vorschau anfordern.Klicken Sie dazu links unten neben Seitenansicht auf Entwurf.

Wie Sie auch an der Navigation im sich neu öffnende Fenster erkennen können,wird die neue Seite hier berücksichtigt und angezeigt.

Staging-Verwendung

Nachdem wir nun geklärt haben, was die Farbe Orange im Seitenbaum für unsereArbeit bedeutet, können Sie nun den neuen Seitennamen »Kontakt« eintragen.Wie bereits vorhin beschrieben, können Sie anschließend auf Speichern und

Veröffentlichen klicken.

Der Eintrag im Seitenbaum wechselt von Orange zu Schwarz und zeigt damit an,dass die neue Seite veröffentlicht, also online erreichbar ist.

Ein Klick auf Speichern hätte Ihre Änderungen nur als Entwurf gesichert und un-serem Eintrag im Seitenbaum wäre seine orangene Farbe erhalten geblieben. DerButton Von Entwurf-Seite löschen hätte unsere neue Seite komplett gelöscht.

4.2.5 Drag & Drop

Wir haben nun gerade unsere erste eigene Seite eingefügt. Wenn Sie zwischen-zeitlich nichts anderes ausgewählt haben, sollte die neue Seite noch aktiv sein.

Würden Sie jetzt zum Anlegen einer weiteren Seite oberhalb des Seitenbaumesauf den Button Los klicken, würde diese als Unterseite von unserer eben angeleg-

Abbildung 4.12 Link zur Entwurfsansicht aus dem CMS

Abbildung 4.13 Aktuelle Daten speichern oder löschen


112

Erste Schritte4

ten Seite eingefügt werden. Sie sollten also zuvor wieder die Hauptebene desBaums (Seiteninhalt) anwählen und erst anschließend die neue Seite erstellen.

Sollten Sie das aber vergessen haben oder später einmal aus anderen Gründen dieAnordnung der Seiten ändern wollen, so können Sie das jederzeit tun: Verschie-ben Sie einfach die Seiten im Seitenbaum mit der Maus an die gewünschte Stelle.Aktivieren Sie dazu die Checkbox Erlaube Drag & Drop neuordnen.

Die Seiten lassen sich nun zwischen andere platzieren oder – wenn Sie eine Seiteauf eine andere verschieben und dort »fallen lassen« – als Unterseite einbinden.Natürlich lassen sich diese dort auch wieder »herausholen« und auf eine andereHierarchie-Ebene versetzen.

Ordnen Sie die Seiten also nun so an, wie vorhin beschrieben.

Wir haben nun alle notwendigen Seiten für unser Projekt angelegt. Bisher habenwir diesen Seiten keine besondere Funktionalität und lediglich den Seitentyp»Seite« zugewiesen.

Mit der Auswahl des Seitentyps wird entschieden, welches Layout und welcheProgrammlogik eine Seite erhalten soll. Wie Sie sich sicherlich noch aus Kapitel3, »Architektur«, erinnern, weisen wir mit dem Seitentyp eine eindeutige MVC-Definition zu. Der Seitentyp ist also für den Redakteur die logische Verbindungzwischen CMS und MVC-Framework.

Den Typ einer Seite legen Sie zwar schon beim Anlegen einer neuen Seite fest,können diesen aber auch später jederzeit über den Reiter Verhalten ändern.

Standardmäßig bietet SilverStripe die folgenden Seitentypen an:

Abbildung 4.14 Seite über Drag & Drop verschieben

Abbildung 4.15 Seitentypen


113

Seiteninhalt einfügen 4.3

Seite

Ist die Basis einer jeden Seite für die Ausgabe (Klasse: Page).

Weiterleitung

Mit diesem Seitentyp der Klasse RedirectorPage legen Sie keine wirkliche Seiteim System an, sondern verweisen auf eine andere. Es handelt sich hierbei nichtum eine Weiterleitung, sondern um eine direkte Verlinkung zu einer beliebigenAdresse. Mit dieser Methode könnten Sie beispielsweise einen externen Link inIhre Hauptnavigation aufnehmen.

Virtuelle Seite

Unter einer virtuellen Seite der Klasse VirtualPage versteht SilverStripe eineKopie einer anderen Seite, die zwar ihre eigene Adresse erhält, inhaltlich jedochimmer mit dem Original übereinstimmt.

Fehlerseite

Sicherlich ist Ihnen im Seitenbaum die Seite Page not found aufgefallen. Dieserist der Seitentyp »Fehlerseite« zugewiesen, mit der Klasse ErrorPage. Sie könnenes sich schon denken: Hierbei handelt es sich um die Seite, die bei einer Fehler-meldung ausgegeben wird. Zwar dürfte eine Fehlermeldung mit dem HTTP Sta-tuscode 404 Not Found zur häufigsten Meldung zählen, die Sie abfangen und in-dividuell kommentieren wollen, mit SilverStripe können Sie aber auch nochweitere Fehlermeldungen individualisieren. In Frage kommen unterschiedlicheServerantworten mit den HTTP-Statuscodes von 400 bis 505.

4.3 Seiteninhalt einfügen

Nachdem wir die grundlegenden Strukturen für unsere Anwendung angelegt ha-ben, werden wir diese nun mit etwas Inhalt füllen. Beginnen werden wir mit derSeite Home, die wir mit Textmaterial und einer Grafik bestücken möchten.

Abbildung 4.16 SilverStripe-Seitentypen


114

Erste Schritte4

4.3.1 Einbinden von Text

SilverStripe nutzt für die Eingabe und Verwaltung von Texten den JavaScript-ba-sierten Editor TinyMCE1, dessen Bekanntschaft Sie sicherlich schon beim erstenÖffnen von SilverStripe gemacht haben. Über ihn können HTML-basierte Inhalteohne Kenntnisse über die genaue Syntax erstellt werden. Der Editor erstellt dabeiinnerhalb des Eingabebereiches eine Vorschau der späteren Ausgabe.

Sollten Sie ihn noch nicht bewusst wahrgenommen haben, so holen wir das jetztnach. Klicken Sie im Seitenbaum jetzt auf Home und wählen Sie den Reiter In-

halt � Hauptteil aus.

Zum Anlegen der Struktur hatten wir uns bisher nur mit den Eingabefeldern Sei-

ten Name und Navigationsbezeichnung befasst. Für uns nun wichtig – undkaum zu übersehen – ist das große Eingabefeld Inhalt mit einem Beispieltext ausder Standardinstallation (falls Sie den nicht schon gelöscht haben).

Die hier hinterlegten Texte können Sie über die TinyMCE-Toolbar formatieren, diesich oberhalb des Textfeldes befindet.

Die meisten der aufgeführten Symbole dürften bereits aus diversen Textverarbei-tungsprogrammen geläufig sein, weshalb wir im Folgenden nur die wichtigstenBearbeitungsmöglichkeiten besprechen. Alle Symbole sind übrigens mit Kurzhin-weisen (Tooltips) versehen, die beim Überfahren mit der Maus die jeweilige Funk-tion erklären.

Die obere Zeile der Toolbar enthält in erster Linie die bekannten Optionen zurFormatierung und Ausrichtung des Textes. Außerdem können Sie hier auch Lis-ten (nummeriert und unnummeriert), Trennlinien und Sonderzeichen einfügen.

Die zweite Zeile enthält ein paar webspezifischere Möglichkeiten. Hier solltenwir uns kurz die Klemmbrett-Funktionen ansehen, die Sie gut gebrauchen kön-nen, wenn Sie Texte aus anderen Anwendungen wie Microsoft Word oder Open-Office übernehmen möchten.

1 http://tinymce.moxiecode.com

Abbildung 4.17 TinyMCE-Toolbar

Abbildung 4.18 Klemmbrett-Operationen von TinyMCE


115


Dies ist vor allem für Redakteure interessant, die die Erstellung ihrer Texte lieberüber ein traditionelles Textverarbeitungsprogramm vornehmen. Der Text kannanschließend einfach in die Zwischenablage kopiert und über eine der folgendenKlemmbrett-Funktionen in das System eingefügt werden.

Kopieren aus der Zwischenablage

Über einen Klick auf das erste Klemmbrett-Symbol kopieren Sie alle Inhalte derZwischenablage in das Feld Inhalt. Je nachdem, welche Inhalte (und Steuerzei-chen) sich in der Zwischenablage befunden haben, kann das jedoch zu uner-wünschten Ergebnissen führen.

Sollte es also Probleme bei der Formatierung geben, können Sie die Steuerzei-chen vor dem Einfügen löschen. Genau das erledigen Sie mit dem zweitenKlemmbrett-Symbol.

Kopieren von ausschließlich lesbaren Zeichen

Über das Klemmbrett-Symbol mit dem »T« kopieren Sie ebenfalls die Daten ausder Zwischenablage, allerdings werden wirklich nur lesbare Zeichen kopiert.Diese Methode bietet sich vor allem dann an, wenn Sie zuvor formatierte Textein TinyMCE neu formatieren möchten.

Kopieren von Word

TinyMCE stellt konkret für die Einbindung von Word-Texten einen speziellenImportfilter bereit, der Word-spezifische Steuerungszeichen entfernt, die manch-mal zu unvorhersehbaren Formatierungsproblemen führen können. Wählen Siein diesem Fall das Klemmbrett-Symbol mit dem »W«.

Text für die Homepage

Für die Seite Home möchten wir nun einen Text, den wir in einem Textverarbei-tungsprogramm erstellt haben, in SilverStripe einfügen.

In diesem Beispiel wurde das frei verfügbare OpenOffice2 als Texteditor verwen-det. Lassen Sie Ihrem kreativen Schreibfluss freien Lauf und erstellen Sie einenkurzen Werbetext für unser Jobportal. Diesen Text kopieren wir nun in die Zwi-schenablage (Strg)+(C)/(°)+(C) und wechseln zum SilverStripe-Backend.

Verwenden auch Sie OpenOffice zur Erstellung Ihres Textes, können Sie diesenaus der Zwischenablage direkt und ohne Verwendung der Klemmbrett-Funktio-nen in das Feld Inhalt kopieren (Strg)+(V)/(°)+(V).

2 http://www.openoffice.org


116

Erste Schritte4

TinyMCE sollte die Steuerzeichen alle erkannt und Formatierungselemente kor-rekt übertragen haben.

Abbildung 4.19 Texterstellung in OpenOffice

Abbildung 4.20 Eingefügter Text aus OpenOffice


117


4.3.2 Verlinkungen

Unser Text enthält ein paar Passagen, die wir mit einem direkten Link zur Seitedes Angebotes ausstatten möchten. Markieren Sie dazu einfach den Text im Edi-tor, den Sie verlinken möchten.

In der Toolbar finden Sie die Symbole, mit denen Sie einen Link für diesen Text-bereich definieren können:

Klicken Sie jetzt auf das linke Ketten-Symbol. Rechts des Hauptbereiches öffnetsich nun ein weiterer Bereich, über den Sie die Parameter des Links eingebenkönnen.

Abbildung 4.21 Verlinkungen einfügen

Abbildung 4.22 Markierten Text verlinken oder Link entfernen

Abbildung 4.23 Einfügen eines Links


118

Erste Schritte4

Sie können nun über die Box Verweis zu die Art des neuen Links festlegen. Mög-lich sind hier die folgenden Optionen:

Seite auf der Website

Legt einen Link zu einer anderen im System angelegten Seite an.

Andere Website

Für externe/absolute URL-Angaben können Sie diese Option nutzen.

Anker auf dieser Seite

Setzt einen Link zu einem Anker auf derselben Seite, um beispielsweise zu weiterunten liegenden Abschnitten springen zu können.

E-Mail-Adresse

Diese Option nutzen Sie zum Einfügen einer anklickbaren E-Mail-Adresse, überdie sich ein E-Mail-Client öffnen soll.

Datei herunterladen

Über diese Option definieren Sie einen Link zu einer im System hinterlegten Da-tei, die Sie zum Download anbieten möchten. Wie und wo Sie Dateien in Silver-Stripe hinterlegen können, erklären wir gleich im folgenden Kapitel.

Da wir für die markierte Textpassage einen Link zur Seite Entwickler setzenmöchten, ist die Auswahl des Radio-Buttons (Seite auf der Website) korrekt. Spe-zifizieren Sie aus dem Dropdownfeld Seite noch die Zielseite. Tragen Sie bei Be-schreibung des Verweises einfach »zu den Stellenausschreibungen« ein. DieserText erscheint später als Tooltip, wenn Sie mit der Maus über den Link fahren.Da wir für die Zielseite (bisher) keinen Anker definiert haben, müssen Sie hierkeine Angaben vornehmen und können das Feld leer lassen. Da sich die neueSeite auch nicht in einem neuen Fenster öffnen soll, lassen wir die Checkbox imunteren Bereich unberührt und klicken zum Speichern auf Verweis einfügen.

Vorsicht

Der erzeugte Link ist in keiner Weise kodiert und kann von diversen Scripten ausgelesenwerden, die die Adresse gerne auch dazu nutzen, Ihr E-Mail-Postfach mit ausreichendSpam zu versorgen.


119


4.3.3 HTML-Ansicht

Der eben markierte Text erscheint nun unterstrichen. Überprüfen wir noch kurz,welchen HTML-Code TinyMCE da generiert hat. Klicken Sie dazu auf den HTML-Button der TinyMCE-Toolbar.

Das sich öffnende Fenster zeigt Ihnen das HTML-Äquivalent Ihres Inhaltes an.

Wie Sie sehen, ist Beschreibung des Verweises als title-Atttribut in den Linkder E-Mail-Adresse eingebunden worden. Sie können über die HTML-Ansicht na-türlich selbst noch weitere Änderungen am HTML-Text vornehmen. Sollten Sieden Link beispielsweise wieder löschen wollen, können Sie dies hier erledigen.Einfacher geht dies aber, wenn Sie die HTML-Ansicht verlassen, den Cursor mitder Maus auf den gerade definierten Link setzen und das Symbol zum Löscheneines Links anklicken, welches passenderweise eine zerbrochene Kette darstellt.

Abbildung 4.24 Aufruf der HTML-Ansicht

Abbildung 4.25 HTML-Code-Ansicht

Abbildung 4.26 Link entfernen (rechts)


120

Erste Schritte4

Nach den vorgenommenen Änderungen am Code können Sie diesen über einenKlick auf Aktualisieren speichern. Andernfalls klicken Sie zum Schließen desFensters einfach auf Abbrechen.

Vergessen Sie abschließend nicht, Ihre Änderungen auch zu speichern (Speichern

und Veröffentlichen). Sollten Sie versuchen, die Seite ohne eine Speicherungzu verlassen, macht SilverStripe Sie darauf aufmerksam.

4.4 Verwaltung von Dateien und Bildern

Bisher haben wir uns lediglich auf das Hinterlegen von Text beschränkt. Nun solletwas Farbe ins Spiel kommen.

TinyMCE ist nicht nur zur Formatierung von Texten gut einsetzbar, sondern kannauch Bildmaterial sehr einfach und komfortabel für die Ausgabe einbinden.Damit auf Bilder und Grafiken zugegriffen werden kann, müssen diese zunächstin das System hochgeladen werden.

Wie Sie sich sicherlich erinnern, werden hochgeladene Dateien von SilverStripeim Ordner assets abgelegt. Damit Sie die Dateien nicht manuell über ein Trans-portformat wie FTP auf dem Server platzieren müssen, bietet SilverStripe imBackend eine entsprechende Verwaltung an. Diese erreichen Sie über die Haupt-navigation über Dateien & Bilder.

Auch dieser Bereich präsentiert sich in bekannter Weise: Im linken Drittel findenSie einen Verzeichnisbaum, der Ihnen Auskunft über die angelegten Ordner gibt.Die hier dargestellten Ordner befinden sich auch tatsächlich auf dem Server anangegebener Stelle.

Code-Validator

TinyMCE versucht, den HTML-Code so zuzubereiten, dass er den XHTML-Spezifikatio-nen genügt. Wenn Sie also Code manuell einfügen, ist es nach dem Speichern durchausdenkbar, dass TinyMCE diesen umgeschrieben hat.

Außerdem werden nur definierte Tags akzeptiert. Verwenden Sie Tags, die dem Editorunbekannt sind, werden diese gelöscht, was natürlich zu unvorhersehbaren Ergebnissenführen kann.

TinyMCE lässt sich jedoch sehr gut individuellen Bedürfnissen anpassen. Weitere Infor-mationen hierzu erhalten Sie auf der TinyMCE-Entwicklerseite unter http://tinymce.moxiecode.com/.


433

Index

.htaccess 84_config.php 94, 97, 405_ss_environment.php 97, 981:n-Relation 75, 154, 213

A

ACL (Access Control Lists) 262ActionScript 381Active Record (Design Pattern) 71Administrator 49Administratorrechte 140Adobe Flash 381Adobe Flex 381Agile Softwareentwicklung 32AJAX 33Akismet-Spam-Filter 95Apache 39, 285

AddHandler 52AddType 52AllowOverride 285ErrorDocument 303Logfiles 299mod_rewrite 299Port 80 47RewriteBase 52VirtualHost 285

Aptana Studio 54, 292Architektur 61Architekturmuster 30Archivierungssystem 128ArrayData 402ASCII 328AssetAdmin 140Assets (Ordner) 80, 285Auth_OpenID 429Authenticator

register_authenticator 94set_default_authenticator 94

Authentifizierungsmechanismus 94automatisierte Tests 311

B

Backend 25, 33, 90Backup

Dateisystem 297Datenbank 57MySQLDumper 57

BasicAuth 94disable 94

BBCode 278BBCodeParser 95Bearbeitungsverlauf 398Benutzer

anlegen 137Rechtevergabe 91, 138Verwaltung 105

Berechtigungen 139Beschleunigung 304Betriebsarten 95Bildeditor 122Bilder 120

Ausrichtung 127Bildmanipulation 241

BlackCandy 49, 79, 83, 141Bleeding Edge 26BlogEntry 197BlogHolder 197BSD-Lizenz 35, 345Bugtracker 59Buildbot 313Businesslogik 63Bytecode Caches 304

C

Cache 85, 89Callbacks 188, 404Captcha 425Casting 282CDN (Content Delivery Network) 309changelog 298CI (Continuous Integration) 313ClassInfo 85CMS (Content-Management-System) 25CMS Logo 346


434

Index

CMSMain 91, 92, 140Code Listings 27CollectionController 252CollectionPage 253, 413CommentAdmin 140Comments (CMS Bereich) 105ComplexTableField 158ComponentSet 156

add 193getIdList 191remove 193

ContentController 88dataRecord 187

ContentNegotiator 95, 329disable 95

Controller-Klasse 88run 88, 89

Convention over Configuration 62Convert (Klasse) 276Cookies 287CRUD 72, 218CruiseControl 313CSS-Stylesheets

editor.css 144layout.css 144typography.css 144

CSV (Comma-separated Values) 375CSVBulkLoader 375

columnMap 379duplicateChecks 380relationCallbacks 380

CSV-Import 375cURL 40, 45CurrentMember 188customize/customise 238Cutting Edge 26CVS (Concurrent Versions System) 289

D

Daily Builds 298DataObject

add_extension 400api_access 388Attribute 152belongs_many_many 155canCreate 262canDelete 262canEdit 262

DataObject (Forts.)canView 262column 251Created- Attribut 408db Array 72field_labels 223get 73get_by_id 73get_one 73getCMSFields 158, 233getComponentsQuery 364getFrontendFields 229has_many 154has_one 154lLokalisieren 222many_many 155many_many extraFields 156onAfterWrite 188onBeforeDelete 188onBeforePublish 188onBeforeWrite 188Relationen 153scaffoldFormFields 233stat 230Unterschied zu SiteTree 151

DataObjectDecorator 398, 406extraStatics 401, 407updateCMSFields 401

DataObjectSet 156, 175, 176merge 371toDropDownMap 369

DataObjectTest 314Datei-Anhänge 419Dateien 120Dateien & Bilder 120Dateigröße 125Dateipfade 284Dateitypen 284Datenbank

Backup 294Dump 296Import 296limit 73

DBFieldBoolean 153Currency 153Date 153Decimal 153Enum 152


435

Index

DBField (Forts.)HTMLText 152, 276, 278HTMLVarchar 152, 276, 278Int 153Percentage 153SSDateTime 153Text 152, 276Varchar 152

Deaktivieren von PHP 285Decorator (Design Pattern) 398Design Patterns 30, 61Dev (Betriebsmodus) 94dev/build 164Developer-Modus 50, 96Director 86

addRules 94isDev 97isLive 97isTest 97Mapping 87Priorität 87Rules 87set_dev_servers 94, 96set_environment_type 94, 96, 301

Directory Traversal 242Dispatcher 84DOCTYPE 95Doctype (HTML) 329DPS 418Drag & Drop 111DRY (Don't repeat yourself) 64

E

EasyEclipse 53, 292Eclipse 53E-Commerce 418E-Mail 190

send 196Entities 330Entwicklungsumgebungen 52Entwurfsmuster 30, 61Environment 97Error (Logging) 300Errorhandler 300ErrorPage 78, 113, 302Erweiterungen 396Escape-Typen 276

ATT 277

Escape-Typen (Forts.)JS 277RAW 277SQL 277XML 277

ExternalInterface 387Externals 292Extreme Programming 312

F

Fehler melden 59Fehlerbehandlung 299Feldtypen 276FieldSet 158, 184

addFieldsToTab 369addFieldToTab 158, 338, 363, 401getCMSFields 162push 239removeFieldByName 251

File 78, 240Files & Images 105FilesystemPublisher 308Firebug 387Fixtures 319Flash 381

CSS-Stylesheets 391Einbinden in HTML 392Erlaubte HTML-Tags 389XPath 390

Flickr-API 422Folder 78Form 184

disableSecurityToken 277saveInto 186

form.css 144FormAction 184, 349FormField

jsValidation 397validate 397

FormulareSicherheit 235

FormularFelderCheckboxField 163CheckboxSetField 163DateField 163DropdownField 163EmailField 163HeaderField 163


436

Index

FormularFelder (Forts.)LiteralField 163NumericField 163OptionsetField 163TextField 162

Formularfelder 162CheckboxSetField 369ComplexTableField 158DropdownField 251EmailField 234ImageField 343NumericField 369, 397TextareaField 162TextField 369

Forum 419Frontend 25FTP 120, 428Functional Tests 321

G

Gallery 421GD

croppedResize 343resizeByWidth 243setQuality 243

Gdata-API 424GDlib 40GIF 125Globalisierung 327Google Analytics 362Google Sitemap 205Google Summer of Code 36Google-API 427GPL-Lizenz 35Grafiken 120Group 78Group_Members 78

H

has_many 75, 154has_one 74, 154, 241Hooks 188, 404htaccess 285HTML

Entities 276Valider Code 204

HTML-Ansicht 119

HTTPContent-Type 329Referrer 359

HTTP Statuscodes301 Moved Permanently 204301 Permanent Redirect 357302 Found 357307 Temporary Redirect 357404 Not Found 205

HTTP- Statuscodes404 Not Found 303500 Server Error 303

HTTPRepsonse 384HTTPResponse 89, 323HTTP-Statuscodes 303

I

i18n (Internationalization) 327i18nTextCollector 334Image 241, 243

Upload 241IMAP 428install.php 84Installation 43Installer 84Interpolation 125IRC-Chat 58ISO 8859 328

J

JPG 125jQuery 239JSMIN 307JSON 388Jsparty (Ordner) 80

K

Kapselung 62Klemmbrett 114Kommentare 198Komprimierung 304Konfiguration 93Kontaktformular 133Konvention vor Konfiguration 32


437

Index

L

l10n (Localization) 327Ländercodes 331Landessprache 327LDAP 428LeftAndMain 92

init 93require_css 348set_loading_image 347setLogo 346

lighttpd 39, 42LinkingMode 176LinkOrCurrent 176LinkOrSection 176Links 205Linux 43Live-Modus 96Locale 336log_errors_to 301Logging 300Lokalisierung 327

M

m:n-Relation 77, 155, 213Mac OS X 46main.php 85MAMP 46ManifestBuilder 52, 82, 85

Priorität 90many_many 76, 155Mashups 265, 427Member 78, 400, 406

currentMember 190dekorieren 406Member_Validator 231

Metadaten 107Metatags 204Microsoft Word 115mod_rewrite 39, 52ModelAdmin 140, 217, 377

getMenuTitle 219managed_models 219model_importers 380url_segment 219

ModelAsController 88, 356Modularität 34

Module 34, 396, 417Auth_External 428Blog 197dDekorieren 406Erstellung 404Flickr Service 422Gallery 420Genericviews 253Google Maps 427googlesitemaps 81Multiform 228Recaptcha 425Unterscheidung zu Widgets 81userforms 133

MSSQL 72MultiForm

getFields 229getSavedStepByClass 237getValidator 231

MultiFormStep 228MVC (Model View Controller) 30, 62

Controller 64, 65Model 64, 65View 64, 67

Mysite (Ordner) 79MySQL 39, 49

auto_increment 297Client 58mysqladmin 58mysqldump 58mysqlimport 58

MySQLDumper 57

N

Navigationsbezeichnung 107NetBeans 56Netbeans 293Notice (Logging) 300

O

Objectadd_extension 407

OCR 425OpenID 429OpenOffice 115Open-Source 29


438

Index

OrdnerZugriffsrechte 283

ORM (Object Relational Mapping) 31, 71

P

Page 113Page type 65PageComment 78

enableModeration 95Partials 177Patches 395PayPal 418PEAR 313Performance 303Permission 78

check 262checkMember 262

Permission (Klasse) 89Permission-Codes 261, 264PermissionProvider 265PHP Logfile 300PHPEclipse 53phpinfo 52PHP-Konfiguration

display_errors 300error_log 300ini_set 300log_errors 300upload_max_filesize 297

phpMyAdmin 294PHPSESSID 91PHPUnit 311, 313Plugins 396PNG 125POP3 428PositiveNumericField 397PostgreSQL 72Prototype (Javascript) 81Prozeduraler Code 94

R

Rechtevergabe 91RecordController 253RedirectorPage 78, 113, 204Regular Expressions 374Relationen 73

1:n 74

Relationen (Forts.)m:n 77, 213

renderWith 238Repository 290RequiredFields 185Requirements 149, 304

block 150clear 150combine_files 305css 149customCSS 150customScript 150javascript 149write_js_to_body 307

REST 266RESTfulServer 265, 388

Client 271Rich Internet Applications 381RootURLController 88Routing-Regeln 94RSS-Feeds 419RsyncMultiHostPublisher 309

S

Sake (Sapphire Make) 316Salt 95sapphire 30, 85Sapphire (Ordner) 80SapphireTest 316Scaffolding 218, 225Schema-Update 79script.aculo.us 81SearchContext 248SearchFilter 248SearchForm 349

setPageLength 353Security

encrypt_passwords 95set_password_encryption_algorithm 95setDefaultAdmin 95

Security (CMS Bereich) 105Security Klasse 92SecurityAdmin 140Seitenbaum 105

Ordnen 112Seiteninhalt 112Seitentypen 112

BlogEntry 197


439

Index

Seitentypen (Forts.)BlogHolder 197Fehlerseite (ErrorPage) 113RedirectorPage 78Seite (Page) 113Virtuelle Seite (VirtualPage) 113Weiterleitung (RedirectorPage) 113

SEM (Search Engine Marketing) 199SEO (Search Engine Optimization) 199Session Fixation 287Session Hijacking 286Sessions 286Shared-Hosting 33, 51Shared-Secret 279Shop 418Sicherheitsgruppen 138Sicherung 289SilverStripe 29SilverStripe Limited 35, 36SimpleTest 311Singleton (Design Pattern) 230, 403Site Content 105sitemap.xml 206SiteTree 78

Unterschied zu DataObject 151URLSegment 168

SiteTree_lang 335SiteTree_Live 78SiteTree_versions 78Spam 425SpamProtection 95Sprachcodes 331Sprachwahl 338sprintf 333SQLite 72SQLQuery 364SSViewer 89

parseTemplateContent 89process 89set_theme 95, 142

Stage (Versioned) 399Staging im CMS 33StaticPublisher 308Statische HTML-Dokumente 308Statische Variablen 402Statistiken 358Subversion

branches 291Checkout 290

Subversion (Forts.)Command Line Client 293Commit 290tags 291trunk 291Update 290

Suche (Volltext) 349Suchmaschinenoptimierung 199

Keyword-Analyse 201Offsite 201, 206Onsite 201PageRank 206tTabellenloser Aufbau 203Verlinkungsdichte 206

Suchmaschinenrobot 200Support 58SVN (Subversion) 289SWFObject 393SWFUpload 80Syntaxfehler 300Systemvoraussetzungen 39, 50

T

TableListField 358setFieldCasting 363setFieldFormatting 363setPermissions 363

TagCloudWidget 369Tags 213Templates 165

$Breadcrumbs 168$Content 167$Form 167$Layout 167$MetaTags 167$PageComments 168Bedingte Anweisungen 170Blöcke 172Controls 165Dateipfade 238Includes 177Menüstatus 176Namenskonventionen 67Platzhalter 167renderWith 238Schleifen 172Syntax 71Tabellenlos 203


440

Index

Templates (Forts.)Vererbung 166Verschachtelung 71

Templates (Ordner) 67Temporäre Dateien 284Test (Betriebsmodus) 94Test Case 314Test-Driven Development 312Testing 311Test-Modus 96Themes 34, 79, 141

Aktivierung 83mysite 141

Thumbnails 243Tickets 59TinderBox 313TinyMCE 114, 330Toolbar 114Tracking 360Translatable 335

U

Übersetzung 327_t()-Funktion 330, 331Code 330Seiteninhalte 335Standardsprache 336Templates 330

Unicode 327, 329Unit Tests 316

Annahmen 318Upgrade 297Upload 123Uploads (Ordner) 121URL 107URL Parameter

flush 85isDev 96

URL-Format 205URLSegment 357, 413UTF-8 329

V

Validator 244Validator (TinyMCE) 120Validierung 185, 281Vererbung 68, 396

VerlinkungenAnker 118Email 118Namenskonvention 144

Versioned 399Versionierung 33Versionierung von DataObjects 398Versionskontrolle 289Versionsnummer 129ViewableData 277VirtualHost 285VirtualPage 78, 113, 204

W

WAMP 43Warning (Logging) 300Webhosting 48Webinstaller 48Weiterleitung 204, 354WidgetArea 78, 408WidgetAreaEditor 409Widgets 34, 78, 396

Datenbank- Präfix 410Deinstallation 82Erstellung 407Installation 82Templates 411

Windows 43Workflow 110Worldpay 418WYSIWYG 388

X

XCache 46, 304XHTML 34, 120XML 381, 382XSS (Cross-Site Scripting) 275

Y

YAML 203, 320Youtube Service 424

Z

Zeichensätze 327Zitate 26Zwischenablage 115


SilverStripe · Steven Broschart, Ingo Schommer SilverStripe 1295.book Seite 1 Mittwoch, 4. Februar...

Documents

Transcript of SilverStripe · Steven Broschart, Ingo Schommer SilverStripe 1295.book Seite 1 Mittwoch, 4. Februar...