Anhang B: Metaphern in der Führung komplexer ... - Universität Zürich

Entwicklung eines Content Management
Systems für die MIO-Lernumgebung
Diplomarbeit im Fach Informatik
vorgelegt von
Christian Ziegler
Bettingen,Basel,CH
Matrikelnr.: 95-915-021
Angefertigt am
Institut für Informatik
der Universität Zürich
Prof. Dr. H. Schauer
Betreuer: Dr. Andreas Huber
Abgabe der Arbeit: 08.10.2002

CMS für die MIO-Lernumgebung Inhaltsverzeichnis
Inhaltsverzeichnis
Inhaltsverzeichnis .......................................................................................................................2
Abbildungsverzeichnis ................................................................................................................5
Tabellenverzeichnis ....................................................................................................................6
Zusammenfassung/Abstract ........................................................................................................7
1. Ausgangslage ..........................................................................................................................8
1.1. Voraussetzungen .............................................................................................................8
1.2. Problemstellung ...............................................................................................................8
1.3. Rahmenbedingungen .......................................................................................................9
1.4. Gliederung der Arbeit .....................................................................................................9
2. Einleitung ..............................................................................................................................10
2.1.Verwendete Technologien .............................................................................................10
2.1.1. Apache ...................................................................................................................10
2.1.2. MySQL ..................................................................................................................10
2.1.3. PHP ........................................................................................................................10
2.1.4. XML/XSL/HTML .................................................................................................11
2.1.5. PhpMyAdmin ........................................................................................................13
2.2. Einführung in das konzeptuelle Datenbankschema ......................................................14
2.2.1. Konzepte ................................................................................................................14
2.3. Begriffsabgrenzung .......................................................................................................16
2.4. Einführung Content Management System ....................................................................17
2.4.1. Herkömmliches Webpublishing vs. Content Management ...................................17
2.4.2. Kernprinzip von Content Management Systemen .................................................17
2.4.3. Content Life Cycle ................................................................................................18
2.4.4. Anforderungen an ein Content Management System ............................................20
2.5. Open source CMS .....................................................................................…................23
3. Anforderungsspezifikation des Content Management Systems ..........................................24
3.1. Systemanforderungen ...................................................................................................25
3.2. Objektmodell ................................................................................................................30
3.3. Anwendungsfall-Diagramm .........................................................................................32
3.4. Detailanalyse der Hauptanwendungsfälle ....................................................................33
3.4.1. Lehrtext anschauen ................................................................................................34
3.4.2. Lehrtext erstellen ...................................................................................................35
3.4.3. Lehrtext editieren ...................................................................................................36
3.4.4. Lehrtext prüfen ......................................................................................................37
3.4.5. Metadaten verwalten .............................................................................................38
3.4.6. Archiv ....................................................................................................................39
3.5. Zustandsmodelle ...........................................................................................................40
3.6. Analyse des bestehenden Designs .................................................................................42
4. Architekturentwurf ................................................................................................................43
4.1. Datenbankstruktur .........................................................................................................44
4.2. Trennung von Inhalt und Layout ...................................................................................47
2

CMS für die MIO-Lernumgebung Inhaltsverzeichnis
4.3. Struktur der Website .....................................................................................................48
5. Implementierung ...................................................................................................................54
5.1. Genereller Skriptaufbau ................................................................................................55
5.2. Verwendung von $_POST ............................................................................................56
5.3. edit_xml.php .................................................................................….......…..................57
5.4. XML, XSL und DTD ....................................................................................................64
6. Proof of Concept ...............................................................................................................…65
7. Benutzerdokumentation ........................................................................................................67
7.1. Einführung .....................................................................................................................67
7.2. Bedienung .....................................................................................................................68
7.2.1. Hauptfenster ..........................................................................................................68
7.2.2. Funktionen .............................................................................................................69
8. Zusammenfassung und Ausblick ..........................................................................................84
8.1. Zusammenfassung .........................................................................................................84
8.2. Ausblick ........................................................................................................................84
9. Literaturverzeichnis ..............................................................................................................86
Anhang A: Tabellen ..................................................................................................................88
Anhang B: Metaphern in der Führung komplexer IT-Projekte [Hald02]
aufbereitet als Lehreinheit ......................................................................................90
Anhang C: eingerichtete Umgebung .........................................................................................99
httpd.conf .............................................................................................................................99
php.ini .................................................................................................................................109
Anhang D: Source-Code .........................................................................................................118
1. frame.php .......................................................................................................................119
2. index.html .......................................................................................................................119
3. table_of_contents.html ...................................................................................................119
4. choose_class.php ............................................................................................................119
5. contents.php ...................................................................................................................121
6. show_content.php ...........................................................................................................125
7. new_content.php ............................................................................................................126
8. edit_content.php .............................................................................................................126
9. archive.php .....................................................................................................................127
10. check_content.php ........................................................................................................128
11. set_state.php .................................................................................................................128
12. get_metadata.php .........................................................................................................129
13. set_metadata.php .........................................................................................................131
14. edit_xml.php ................................................................................................................132
15. content.xsl ....................................................................................................................141
3

CMS für die MIO-Lernumgebung Inhaltsverzeichnis
16. content_form.xsl ...........................................................................................................142
17. content.dtd ....................................................................................................................143
18. Bedienungsanleitung_CMS.html .................................................................................143
4

CMS für die MIO-Lernumgebung Abbildungsverzeichnis
Abbildungsverzeichnis
Abb. 1: ER-Gegenstandstyp (nach [Ditt99]) .............................................................................14
Abb. 2: ER-Beziehungstyp mit Strukturbeschränkungen (nach [Ditt99]) ................................15
Abb. 3: Manuelle Administration vs. Content Management System [Pinuts] ..........................17
Abb. 4: Verwendung von Templates [Pinuts] ...........................................................................18
Abb. 5: Content-Lifecycle [Wein00].........................................................................................19
Abb. 6: Objektmodell ................................................................................................................31
Abb. 7: Anwendungsfall-Diagramm .........................................................................................32
Abb. 8: Aktivitätsdiagramm Lehrtext anschauen......................................................................34
Abb. 9: Aktivitätsdiagramm Lehrtext erstellen .........................................................................35
Abb. 10: Aktivitätsdiagramm Lehrtext editieren.......................................................................36
Abb. 11: Aktivitätsdiagramm Lehrtext prüfen ..........................................................................37
Abb. 12: Aktivitätsdiagramm Metadaten verwalten..................................................................38
Abb. 13: Aktivitätsdiagramm Lehrtext aus Archiv anschauen..................................................39
Abb. 14: Zustandsmodell Life Cycle eines Lehrtextes..............................................................41
Abb. 15: Zustandsmodell Status eines Lehrtext ändern ............................................................41
Abb. 16: ER-Diagramm.............................................................................................................44
Abb. 17: Website-Struktur.........................................................................................................48
Abb. 18: Screenprint Index.html ...............................................................................................49
Abb. 19: Screenprint Auswahl Editieren...................................................................................50
Abb. 20: Screenprint Thema und Link in Template („content_form.xsl“) einfügen ................51
Abb. 21: Screenprint Ausgabe des Dokuments mit Stylesheet „content.xsl“ ...........................52
Abb. 22: Screenprint Hauptfenster ............................................................................................68
Abb. 23: Screenprint Ansicht ....................................................................................................69
Abb. 24: Screenprint Erstellen...................................................................................................70
Abb. 25: Screenprint Thema wählen .........................................................................................71
Abb. 26: Screenprint Untertitel1, Untertitel2 und Textarea ......................................................72
Abb. 27: Screenprint Syntaktisch unkorrekte Tag-Eingabe ......................................................74
Abb. 28: Screenprint Eingerückte Listen- und Tabellen-Tags in der Textarea.........................75
Abb. 29: Screenprint Link/Bild einfügen ..................................................................................76
Abb. 30: Screenprint Textarea-Eintrag......................................................................................77
Abb. 31: Screenprint Ausgabe...................................................................................................78
Abb. 32: Screenprint Genehmigen/Ablehnen............................................................................80
Abb. 33: Screenprint Metadaten................................................................................................82
Abb. 34: Einflüsse auf das Führungsverhalten [Hald02] ..........................................................95
5

CMS für die MIO-Lernumgebung Tabellenverzeichnis
Tabellenverzeichnis
Tab. 1: Anwendungsfall Lehrtext anschauen ............................................................................34
Tab. 2: Anwendungsfall Lehrtext erstellen ...............................................................................35
Tab. 3: Anwendungsfall Lehrtext editieren...............................................................................36
Tab. 4: Anwendungsfall Lehrtext prüfen ..................................................................................37
Tab. 5: Anwendungsfall Metadaten verwalten..........................................................................38
Tab. 6: Anwendungsfall Archiv ................................................................................................39
Tab. 7: Metadata........................................................................................................................45
Tab. 8: Content ..........................................................................................................................45
Tab. 9: State...............................................................................................................................45
Tab. 10: Groups_persons [Lagl02]............................................................................................46
Tab. 11: Classes_groups [Lagl02].............................................................................................46
Tab. 12: Metadata......................................................................................................................88
Tab. 13: Content ........................................................................................................................88
Tab. 14: State.............................................................................................................................88
Tab. 15: Groups_persons [Lagl02]............................................................................................88
Tab. 16: Classes_groups [Lagl02].............................................................................................88
Tab. 17: Classes [Lagl02]..........................................................................................................89
Tab. 18: Groups [Lagl02] ..........................................................................................................89
Tab. 19: Themes [Lagl02] .........................................................................................................89
Tab. 20: Persons [Lagl02] .........................................................................................................89
Tab. 21: Begriff Leadership vs. Management [Hald02]............................................................92
Tab. 22: Systemebenen [Hald02] ..............................................................................................97
Tab. 23: Situativer Einsatz von Metaphern [Hald02]................................................................98
6

CMS für die MIO-Lernumgebung Zusammenfassung
Zusammenfassung
Die Informationsflut grosser Websites ist immer schwieriger zu handhaben. Der Arbeitsaufwand
und die Kosten für Erstellung und Pflege von Inhalten durch Programmierer und
Redakteure führen zu immer grösseren Problemen.
Durch die Einführung eines Content Management Systems zur Strukturierung und Verwaltung
der Informationsseiten sollen die Handlungen der Anwender koordiniert und die Veröffentlichung
der Dokumente automatisiert werden.
Im Rahmen dieser Diplomarbeit wurde für die webbasierte Lernumgebung des Ergänzungsstudiums
MIO (Mensch Informatik Organisation) ein Content Management System entwickelt,
welches die Verfasser bei der Erstellung, Steuerung und Organisation von Lehrtexten
unterstützen soll. Die Arbeit basiert auf der vorgängigen Analyse des aktuellen Stands der
Technik („state of the art“) von Content Management Systemen. Abschliessend wurde das
CMS-Tool im Sinne eines „Proof of Concept“ anhand einer beispielhaften Lehreinheit
getestet.
Abstract
The amount of information in the web is getting more and more difficult to handle.
Expenditure of energy and costs of producing and managing the content by programmers and
editors results in bigger and bigger problems.
The introduction of a content management system to structure and manage the sites should
coordinate the acts of users and automate the publication of documents.
Within the scope of this diploma a content management system has been developed for the
webbased learning environment of MIO, which should help authors to produce, control and
organize the learning texts. This thesis bases on analyses of the state of the art of content
management systems. Finally, the tool was tested as a proof of concept with an exemplary
learning unit.
7

CMS für die MIO-Lernumgebung Ausgangslage
1. Ausgangslage
1.1. Voraussetzungen
„Das Ergänzungsstudium mensch | informatik | organisation (MIO) wird vom Institut für
Informatik der Universität Zürich angeboten. Es richtet sich an Führungskräfte aus den
Bereichen Business, Informatik, Organisationsentwicklung und Human Ressources, die für
ihre aktuelle oder zukünftige Tätigkeit profunde Kenntnisse der Führung und des
Managements technisch innovativer Veränderungsprozesse benötigen. Der Studiengang
vermittelt im ersten Semester neue Erkenntnisse über Wissensgebiete, die zur Entwicklung
und Einführung innovativer IT- Lösungen relevant sind. Fallbeispiele aus der Praxis der
Studienteilnehmer werden exemplarisch analysiert und Lösungsansätze diskutiert. Begleitende
Lerngruppen und eine webbasierte Lernumgebung unterstützen die Lernprozesse“ [Mahl02].
Für das Ergänzungsstudium MIO wurde eine webbasierte Lernumgebung entwickelt. Sie dient
der Verwaltung aller MIO-Benutzerdaten, der Kommunikation zwischen den Studienteilnehmern,
der Erfassung und Veröffentlichung von eigenen Projektarbeiten und der
Bereitstellung von Lernmaterialien und Informationen über den Studiengang [Mahl02].
Die MIO-Lernumgebung wurde bis Ende Mai 2002 überarbeitet und eine neue Version der
MIO-Lernumgebung (Lernumgebung 2.0 siehe [Mahl02],[Nier02],[Lagl02]) erstellt. Nach
dieser grundlegenden Überarbeitung sollen nun auf der neuen Plattform funktionelle
Ergänzungen zur Verbesserung der Lehr- und Lernunterstützung des Tools realisiert werden.
1.2. Problemstellung
Das zu entwickelnde Content Management System (CMS) soll die Verfasser von Lehrtexten
für die MIO-Lernumgebung bei ihrer Arbeit unterstützen. Unter „Content“ wird hier Lehrstoff
verstanden.
Nach einer Literaturanalyse über den aktuellen Stand der Technik („state of the art“) im
Bereich Content Management ist eine formalisierte und grafisch aufbereitete Spezifikation für
ein CMS zu erstellen.
Anschliessend wird die technische Spezifikation auf dem Testsystem implementiert.
Besonders betont wird die Abgrenzung zwischen der Verwaltung der Daten über
konventionelle relationale Datenbanken und mittels XML/XSL.
Die Arbeit soll auf der Struktur der bestehenden Datenbank aufsetzen. Diese kann gegebenenfalls
erweitert werden. Kritisch zu überprüfen ist das bestehende Design der Aufbereitung und
der Ausgabe von Lehrtexten.
Basierend auf dieser Implementation soll anschliessend eine beispielhafte Lerneinheit mit dem
Thema „Metaphern in der Führung von komplexen IT-Projekten“ für die Lernumgebung
aufbereitet werden. Dabei ist von der Semesterarbeit von Lukas Haldemann [Hald02]
auszugehen. Mit ihr soll die Applikation im Sinne eines „Proof of Concept“ überprüft werden.
Abschliessend ist eine HTML-Datei als Benutzerleitfaden zu erstellen.
8

CMS für die MIO-Lernumgebung Ausgangslage
1.3. Rahmenbedingungen
Die Arbeiten sind in die vom Schwerpunkt MIO unterstützte technische Umgebung einzupassen
(Apache, MySQL, PHP4, XML, XSL). Die Programmierarbeiten sollen primär auf
einer selbst eingerichteten Umgebung ausgeführt werden. Für den Systemtest steht ein Server
auf der Basis von MacOSX am Schwerpunkt MIO zur Verfügung.
1.4. Gliederung der Arbeit
Das folgende Kapitel 2 führt zunächst in die verwendeten Technologien und in das
konzeptuelle Datenbankschema ein, der Begriff „Content Management“ wird abgegrenzt und
es wird eine Einführung in Content Management Systeme (CMS) gegeben.
Schliesslich behandelt das Kapitel eine mögliche Verwendung von Open Source CMS.
Kapitel 3 spezifiziert die Anforderungen an das CMS.
Kapitel 4 erläutert die Datenbank- und die Websitestruktur und den konzeptuellen Entwurf.
In Kapitel 5 folgt die Beschreibung der Implementierung. Es werden die wichtigsten
Codestücke genauer umschrieben und erklärt.
Kapitel 6 beschreibt die beim „Proof of Concept“ gemachten Erfahrungen und deren Fazit.
Eine Bedienungsanleitung des Content Management Systems ist unter Kapitel 7 abgedruckt.
Kapitel 8 fasst die Arbeit zusammen und gibt Ausblick auf zukünftige Erweiterungen des
Programms.
Kapitel 9 beinhaltet das Literaturverzeichnis.
In Anhang A sind die Tabellen zum Datenbankschema zu finden.
Anhang B gibt Auskunft über die Versionen der verwendeten Technologien und beinhaltet die
Konfigurationsdateien der eingerichteten Umgebung.
Anhang C beinhaltet die aufbereitete Lehreinheit.
In Anhang D ist der Quellcode und der HTML-Quellcode der Bedienungsanleitung abgedruckt.
Alle Quellcode-Dateien sowie die Arbeit selbst sind auf der beiliegenden CD abgespeichert.
9

CMS für die MIO-Lernumgebung Einleitung
2. Einleitung
2.1. Technologien
Folgende Technologien werden verwendet:
• Apache Webserver
• MySQL Datenbank
• PHP4 Serverscriptsprache
• XML/XSL/HTML/Javascript
• PhpMyAdmin
2.1.1. Apache
Apache ist der mit 54% Verbreitung am meisten eingesetzte Webserver [Netcra]. Er ist inkl.
Quellcode für mehr als zwei Dutzend Plattformen frei verfügbar. Die Apache-Software
zeichnet sich durch Stabilität, Robustheit und Geschwindigkeit aus [Apache].
2.1.2. MySQL
MySQL ist ein relationales Datenbank-Verwaltungssystem, das für den nicht kommerziellen
Einsatz als Open Source Software frei verfügbar ist. MySQL unterstützt die Benutzer mit
einer leistungsstarken Mehrbenutzer-SQL-Datenbanklösung, welche mehrere Arbeitsschritte
gleichzeitig verarbeiten kann und schnell, robust und einfach im Gebrauch ist. SQL steht für
“Structured Query Language”. Nachteile äussern sich in der fehlenden Möglichkeit, Sichten
und geschachtelte Anfragen zu generieren [Mysqlc].
2.1.3. PHP
Die PHP-Präprozessor-Engine stellt eine robuste in HTML eingebundene Skript-Sprache zur
Verfügung. Die Syntax ist angelehnt an C, PERL und Java, enthält aber einige einzigartige
PHP-spezifische Merkmale. PHP gestattet schnell funktionsreiche dynamische Websites zu
erzeugen. PHP stellt eine exzellente Schnittstelle zu Online-Datenbanken bereit, wobei es
eine große Anzahl von Datenbank-Systemen (u.a. MySQL) unterstützt. Um für den PHP-
Prozessor zu kennzeichnen, welche Teile der Seite er verarbeiten soll, muss der Code von
einem öffnenden und einem schliessenden Tag umgeben werden. Das öffnende Tag ist
“”. In einer HTML-Seite können beliebig viele solcher PHP-
Blöcke enthalten sein.
PHP-Code besteht aus einer Folge von Anweisungen. Einzelne Anweisungen müssen
voneinander getrennt werden. In PHP wird dazu das Semikolon (;) verwendet.
PHP verwendet untypisierte Variablen, d.h. es muss nicht festgelegt werden, ob Zahlen, Texte
oder sonstige Werte in einer Variablen gespeichert werden sollen. PHP paßt den Typ
automatisch an die Verwendung an. So kann zum Beispiel mit einem String, der nur eine Zahl
enthält, und einer Zahl ganz normal gerechnet werden. Variablen beginnen in PHP mit einem
Dollarzeichen, gefolgt von dem Variablenbezeichner (z.B. $name).
10

CMS für die MIO-Lernumgebung Einleitung
Um Text an den Browser auszugeben bzw. in die ausgegebene HTML-Seite einzufügen,
bietet PHP das Kommando “echo” an, das Text nicht auf den Bildschirm, sondern an den
Browser schickt. So kann HTML-Code erzeugt werden, der dann vom Browser verarbeitet
wird.
echo "";
echo "Dies erzeugt eine Tabelle";
echo "";
Bsp.: Echo-Ausgabe
In PHP dürfen in einem auszugebenen String keine Anführungszeichen (") verwendet werden.
Sollen sie trotzdem verwendet werden, muss ihnen ein Backslash (\) vorangestellt werden.
Innerhalb eines auszugebenden Textes können Variablen verwendet werden, die dann von
PHP durch die aktuellen Werten ersetzt werden.
$a = 1; $b = 2;
$summe = $a + $b;
echo "Die Summe aus $a und $b ist $summe";
Bsp.: PHP-Variablen
Variablen ausserhalb von PHP / Verwendung von HTML-Formularen
Sobald eine HTML-Formular an ein PHP-Skript übergeben wird, sind die in die
Eingabefelder des Formulars gemachten Einträge für das PHP-Skript als Variablen verfügbar.
Diese werden bei Abschicken des Formulars automatisch in die PHP-eigenen globalen
Variablen $_POST oder $_GET geschrieben, je nachdem, welche Methode im -Tag
von HTML angegeben wurde. Das Attribut „Action“ gibt das aufzurufende PHP-Skript an.
Name:
Bsp.: Formular
Wird das Formular abgeschickt, steht der Wert des Textfeldes in der Variable
$_POST[`username`] zur Verfügung.
Weitere Informationen zu PHP sind unter [Phpnet] und zu finden.
2.1.4. XML/XSL/HTML/Javascript
Die eXtensible Markup Language (XML) stellt einen vom World Wide Web Consortium
(W3C) verwalteten Standard zur Darstellung strukturierter Daten dar. Das Format ist
gleichermassen von Mensch und Maschine lesbar und ähnelt stark HTML.
XML erlaubt es, eigene Dokumenten-Markups (Tags) zu definieren und damit ein Dokument
zu formatieren.
Für die Darstellung von XML-Dokumenten sind Stylesheets nötig. Dazu existiert eine
Stylesheet-Spezifikation namens Extensible Stylesheet Language (XSL). Die Benutzung von
XSL garantiert eine auf allen Plattformen gleich erscheinende Formatierung [Ecks00].
Es gibt i.a. drei Dateien, die von einer XML-konformen Anwendung bearbeitet werden, um
XML-Inhalt darzustellen:
11

CMS für die MIO-Lernumgebung Einleitung
XML-Dokument
Diese Datei enthält die Dokumentdaten, üblicherweise gekennzeichnet durch aussagekräftige
XML-Elemente, welche zusätzliche Attribute enthalten können.
Hallo XML!
Bsp.: XML-Datei [Xmlgur]
XSL-Stylesheet
Ein Stylesheet diktiertdie Formatierung der Dokumenten-Elemente bei ihrer Darstellung. Auf
das gleiche Dokument können verschiedene Stylesheets Anwendung finden und somit dessen
Erscheinungsbild verändern, ohne die zugrunde liegenden Daten zu beeinflussen [Ecks00].
Diese Trennung von Inhalt und Formatierung ist ein wesentliches Merkmal von XML.
Bsp.: XSL-Datei [Xmlgur]
Dokumenttypdefinition (DTD)
Die DTD bestimmt die Regeln, wie die XML-Elemente, Attribute und andere Daten definiert
und mit einem logischen Bezug zueinander in einem XML-Dokument dargestellt werden
können. [Ecks00]
Bsp.: DTD-Datei [Xmlgur]
Um ein XML-Dokument schliesslich darstellen zu können, bedarf es einer XSL-Transformation
(XSLT). XSLT ist eine Methode, XML-Dokumente so in ein entsprechendes
Ausgabeformat umzuwandeln, dass sie von der jeweiligen Anwendung (Webbrowser, PDF-
Reader etc.) angezeigt werden können.
Weiterführende Informationen zu XML/XSL/DTD unter [Shep02].
Auf die Technologie von HTML und soll hier nicht weiter eingegangen werden.
Bzgl. Javascript soll nur erwähnt werden, dass dies eine Client-basierte Skriptsprache ist.
Somit wird Javascript-Code vom Client und nicht vom Server ausgeführt.
Da die folgende Arbeit nur einige Zeilen an Javascript-Code beinhaltet, kann auf weitere
Erklärungen zu dieser Technologie verzichtet werden.
12

CMS für die MIO-Lernumgebung Einleitung
2.1.5. PhpMyAdmin
PhpMyAdmin ist eine in PHP geschriebene Verwaltungsoberfläche für MySQL, die
Manipulation der Datenbankstruktur und der darin gespeicherten Daten ermöglicht [Phpmya].
13

CMS für die MIO-Lernumgebung Einleitung
2.2. Einführung in das konzeptuelle Datenbankschema
Im Folgenden wird auf Grundlagen einer relationalen Datenbank eingegangen. Das konkrete
Datenbankschema wird in Kapitel 4 beschrieben.
Nachdem die Beschreibung des Anwendungsbeispiels aus der Ausgangslage bekannt ist, folgt
im nächsten Schritt die Entwicklung des konzeptuellen Entwurfs. Ziel des konzeptuellen
Entwurfs ist die Beschreibung der Miniwelt mit abstrakten und wohldefinierten Konzepten.
Er verwendet die Mittel des konzeptuellen Datenmodells und resultiert im konzeptuellen
Schema.
Das Entity-Relationship-Model (Gegenstand-Beziehungsmodell) gehört zu den wichtigsten
Modellen, mit denen dieses Schema grafisch dargestellt werden kann. Einem ER-Model kann
man Zusammenhänge zwischen den Datensätzen und die Aufteilung der Daten in unabhängige
Tabellen entnehmen.
Die Konzepte des ER-Model sollen nun vorgestellt werden (nach [Ditt99]).
2.2.1. Konzepte
Ein Gegenstand ist ein individuell identifizierbares Exemplar von Dingen, Personen oder
Begriffen der realen oder der Vorstellungswelt.
Eine Eigenschaft wird Gegenständen zugeordnet und ermöglicht damit deren
Charakterisierung, Klassifizierung und unter Umständen eine eindeutige Identifizierung. Eine
Eigenschaft hat einen Namen und einen (allenfalss mehrere) Eigenschaftswert(e). Die
zusätzliche Gliederung der Eigenschaften mit Hilfe der folgenden Klassifizierungseigenschaften
hilft, die Struktur und den Zusammenhang der darzustellenden Informationen
zu erfassen.
a) einfache (atomare) – zusammengesetzte Eigenschaften
b) einwertige – mehrwertige Eigenschaften
c) eigenständige – abgeleitete Eigenschaften
Ein Gegenstandstyp beschreibt die gemeinsame Struktur, die individuelle Gegenstände einer
Gruppe strukturell ähnlicher Gegenstände haben müssen. Die Gegenstandsmenge eines
bestimmten Gegenstandtyps ist die aktuelle Menge von individuellen Gegenständen, deren
Struktur durch den Gegenstandstyp beschrieben ist.
Gegenstandstyp
Primärschlüssel: Datentyp
Attribut: Datentyp=Voreingestellter Wert
Mehrwertiges Attribut:
*Eintrag fakultativ („Null“-Wert
erlaubt)
Abb. 1: ER-Gegenstandstyp (nach [Ditt99])
14

CMS für die MIO-Lernumgebung Einleitung
Die Wertmenge einer einfachen Eigenschaft eines bestimmten Gegenstandstyps enthält die
Werte, die der betreffenden Eigenschaft zugewiesen werden können.
Ein Gegenstandsschlüssel ist eine Eigenschaft oder eine Kombination von Eigenschaften, mit
deren Wert(en) die in einer Gegenstandsmenge enthaltenen Gegenstände eindeutig
identifiziert werden können (Grafik: siehe Gegenstandstyp).
Eine Beziehung assoziiert zwei (oder mehr) Gegenstände eines bestimmten Typs. Ein
Beziehungstyp beschreibt die Typen der teilnehmenden Gegenstände. Die Beziehungsmenge
eines bestimmten Beziehungstyps ist die aktuelle Menge von individuellen Beziehungen,
deren Struktur durch den Beziehungstyp beschrieben ist.
Es gibt Strukturbeschränkungen auf einen Beziehungstyp, welche durch ein Paar von ganzen
Zahlen (n für beliebig gross) in Form von (min,max) dargestellt werden:
a) Eine Kardinalitätsbeschränkung für einen an einem bestimmten Beziehungstyp B
beteiligten Gegenstandstyp G spezifiziert die Anzahl der Beziehungen des Typs B,
an denen ein Gegenstand des Typs G maximal teilnehmen kann
b) Eine Partizipationsbeschränkung für einen an einem bestimmten Beziehungstyp B
beteiligten Gegenstandstyp G spezifiziert, ob die Existenz eines Gegenstands des
Typs G davon abhängt, dass er an einer Beziehung des Typs B beteiligt ist
Gegenstandstyp B
Primärschlüssel:
Datentyp
(1,1)
Beziehungstyp
Attribut:
Datentyp=Voreingestellter
Wert
Abb. 2: ER-Beziehungstyp mit Strukturbeschränkungen (nach [Ditt99])
15
(0,n)
Gegenstandstyp G
Primärschlüssel: Datentyp

CMS für die MIO-Lernumgebung Einleitung
2.3. Begriffsabgrenzung
Aufgrund der vielfältigen Verwendung des Begriffs „Management-System“ soll der Begriff
des Content Management Systems von den übrigen abgegrenzt werden.
Document Management System
In Unternehmen entstehen verschiedenste Dokumente, die Informationen erfassen oder
bestimmte Vorgänge dokumentieren. Systeme für das Dokumentenmanagement helfen bei der
Verwaltung und dem kontrollierten Zugriff. Wesentliche Features sind dabei Erfassung,
Versionierung und Archivierung. Die mit diesen Systemen erfassten Dokumente sind meist
nur über Volltextsuche recherchierbar, da sie in unstrukturierter Form vorliegen.
Dokumentenmanagement hat zum Ziel, grosse Datenbestände an Informationen in vielen
verschiedenen Formaten zugänglich zu machen [ZsTr02].
Knowledge Management System
Knowledgemanagement versucht, aus einmal erfassten Informationen Wissen zu generieren.
Software für Knowledgemanagement-Systeme spezialisiert sich somit auf Teilbereiche wie
das intelligente Auffinden von Informationen, den gruppenbasierten Wissensaustausch und
Ähnliches [ZsTr02].
Learning Content Management System (LCMS)
Die Idee eines LCMS ist das Wiederverwenden des Inhalts eines E-learning-Systems.
Ein LCMS ist eine Mehrbenutzerumgebung, welche es den Entwicklern des Lernstoffes
ermöglicht, den digitalen Lernstoff zu kreieren, in einer zentralen Objektdatenbank zu
speichern, wiederzuverwenden, zu managen und den Lernenden zur Verfügung zu stellen.
Dabei wird der Lernstoff individuell zusammengestellt und aufbereitet. So ist es möglich, ein
Lernpaket zur Verfügung zu stellen, welches genau auf den jeweiligen Lernenden
zugeschnitten ist [Intime],[Idccom].
Web Content Management System (WCMS)
Anstatt der vollständigen Bezeichnung „Web Content Management System“ wird häufig nur
der Begriff „Content Management System (CMS)“ gebraucht. Wenn also von einem CMS
die Rede ist, ist normalerweise ein WCMS gemeint.
Der Begriff CMS beschreibt jedoch nicht die Funktionalität, die ein WCMS bietet, sondern
bildet vielmehr eine Überkategorie zu verschiedenen Weiterentwicklungen des Document
Management System. Die zentrale Rolle beim Content Management spielt die Aufteilung von
Dokumenten in einzelne Inhaltsobjekte. Hierin liegt auch der wesentliche Unterschied zum
Document Management System. Im Folgenden wird der Begriff „Content Management
System (CMS)“ für „Web Content Management System“ verwendet.
Der Content setzt sich aus den digitalen Assets (einzelne Bestandteile einer Webseite wie
Texte, Bilder, etc.) zusammen. Deshalb wird ein CMS auch als Asset Management System
bezeichnet [KrKo02].
16

CMS für die MIO-Lernumgebung Einleitung
2.4. Einführung Content Management System
2.4.1. Herkömmliches Webpublishing vs. Content Management
Die Informationsflut grosser Websites ist immer schwieriger zu handhaben. Der
Arbeitsaufwand und die Kosten für Erstellung und Pflege von Inhalten durch Programmierer
und Redakteure führen zu immer grösseren Problemen. Veraltete Informationen, „tote“ Links
und unauffindbare Dokumente sind die Folge.
Die Einführung eines Content Management System zur Strukturierung und Verwaltung der
Informationsseiten ist eine mögliche Lösung. Das CMS soll die Handlungen der Anwender
koordinieren und die Veröffentlichung der Dokumente automatisieren, so dass konsistente
und stets aktuelle Online-Informationen im Internet angeboten werden. Das CMS unterstützt
die Erstellung, Steuerung und Organisation der Inhalte.
Je umfangreicher sich der Inhalt einer Website entwickelt, desto aufwendiger ist die
herkömmliche Pflege über HTML-Editoren (siehe Abb. 3). Ein Content Management System
verarbeitet die Inhalte wesentlich schneller und flexibler. Die Time-to-Web lässt sich so um
ein Vielfaches verkürzen.
Abb. 3: Manuelle Administration vs. Content Management System [Pinuts]
Content Management (CM) erlaubt die schnelle Pflege von Webinhalten ohne
Programmierkenntnisse. Bei CM wird nicht auf die Programmierung verzichtet, sondern jeder
Mitarbeiter kann sich an einer Website wieder auf seine Kernkompetenzen konzentrieren. Die
Programmierer müssen keine Inhalte mehr pflegen, sondern kümmern sich um das
Technische. Der Redakteur braucht keine HTML-Seiten zu erstellen, um Inhalte zu
veröffentlichen.
2.4.2. Kernprinzip von Content Management Systemen
Das Kernprinzip von Content Management Systemen ist die Trennung von Layout und Inhalt.
Die Speicherung der Inhalte erfolgt unabhängig von Ausgabeformat und Design. Vorlagen
(Templates) definieren die Anordnung und Darstellung der Inhaltselemente. Durch das
17

CMS für die MIO-Lernumgebung Einleitung
Content Management System werden bei der Generierung einer Website die Vorlagen
automatisch mit den Inhalten gefüllt.
Durch die Verwendung von Templates ist die konsequente Einhaltung des Layouts garantiert.
Änderungen am Layout erfordern lediglich die Anpassung weniger Templates, die Inhalte
bleiben unverändert. Content Management Systeme entkoppeln damit die Inhaltserstellung
und Website-Programmierung.
Abb. 4: Verwendung von Templates [Pinuts]
Das Kernprinzip spricht für einen Einsatz von XML/XSL bei der Entwicklung eines CMS.
Dabei werden der Inhalt mit XML, die Darstellung (Templates) mit XSL und die Struktur-
Regeln mit DTD festgelegt.
Die Umwandlung in das Ausgabeformat übernimmt der XSL-Transformator.
2.4.3. Content Life Cycle
Als Content Life Cycle wird der Lebenszyklus der Inhaltselemente von Websites im
definierten Workflow (Produktionsprozess des Inhalts) verstanden. Der Content Life Cycle ist
ein theoretisches Modell, das den Workflow in sechs Abschnitte einteilt [Wein00]:
1. Recherchieren der Informationen
2. Erstellen der einzelnen Inhalte
3. Kontrollieren
4. Freigeben
5. Publizieren
6. Archivieren
Recherchieren
Recherchieren bedeutet das Sammeln von Informationen, welche dann in der
Erstellungsphase umgesetzt werden.
18

CMS für die MIO-Lernumgebung Einleitung
Erstellung
Der Autor bedient sich der gesammelten Informationen aus der Phase des Recherchierens und
setzt diese um. Bei der Erstellung bedient er sich der Werkzeuge, die dem zu erstellenden
Bestandteil entsprechen (z.B. Word wird für einen Text verwendet).
Kontrolle
Autoren sind meist das erste Glied in einer Kette von Verantwortlichkeiten. Sie erstellen auf
Anordnung Inhalte und müssen diese zur Kontrolle und Freigabe einer höheren Instanz
vorlegen. Dieser der Erstellung des Inhalts nachfolgende zweite Abschnitt des Content Life
Cycle ist eine wichtige Stufe für die Qualität der Inhalte auf einer Website.
Freigabe und Wiedervorlage
Hat in der Phase der Kontrolle ein entsprechend autorisierter Mitarbeiter die Inhalte geprüft,
kann er diese nun freigeben und damit die nächste Phase des Zyklus einleiten. Unkorrekte
Inhalte werden zur Überarbeitung an den Autor zurückgegeben (Wiedervorlage) und finden
sich zur weiteren Bearbeitung im Abschnitt der Erstellung wieder.
Publikation
Nach erfolgreicher Freigabe kann der Text veröffentlicht werden. Entsprechend autorisierte
Mitarbeiter können Inhalte nach Kontrolle und Freigabe im Web publizieren lassen. In der
Praxis bedeutet dies, dass ein neuer oder bearbeiteter Inhalt im Intra-, Extra- oder Internet
veröffentlicht und damit der entsprechenden Öffentlichkeit zugänglich gemacht wird.
Archivierung
Nachdem der Inhalt nach einiger Zeit seinen Zweck erfüllt hat, muss die Ausschreibung aus
dem Web wieder entfernt werden. Löschen wäre die schnellste Variante, aber nicht die beste.
Die Archivierung alter Inhalte ist sinnvoller, denn sie hat einige bedeutende Vorteile:
Man kann alte Stände der Website einsehen oder wiederherstellen oder auf Basis alter
Beiträge neue der gleichen Art erstellen, indem man die alten als Vorlage benutzt.
Abb. 5: Content-Lifecycle [Wein00]
19

CMS für die MIO-Lernumgebung Einleitung
2.4.4. Anforderungen an ein Content Management System
Im Folgenden sind die wichtigsten Funktionen, die ein CMS erfüllen sollte, aufgeführt.
Anschliessend werden in einem Ausscheidungsverfahren die von uns benötigten Funktionen
festgelegt. Aufgrund von [KrKo02],[Nohr00],[Pinuts],[RoRi01],[ZsTr02] kann eruiert
werden, dass für ein CMS folgende Eigenschaften und Funktionalitäten „state of the art“ sind:
Trennung von Inhalt und Layout
Diese Trennung ist auf verschiedener Ebene möglich: Absatz-, Seitenebene oder nur innerhalb
der Menüsteuerung. Je nach Grad der Trennung wird der Produzent mehr oder weniger
stark in seinen gestalterischen Freiheiten eingeschränkt.
Lebenszyklus-Management von Dokumenten
Der Dokumentenlebenszyklus beinhaltet die Erstellung, Updates und die Archivierung von
Dokumenten (siehe 2.3.3. Content Life Cycle).
Dieser Lebenszyklus besteht aus folgenden sechs Phasen:
1. Recherchieren der Informationen
2. Erstellen der Inhalte (Texte, Bilder, Videos etc.)
3. Kontrollieren
4. Freigeben
5. Publizieren (HTML, XML, PDF etc.)
6. Archivieren
Jedes Dokument muss mit dem Erstellungsdatum, dem Publikationsdatum und der Dauer der
Publikationsperiode versehen sein. Zusätzlich ist eine Angabe der Methode nötig, wie das
Dokument entfernt werden soll (manuell oder automatisch). Eventuell sollte ein Agent den
Betreiber einer Site warnen, sobald sich dieser Zeitpunkt nähert. Das Dokument kann dann
weiterhin im Netz publiziert bleiben oder manuell bzw. automatisch entfernt werden.
Genehmigungsprozess
Sobald ein Genehmigungsprozess definiert ist, muss der betroffene Inhalt durch diesen
Prozess geleitet werden. Dieser Prozess informiert die Autoren, falls das Dokument überarbeitet
werden muss. Nach Genehmigung aller Stellen erfolgt automatisch die Publikation.
Veränderungen an publizierten Dokumenten dürfen nur an Kopien vorgenommen werden.
Diese sind erst nach erneuter Prüfung und Genehmigung durch die entsprechenden Gremien
für die Publikation freigegeben. Jeder vordefinierte Abschnitt eines Dokuments hat seinen
eigenen Genehmigungsprozess. So können einem Abschnitt genau diejenigen Personen
zugeteilt werden, welche das nötige Wissen, die Verantwortung und die Kompetenzen
besitzen.
Rollenkonzepte (Verwaltung von Benutzungs- und Zugriffsrechten)
Die Vergabe von Zugriffsrechten kann auf verschiedenen Ebenen erfolgen: z.B. auf der
Absatz-, Seiten- oder Objektebene.
20

CMS für die MIO-Lernumgebung Einleitung
In der Regel sind hierarchisch abgestufte Rechte sinnvoll:
Das volle Zugriffsrecht benötigt nur die mit der Gesamtkoordination beauftragte Stelle.
Weitere Zugriffsrechte sollten abgestuft je nach definierter Kompetenz der Akteure vergeben
werden.
Die Vergabe von Zugriffsrechen auf die Menüstruktur kann sinnvoll sein. Manche Systeme
zeigen stets das vollständige Menüverzeichnis an und fragen beim Aufruf eines geschützten
Menüpunkts die Authentifizierung ab. Die Menüstruktur kann – bei Anzeige aller Menüpunkte
– schnell zu Unübersichtlichkeit führen. Daher ist es sinnvoll, die Menüstruktur
dynamisch zu generieren, so dass dem Benutzer nur diejenigen Menüpunkte zur Verfügung
stehen, zu welchen er auch Zutritt hat.
Editor
Um die Akzeptanz der Benutzer zu erhöhen, sollte der Editor möglichst einfach gehalten
werden. Für eine dezentrale Erstellung des Content ist ein Editor mit WYSIWYG-ähnlichen
Eigenschaften (What You See Is What You Get) von Vorteil. Die Benutzung von Templates
soll ein einheitliches Layout gewährleistet werden („Corporate Idetity“). Ausserdem ist so das
Hinzufügen und Editieren von Inhalt ohne Kenntnisse von HTML oder XML möglich.
Metainformationen (Informationen über Informationen)
Es ist nötig, zum eigentlichen Content Metainformationen zu verwalten. Metainformationen
beschreiben ein Dokument nach formalen oder inhaltlichen Aspekten. Zu den
Metainformationen können u.a. gehören:
• Autoreninformationen
• Erstellungsdatum und Änderungsdatum
• Versionsangaben
• Angaben über die Lebensdauer eines Dokumentes bzw. dessen Inhalt
• Sprachinformationen
• Klassifikationsinformationen
• Angaben über Dateiformate und –grösse
Über diese Metainformationen werden z.T. wichtige Funktionalitäten des CMS gesteuert, z.B.
die Lebensdauer eines Dokuments bzw. dessen Inhalt und damit die Revisionstermine.
Versionsmanagement
Ältere Versionen von Content sollten zur Verfügung gestellt werden. Versionsmanagement
lässt einen Rückblick auf die Entstehungs- und Veränderungsgeschichte von Dokumenteninhalten
zu. Um einem unterschiedlich hohen Änderungsbedarf verschiedener Dokumente
gerecht zu werden, sollte ein CMS eine vom Anwender frei zu konfigurierende Anzahl der
zur Verfügung stehenden historischen Versionen anbieten. Versionsmanagement ist eine
Anforderung an die Archivfunktion eines CMS und damit an ein leistungsfähiges
Dokumentenmanagement.
21

CMS für die MIO-Lernumgebung Einleitung
Link-Management
Das System sollte über ein „intelligentes“ Link-Management verfügen, welches das Auftreten
von „toten“ Links innerhalb des Systems unterbindet und automatisch korrigiert, so dass stets
nur gültige Links im System verwaltet und publiziert werden.
Beim Löschen von Inhalten, auf die noch ein oder mehrere Links verweisen, werden diese
Links automatisch ebenfalls eliminiert. Da ein solcher Automatismus möglicherweise auch zu
ungewollten Aktionen des Systems führen kann, sollte das System die Alternative bieten,
diese Aktion vom Anwender selbst ausführen zu lassen, nachdem er über eine mögliche
Inkonsistenz hingewiesen wurde.
Retrievalmöglichkeiten
Neben einer sinnvollen, systematisch aufgebauten Menüstruktur für die Navigation in den
Dokumentbeständen ist eine ausgereifte Retrievalfunktionalität für das schnelle Auffinden
von Informationen sehr wichtig. Das System sollte neben einer Recherche über Metainformationen
die Möglichkeit einer Volltextsuche bieten, die idealerweise auch Treffer
innerhalb von Word-, PDF- und anderen Binärobjekten findet. Ausgefeilte Retrievalkomponenten
bieten gewichtete Ranking-Listen im Anschluss an eine Suche an.
Ausserdem sollte sie einfach zu bedienen sein.
Dateiformate
Das System sollte möglichst viele gebräuchliche Objekttypen verwalten können (Neben
HTML und XML auch Word, PDF etc.).
Diskussions-Management
Besuchern von der Site sollte standardmässig die Möglichkeit geboten werden, Kommentare
und Kritik zu der Site zu äussern. Diese Anregungen werden an die verantwortliche Person /
Gruppe gesendet.
Import und Export
Das System sollte die Möglichkeit bieten, bestehende Web-Auftritte samt ihren Strukturen zu
übernehmen, sowie neben HTML-Seiten andere Dokument-Formate (wie z.B. PDF) einzubinden.
Eine Exportfunktion ist nötig für die Publikation auf einem oder mehreren Web-Servern.
Darüber hinaus sollte eine Exportfunktion Offline-Versionen des Web-Auftritts erzeugen
können, z.B. um diese auf CD-ROM zu brennen.
22

CMS für die MIO-Lernumgebung Einleitung
2.5. Open-Source CMS
Generell handelt es sich bei jedem Programm, dessen Quellcode im Klartext verfügbar ist, um
Open-Source. Open-Source-Software wird gewöhnlich in öffentlichen Kooperationen von
zahlreichen Programmierern entwickelt und ist somit an keine Firma kommerziell oder
entwicklungstechnisch gebunden. Dies sichert eine schnelle Weiterentwicklung der
Komponenten, birgt jedoch die Gefahr, dass in der Entwicklung nicht nachvollziehbare neue
Schwerpunkte gesetzt werden oder die Entwicklung komplett eingestellt wird [KrKo02].
Der Vorteil von Open-Source-Software liegt darin, dass sich neue Standards und individuelle
Anpassungen selbst integrieren lassen, da der Quellcode verfügbar ist.
Nachteilig wirkt sich aus, dass aufgrund der Entwicklung durch mehrere Firmen ungewiss ist,
ob und wann neue Funktionen implementiert werden.
In Bezug auf Content Management Systeme ist eine grosse Palette an Open-Source-Produkten
vorhanden, welche sich aber in der Funktionalität stark unterscheiden. Das Angebot reicht
von einer einfachen Dokumentenverwaltung bis zum komplexen CMS.
Viele Open-Source-CMS sind in ihrer Grundausstattung sehr spartanisch gehalten, bieten
jedoch teilweise ein hohes Mass an „Customizing“, also an projektbezogener Hinzuprogrammierung
von Features.
Wird der Aufwand für die zusätzliche Programmierarbeit in Kauf genommen, können solche
Produkte, wie z.B. Midgard [Midgar], zu funktionsreichen CMS mit Benutzerverwaltung,
Dokumentenmanagement, Trennung von Metadaten und Content, Editor, Versionsmanagement,
Suchmechanismen, Unterstützung verschiedener Dateiformate und Linkmanagement
erweitert werden.
Die meisten dieser Produkte bieten neben der Trennung von Layout und Inhalt wenigstens
einen Editor zur Erstellung und Änderung von Websites und gehen damit über die reine
Dokumentenverwaltung hinaus. Einige dieser Editoren sind WYSIWYG-fähig (What You
See Is What You Get) oder lassen die Verwendung von hauseigenen Tags zu oder vereinen
beides.
Des weiteren sind oft eine Zugangsverwaltung und ein Suchmechanismus integriert.
Ausgefeiltere Systeme wie z.B. Zope [Zoporg] beinhalten ausserdem eine Unterstützung von
XML, eine Objekt-Datenbank, die verschiedene Objekte wie z.B. Bilder für die Integration in
die Website bereithält, eine Session-Verwaltung und ein Dikussionsgruppen-Portal.
Leider lassen die Qualität und der Umfang der Dokumentationen von Open-Source-CMS oft
zu wünschen übrig. Vorbildlich diesbezüglich ist jedoch z.B. Typo3 [Typo3c].
Zu erwähnen ist, dass die meisten dieser Systeme auf den Technologien Apache, PHP und
MySQL basieren. Somit ist das ganze Paket „Open-Source“.
Weitere Informationen können unter [Cmseva] und den dort befindlichen Links
nachgeschlagen werden.
Auf der Webseite www.contentmanager.de [Contma] wird jeweils die aktuelle Marktübersicht
von Content Management Systemen publiziert.
23

CMS für die MIO-Lernumgebung Anforderungsspezifikation
3. Anforderungsspezifikation
Aus den im letzten Kapitel eruierten Anforderungen an ein Content Management System
sollen nun nach einem Ausschlussverfahren die für das zu implementierende System
Notwendigen bestimmt und anschliessend genauer spezifiziert werden. Für die grafische
Beschreibung wird die Spezifikationssprache UML (unified modelling language) verwendet
(nach [Glin00]).
Nach einer genauen Beschreibung der Systemanforderungen wird das System aus
verschiedener Sichtweise betrachtet (nach [Glin00]).
Das Objektmodell beschreibt das System aus statischer Sicht. Es spezifiziert die Gegenstände
der Realität, mit denen das System umgehen muss.
Das Anwendungsfall-Diagramm modelliert die Benutzer-System-Interaktion aus Benutzersicht
und gibt einen Überblick über die Anwendungsfälle.
In einer Detailanalyse werden die Anwendungsfälle genauer spezifiziert und deren Ablauf aus
Aktivitätssicht als Aktivitätsdiagramme dargestellt.
Ein Teil des Systems wird schliesslich aus Verhaltenssicht als Zustandsmodell beschrieben.
Sämtliche Modelle werden mit Hilfe des Visualisierungstools VISIO 2000 erstellt.
24

CMS für die MIO-Lernumgebung Anforderungsspezifikation
3.1. Systemanforderungen
Nach Rücksprache mit Vertretern des Schwerpunkts MIO steht fest, dass die zu
implementierende Applikation folgende Funktionen zur Verfügung stellen muss:
• Trennung von Inhalt und Layout
• Lebenszyklus-Management inkl. Bestätigung der Kontrollphase
• Metainformationen verwalten
• Rollenkonzepte
• Editor für Lehrtexte
• Versionsmanagement
Trennung von Inhalt und Layout
Die Kernanforderung des CMS ist die Trennung des Inhalts von Gestaltung und
Funktionalität. Optimalerweise sind auch Gestaltung und Funktionalität autonom. Somit
können die drei Bestandteile unabhängig voneinander geändert werden, ohne einen anderen
Teil verändern zu müssen.
Eine durch das CMS ausgelieferte Seite wird aus Templates und Inhalten zusammengesetzt.
Eine Implementation mit XML (Inhalt), XSL (Gestaltung) und PHP (Funktionalität) wird der
Kernanforderung der Trennung des Inhalts von Gestaltung und Funktionalität gerecht.
Das Erscheinungsbild einer Webseite wird durch Vorlagen, sog. Templates bestimmt. Solche
Vorlagen sind normalerweise starr vorgegeben und der Autor kann nur aus Bestehenden eine
ihm passende auswählen.
Das zu implementierende System soll dem Autor die Möglichkeit bieten, diese Vorlagen
seinen Bedürfnissen anzupassen. Vorerst wird nur ein Template im System integriert, was
eine spätere Ergänzung durch weitere nicht ausschliessen soll. Die Anpassung der Vorlage
wird dadurch eingeschränkt, dass nur vorgegebene Felder verwendet werden können. Wie
viele Felder und in welcher Reihenfolge diese eingefügt werden, ist dabei dem Autor
überlassen.
Lebenszyklus-Management
Die Recherche der Informationen geschieht ausserhalb des CMS und wird deshalb mit der
Erstellungsphase des Lehrtextes zusammengelegt. Nach Eingabe eines Lehrtextes muss dieser
in einer nächsten Phase kontrolliert und anschliessend freigegeben oder abgelehnt werden.
Ein freigegebener Lehrtext wird automatisch vom System publiziert. Ein abgelehnter Lehrtext
muss nochmals überarbeitet und erneut überprüft werden. Veraltete Lehrtexte werden im
Archiv abgelegt.
Nach Freigabe oder Ablehnung eines Lehrtextes muss der entsprechende Autor sofort
informiert werden. Die Benachrichtigung erfolgt per E-Mail an den Autor. Bei Ablehnung ist
eine Begründung des Entscheids anzugeben.
25

CMS für die MIO-Lernumgebung Anforderungsspezifikation
Metainformationen
Die Metainformationen beinhalten Informationen über Titel, Autor, Thema, Version, Status,
Erstellungsdatum, Klasse, Schreibberechtigungsgruppe und Prüfberechtigungsgruppe eines
Dokuments.
Diese Informationen können jederzeit durch kompetente Stellen verändert werden, mit
Ausnahme von Version und Erstellungsdatum, da das Editieren der Versionsangabe zu
Inkonsistenz führen könnte und das Ändern des Erstellungsdatums eine spätere
Rekonstruktion der Entstehungsgeschichte der Dokumenteninhalte verhindert.
Die Statusangabe gibt Auskunft darüber, in welcher Phase des Lebenszyklus sich ein
Dokument befindet. Über den gesamten Lebenszeitraum hat jedes Dokument immer genau
einen Zustand, welcher durch die aktuelle Phase des Lebenszyklus bestimmt wird.
Folgende Zustände sind möglich:
• Zu prüfen
• Freigegeben
• Nicht freigegeben
• Veraltet
Nach der Erstellung eines Dokuments wird es automatisch vom System als „zu prüfen“
gekennzeichnet. Nach der Kontrollphase ist es entweder „freigegeben“ oder „nicht
freigegeben“. Freigegebene Lehrtexte können angeschaut werden. Nicht freigegebene
Lehrtexte können editiert werden. In der Archivierungsphase ist es überholt und als „veraltet“
gekennzeichnet.
Rollenkonzepte
Folgender Abschnitt bezieht sich auf [Mahl02] und [Kaeg02].
Die Personenverwaltung der MIO-Umgebung ist im Moment im Umbruch. Das
Rollenkonzept des CMS soll möglichst an die neue Version [Kaeg02] der Personenverwaltung
angeglichen werden. Dabei wird nur auf die Teile der Personenverwaltung
eingegangen, welche das CMS betreffen.
Die Benutzer des MIO-Systems sind in folgende Gruppen eingeteilt:
• Allgemeine Interessenten
Personen, die sich für MIO und Studiengänge interessieren.
• Teilnehmer einer Klasse
Dies kann eine aktuelle oder zukünftige Klasse sein.
• Referenten
Die Referenten bereichern die Aktivitäten in Weiterbildung, Forschung und Beratung
um wichtige Inputs aus der akademischen Welt und aus der Welt der
Organisationsberatung. Sie verfügen über einen höheren akademischen Abschluss und
bewegen sich im Spannungsfeld von Wissenschaft und Praxis.
26

CMS für die MIO-Lernumgebung Anforderungsspezifikation
• Mentoren/Ehemalige Teilnehmer
Mentoren sind erfahrene Ratgeber und motivierende Helfer, die einen intensiven
Kontakt zur MIO Praxis in Unternehmen herstellen. Konkret heisst das: Ehemalige
berichten von Erfahrungen, stellen Praxisfälle im Rahmen der einzelnen Fachtage vor,
gestalten die Praxistage mit, unterstützen die Projektgruppen während der Praxisphase
und fungieren als Ansprechpartner und zusätzliche Projekteinbringer.
Damit geben wir den Ehemaligen die Gelegenheit, ihre Erfahrungen aufzuarbeiten und
zu reflektieren, wovon die „Neuen“ profitieren.
• Personen aus dem MIO-Team
Das MIO-Team begleitet die Teilnehmenden durch die Ausbildung und ist
verantwortlich für das Konzept und die inhaltliche und didaktische Ausgestaltung der
Workshops in den Tagungshotels. Es koordiniert die Referenten und Mentoren an den
Studientagen.
• Administratoren
Sie sind für die Pflege aller Daten des Systems verantwortlich.
• Studienleitung
Gruppe, die pro Klasse Lehrtexte prüfen und freigeben kann
Die Gruppen werden verschiedenen Klassen zugeordnet. Pro Studiengang gibt es eine eigene
Klasse, die aktiv oder passiv sein kann. Zusätzlich existiert die Pool-Klasse, welche immer
aktiv ist. Der Pool-Klasse gehören die Gruppe des MIO-Teams und die der Administratoren
an.
Die Vergabe der Benutzungsrechte erfolgt auf verschiedener Ebene:
• Klassen-
• Gruppen- und
• Personenebene
Die Lehrtexte beziehen sich grundsätzlich auf Klassen. Pro Klasse hat genau eine Gruppe ein
bestimmtes Recht bzgl. der Lehrtexte.
Einem Lehrtext wird somit eine Klasse, ein Autor (Referent), eine Editiergruppe und eine
Prüfgruppe zugewiesen. Als Standard für die zugewiesene Editier- und Prüfgruppe wird die
Studienleitung der jeweiligen Klasse eingetragen.
Bezüglich der CMS-Funktionen Ansicht, Erstellen, Editieren, Prüfen, Metadaten verwalten
und Archivieren werden folgende Berechtigungen vergeben, wobei jeder Lehrtexte sich
jeweils auf eine Klasse bezieht:
Ansicht
Lehrtexte anschauen dürfen:
- alle Gruppen der Klasse
- Administratoren
27

CMS für die MIO-Lernumgebung Anforderungsspezifikation
Erstellen
Lehrtexte erstellen dürfen:
- Referenten der Klass
- Administratoren
Editieren
Lehrtexte editieren dürfen:
- der Autor, solange der Lehrtext von der Studienleitung nicht geprüft und freigegeben ist
- Administratoren
Prüfen
Lehrtexte prüfen dürfen:
- die Studienleitung
- Administratoren
Metadaten verwalten
- die Studienleitung
- Administratoren
Archiv anschauen
- Referenten der Klasse
- Administratoren
Editor für Lehrtexte
Der Editor soll einfach und flexibel in der Bedienung sein. Die vorhandenen Felder
Haupttitel, Autor und Thema können durch Knopfdruck mit zusätzlichen Titel- und
Textfeldern ergänzt werden. Der „Klar-Text“ in den Textfeldern kann mit einfachen HTML-
Befehlen formatiert und mit Links versehen werden. Bilder können aus einem Bildverzeichnis
in den Text eingefügt werden.
Verwendbare HTML-Tags:
• Tabelle: mit den Tags , und
• Listen: mit dem Tag
mit dem Tag
• fett:
• kursiv:
• unterstrichen:
• Trennstrich:
• Umbruch: (wie Enter-Taste)
Alle verwendbaren HTML-Elemente (ausser und ) bestehen aus einem einleitenden
und einem abschliessenden Tag.
28

CMS für die MIO-Lernumgebung Anforderungsspezifikation
Versionsmanagement
Ältere Versionen erhalten den Status „veraltet“ und werden in einem Archiv abgelegt. Jede
neue Version erhält eine neue Versionsnummer. Die archivierten Dokumente können jederzeit
angeschaut, aber nicht mehr editiert werden.
Jedoch besteht die Möglichkeit, falls die benötigten Benutzungsrechte vorhanden sind, den
Status eines Dokuments über die Metadatenverwaltung wieder zu ändern. So kann ein
versehentlich ins Archiv abgelegtes Dokument wieder zur Nutzung freigegeben werden.
Ebenso kann ein Dokument, welches nicht mehr aktuell ist, aber nicht als neue Version
aufbereitet werden soll, über die Metadatenverwaltung als „veraltet“ gekennzeichnet und ins
Archiv abgelegt werden.
29

CMS für die MIO-Lernumgebung Anforderungsspezifikation
3.2. Objektmodell
Das Objektmodell zeigt die statische Struktur des Systems auf. Es werden die Objekte des
Systems, die Beziehungen zwischen den Objekten, sowie die Attribute und Operationen der
einzelnen Klassen beschrieben.
• Lehrtext
Lehrtexte bilden den Content des CMS. Ein Lehrtext besteht aus seinem Inhalt. Die
Funktionen der Lehrtexte lassen diese anzeigen, erstellen, editieren oder prüfen.
• Klasse
Jeder Lehrtext gehört zu einer Klasse. Eine Klasse ist gegeben durch einen
Klassennamen und eine Klassenbeschreibung. Sie besitzt ausserdem Angaben darüber,
ob sie aktiv (d.h. Studiengang ist aktuell) und offen (d.h. Anmeldung an diesen
Studiengang ist möglich) ist.
• Gruppe
Zu jeder Klasse können mehrere Gruppen gehören. Eine Gruppe ist durch einen
Gruppennamen und eine Gruppenbeschreibung bestimmt.
• Person
Alle Personen sind Mitglieder einer oder mehrerer Gruppen. Personen sind durch
deren Basisdaten (Name, Vorname etc.) und deren Status bestimmt. Der Status gibt
an, ob eine Person nur „allgemein interessiert“ oder Mitglied einer Gruppe ist.
• Metadaten
Die Metadaten repräsentieren Informationen über einen Lehrtext. Sie gehören genau
zu einem Lehrtext und beinhalten Titel, eine Person als Autor, Thema und
Erstellungsdatum. Von einem Lehrtext können verschiedene Versionen existieren.
Ältere Versionen sind als solche markiert (Status „veraltet“). Für Lese- und
Schreibberechtigung sind Gruppen angegeben.
• Ansicht
Ermöglicht das Anzeigen von Lehrtexten.
• Erstellen
Ermöglicht das Erstellen von Lehrtexten.
• Editieren
Ermöglicht das Editieren von Lehrtexten.
• Prüfen
Ermöglicht das Prüfen von Lehrtexten.
• Archiv
Ermöglicht das Anzeigen archivierten Lehrtexten.
30

CMS für die MIO-Lernumgebung Anforderungsspezifikation
Abb. 6: Objektmodell
31

CMS für die MIO-Lernumgebung Anforderungsspezifikation
3.3. Anwendungsfall-Diagramm
Mit dem folgenden Anwendungsfall-Diagramm soll ein Überblick über die Hauptanwendungsfälle
(Szenarien) und deren Akteure gegeben werden.
Abb. 7: Anwendungsfall-Diagramm
32

CMS für die MIO-Lernumgebung Anforderungsspezifikation
3.4. Detailanalyse der Hauptanwendungsfälle
Im Folgenden werden die Akteure und Anwendungsfälle aus dem Anwendungsfall-Diagramm
erläutert. Die Anwendungsfälle werden textuell und deren Ablauf als Aktivitätsdiagramme
beschrieben.
Akteure
• Autor: erstellt Lehrtext und gibt ihn ins System ein, editiert Lehrtext.
• Teilnehmer: schaut Lehrtext an
• Administratoren/Studienleitung: editieren Lehrtext und Metadaten, prüfen Lehrtext
Anwendungsfälle
• Lehrtext anschauen: Anschauen der Lehrtexte, die freigegeben sind
• Lehrtext erstellen: Erstellen eines neuen Lehrtextes
• Lehrtext editieren: Editieren der Lehrtexte, die nicht archiviert wurden
• Lehrtext prüfen: Prüfen der Lehrtexte, die „zu prüfen“ sind
• Metadaten verwalten: Editieren der Metadaten der Lehrtexte, die nicht archiviert
wurden
• Archiv: Anschauen archivierter Lehrtexte
33

CMS für die MIO-Lernumgebung Anforderungsspezifikation
3.4.1. Lehrtext anschauen
Anwendungsfall Lehrtext anschauen
Kurzbeschreibung: Ein Kursteilnehmer ruft einen Lehrtext auf um ihn anzuschauen
Akteur: Kursteilnehmer
System: CMS
Beschreibung: Das System zeigt Hauptmenü an.
Der Teilnehmer wählt Menüpunkt „Ansicht“. Darauf verifiziert das
System die Rechte und zeigt diejenigen Lehrtexte in einem
Auswahlfeld an, die aktuell sind und für welche die Berechtigung
zum Anschauen vorhanden ist.
Der Teilnehmer wählt gewünschten Lehrtext aus und drückt den
„ok“-Knopf. Falls der gewünschte Lehrtext nicht in der Auswahl
vorhanden ist (weil z.B. Berechtigung fehlt), wird mit Wählen eines
anderen Menüpunkts die Aktion abgebrochen.
Andernfalls zeigt das System den ausgewählten Lehrtext an.
Tab. 1: Anwendungsfall Lehrtext anschauen
Abb. 8: Aktivitätsdiagramm Lehrtext anschauen
34

CMS für die MIO-Lernumgebung Anforderungsspezifikation
3.4.2. Lehrtext erstellen
Anwendungsfall Lehrtext erstellen
Kurzbeschreibung: Ein Autor erfasst einen neuen Lehrtext
Akteur: Autor
System: CMS
Beschreibung: Das System zeigt Hauptmenü an.
Der Teilnehmer wählt Menüpunkt „Erstellen“. Darauf verifiziert das
System die Rechte.
Bei erfolgreicher Verifikation zeigt das System das
Standardformular (Template) für die Lehrtexteingabe im Editor an.
Der Autor gibt den Titel ein. Er wählt seinen Namen und das Thema
des Lehrtextes aus den Auswahlfeldern aus und bestätigt jeweils
seine Wahl mit Drücken des „ok“-Knopfs.
Der Autor fügt mit „Untertitel1 einfügen“, „Untertitel2 einfügen“
und „Textarea einfügen“ neue Felder in das Formular ein oder
löscht diese wieder mit den jeweiligen „Löschen“-Knöpfen.
Um den eingegebenen Lehrtext zu speichern drückt der Autor den
Knopf „Version erstellen“.
Möchte der Autor die Eingaben nicht speichern, kann mir Anwählen
eines anderen Menüpunkts die Aktion abgebrochen werden.
Das System zeigt den eingegebenen Lehrtext an.
Tab. 2: Anwendungsfall Lehrtext erstellen
Abb. 9: Aktivitätsdiagramm Lehrtext erstellen
35

CMS für die MIO-Lernumgebung Anforderungsspezifikation
3.4.3. Lehrtext editieren
Anwendungsfall Lehrtext editieren
Kurzbeschreibung: Ein Mitglied der Gruppe mit Editierrechten bearbeitet einen
vorhandenen Lehrtext
Akteur: Mitglied der Gruppe mit Editierrechten
System: CMS
Beschreibung: Das System zeigt Hauptmenü an.
Das Gruppenmitglied wählt Menüpunkt „Editieren“. Darauf
verifiziert das System die Rechte.
Andernfalls zeigt das System diejenigen Lehrtexte in einem
Auswahlfeld an, die aktuell sind und für welche die Berechtigung
zum Editieren vorhanden ist.
Der Teilnehmer wählt gewünschten Lehrtext aus und drückt den
„ok“-Knopf. Falls der gewünschte Lehrtext nicht in der Auswahl
vorhanden ist (weil z.B. Berechtigung fehlt), wird mit Wählen eines
anderen Menüpunkts die Aktion abgebrochen.
Das System zeigt den ausgewählten Lehrtext im Editor an.
Der Autor bearbeitet den Inhalt.
Der Autor fügt mit „Untertitel1 einfügen“, „Untertitel2 einfügen“
und „Textarea einfügen“ neue Felder in das Formular ein oder
löscht diese wieder mit den jeweiligen „Löschen“-Knöpfen.
Um den bearbeiteten Lehrtext zu speichern drückt der Autor den
Knopf „Version erstellen“.
Das System legt die alte Version des Lehrtextes im Archiv mit dem
Vermerk „veraltet“ ab und zeigt die neue Version an.
Tab. 3: Anwendungsfall Lehrtext editieren
Abb. 10: Aktivitätsdiagramm Lehrtext editieren
36

CMS für die MIO-Lernumgebung Anforderungsspezifikation
3.4.4. Lehrtext prüfen
Anwendungsfall Lehrtext prüfen und freigeben/ablehnen
Kurzbeschreibung: Ein Mitglied der Gruppe mit Prüfrechten kontrolliert einen
vorhandenen Lehrtext und gibt ihn zur Publikation frei oder lässt ihn
nochmals überarbeiten
Akteur: Mitglied der Gruppe mit Prüfrechten
System: CMS
Beschreibung: Das System zeigt Hauptmenü an.
Das Gruppenmitglied wählt Menüpunkt „Prüfen“. Darauf verifiziert
das System die Rechte.
Andernfalls zeigt das System diejenigen Lehrtexte in einem
Auswahlfeld an, die zu prüfen sind und für welche die Berechtigung
zum Prüfen vorhanden ist.
Der Teilnehmer wählt gewünschten Lehrtext aus und drückt den
„ok“-Knopf. Falls der gewünschte Lehrtext nicht in der Auswahl
vorhanden ist (weil z.B. Berechtigung fehlt), wird mit Wählen eines
anderen Menüpunkts die Aktion abgebrochen.
Das System zeigt den gewählten Lehrtext an.
Das Gruppenmitglied kontrolliert den Inhalt des Lehrtextes.
Anschliessend wählt es „freigeben“ oder „ablehnen“ an und drückt
den „ok“-Knopf.
Das System kennzeichnet Lehrtext als freigegeben/nicht freigegeben
und gibt entsprechende Meldung aus.
Tab. 4: Anwendungsfall Lehrtext prüfen
Abb. 11: Aktivitätsdiagramm Lehrtext prüfen
37

CMS für die MIO-Lernumgebung Anforderungsspezifikation
3.4.5. Metadaten verwalten
Anwendungsfall Metadaten verwalten
Kurzbeschreibung: Ein Mitglied der klassenspezifischen Studienleitung bearbeitet die
Metadaten eines aktuellen Lehrtextes
Akteur: Mitglied der klassenspezifischen Studienleitung
Beschreibung: Das System zeigt Hauptmenü an.
Das Gruppenmitglied wählt Menüpunkt „Metadaten verwalten“.
Darauf verifiziert das System die Rechte.
Andernfalls zeigt das System diejenigen Lehrtexte in einem
Auswahlfeld an, deren Metadaten zu bearbeiten sind und für welche
die Berechtigung „Bearbeiten von Metadaten“ vorhanden ist.
Der Teilnehmer wählt gewünschten Lehrtext aus und drückt den
„ok“-Knopf. Falls der gewünschte Lehrtext nicht in der Auswahl
vorhanden ist (weil z.B. Berechtigung fehlt), wird mit Wählen eines
anderen Menüpunkts die Aktion abgebrochen.
Das System zeigt die Metadaten des ausgewählten Lehrtextes in
einem Bearbeitungsformular an.
Das Gruppenmitglied bearbeitet den Inhalt.
Um die bearbeiteten Metadaten zu speichern drückt der Autor den
„ok“-Knopf.
Das System gibt Meldung aus.
Tab. 5: Anwendungsfall Metadaten verwalten
Abb. 12: Aktivitätsdiagramm Metadaten verwalten
38

CMS für die MIO-Lernumgebung Anforderungsspezifikation
3.4.6. Archiv
Anwendungsfall Archiv
Kurzbeschreibung: Ein Kursteilnehmer ruft einen archivierten Lehrtext auf um ihn
anzuschauen.
Akteur: Autor
System: CMS
Beschreibung: Das System zeigt Hauptmenü an.
Der Teilnehmer wählt Menüpunkt „Archiv“. Darauf verifiziert das
System die Rechte und zeigt diejenigen Lehrtexte in einem
Auswahlfeld an, die veraltet sind und für welche die Berechtigung
zum Anschauen vorhanden ist.
Der Teilnehmer wählt gewünschten Lehrtext aus und drückt den
„ok“-Knopf. Falls der gewünschte Lehrtext nicht in der Auswahl
vorhanden ist (weil z.B. Berechtigung fehlt), wird mit Wählen eines
anderen Menüpunkts die Aktion abgebrochen.
Andernfalls zeigt das System den ausgewählten Lehrtext an.
Tab. 6: Anwendungsfall Archiv
Abb. 13: Aktivitätsdiagramm Lehrtext aus Archiv anschauen
39

CMS für die MIO-Lernumgebung Anforderungsspezifikation
3.5. Zustandsmodelle
Mit einem Zustandsmodell soll das dynamische zeitliche Verhalten des Lebenszyklus eines
Lehrtextes (siehe 2.3.3. Content Life Cycle) modelliert werden.
Im Verlaufe seines Bestehens kann ein Lehrtext folgende Zustände annehmen:
- zu prüfen
- freigegeben
- nicht freigegeben
- veraltet
Nach Erstellen eines Lehrtextes ist er automatisch im Zustand „zu prüfen“. Sobald er durch
eine kompetente Stelle kontrolliert wurde, geht er in den nächsten Zustand über. Dieser ist bei
Freigabe des Lehrtextes „freigegeben“ oder bei Ablehnung „nicht freigegeben“.
Ein zu prüfender Lehrtext kann editiert werden. Beim Speichern erhält er den Status
„veraltet“ und wird archiviert. Gleichzeitig wird eine neue Version des Lehrtextes mit den
gemachten Änderungen erstellt. Diese befindet sich wieder im Anfangszustand „zu prüfen“.
Ein archivierter Lehrtext kann nicht mehr editiert, sondern nur noch im Archiv angeschaut
werden. Jedoch besteht jederzeit die Möglichkeit über den Menüpunkt „Metadaten verwalten“
den Status direkt zu ändern und den Lehrtext wieder freizugeben.
Wird ein Lehrtext vom Prüfer abgelehnt, erhält der Autor einen Hinweis, den Text nochmals
zu überarbeiten. Beim Speichern des überarbeiteten Lehrtextes wird eine neue Version erstellt
und die alte ins Archiv abgelegt. So ist es jederzeit möglich, die Entstehungsgeschichte der
Dokumente zu rekonstruieren.
40

CMS für die MIO-Lernumgebung Anforderungsspezifikation
Das folgende Zustandsmodell soll den herkömmlichen Ablauf des Life Cycle eines Lehrtextes
grafisch veranschaulichen.
Abb. 14: Zustandsmodell Life Cycle eines Lehrtextes
Zusätzlich besteht für Berechtigte jederzeit die Möglichkeit, über die Metadatenverwaltung
den Status (zu prüfen, freigegeben, nicht freigegeben, veraltet) eines Lehrtextes in einen
anderen zu überführen.
Abb. 15: Zustandsmodell Status eines Lehrtext ändern
41

CMS für die MIO-Lernumgebung Anforderungsspezifikation
3.6. Analyse des bestehenden Designs
Lehrtexte werden bislang als Dateien in die Umgebung miteingebunden. Sie liegen in
elektronischer Form zum „Download“ im Bereich „Material“ vor. Die Texte sind vom
Benutzer vorab als Datei zu erstellen und können anschliessend bei vorhandener Berechtigung
in die Materialliste aufgenommen werden.
Der Benutzer muss beim „Upload“ den Typ der Datei angeben. Diese kann in einem HTML-
oder in einem sonstigen Format vorliegen. Im letzteren Fall wird als Dateityp „binfile“
angegeben.
Bei Verwendung von anderen Formaten als HTML sollte möglichst darauf geachtet werden,
dass der Browser fähig ist, diese darzustellen.
Statt einer Datei kann auch nur ein Link auf eine Datei erfasst werden.
Zusätzlich zum Dateinamen muss ein Materialname, der Dateityp und die updateberechtigte
Person angegeben werden. Schliesslich wird die Datei einem Termin (Block) zugewiesen,
unter welchem sie später zur Verfügung steht.
Unter dem Menüpunkt „Materialübersicht“ sind die Dateien in einer Tabelle aufgelistet.
Das bestehende Design der Aufbereitung und Ausgabe von Lehrtexten genügt den in Kapitel
3.1. eruierten Anforderungen bei weitem nicht.
Aufgrund der Tatsache, dass ganze Dateien eingespeist werden,
• ist ein einheitliches Erscheinungsbild nicht möglich.
• besteht keine Trennung von Inhalt und Layout.
• sind Metadaten vom Inhalt nicht separierbar und können somit nicht getrennt
bearbeitet werden.
• ist für jeden Dateityp ein eigener Editor nötig.
• müssen Links auf Elemente der Umgebung von Hand in den Lehrtext eingebunden
werden. Dazu sind die Angaben für das Zielattribut des Links im Vorfeld genau
abzuklären.
• müssen diese zur Prüfung evtl. mehrmals vom Benutzer zur Prüfstelle und wieder
zurückgeschickt werden, bis sie veröffentlicht werden können.
Zusätzlich fehlen die Möglichkeiten der Versionierung und Archivierung.
Die erörterten Schwächen eines Dateiuploads können mithilfe eines Content Management
Systems behoben werden.
42

CMS für die MIO-Lernumgebung Architekturentwurf
4. Architekturentwurf
Die in der Analysephase gefällten Entscheide legen die Systemarchitektur fest. Diese ist im
folgenden Kapitel genau beschrieben. Dabei werden die zugrundeliegende Datenbankstruktur
und die daraus hervorgehenden Tabellen erläutert. In einem weiteren Schritt folgt die
Beschreibung der Website-Struktur, von der ein Teilkonstrukt genauer betrachtet wird.
Das Content Management System wird als weiterer Teil in die bestehende MIO-Umgebung
eingebaut. Der Aufruf des CMS geschieht über den Link „CMS“ in der rechtsstehenden
Navigation der Umgebung.
Die der Umgebung zugrundeliegende funktionsorientierte Architektur (siehe [Mahl02])
schreibt die des CMS vor. Zur Realisierung einer Funktion werden teilweise andere
Funktionen aufgerufen. Auf diese Art entsteht eine Hierarchie von Funktionen, wobei
diejenige an der Spitze der Hierarchie das Hauptprogramm darstellt.
Der Datenaustausch zwischen den Modulen erfolgt durch Aufruf mit Parameterübergabe.
Die funktionsorientierte Architektur [Glin98] kann der gewünschten Modularisierung nur
teilweise genügen. Alle Aufgaben, bei denen eine Gruppe von Funktionen einen
gemeinsamen Status verwaltet (im Fall des CMS die Bearbeitung der Dokumenteninhalte im
Editor), müssen die Funktionen zusammen mit den Statusdaten zu einem Modul
zusammengefasst werden. Dies kann bei komplexen funktionsorientierten Entwürfen das
Verständnis erschweren.
Im Folgenden wird das Content Management System von seiner Umgebung abgekoppelt
betrachtet. Die für das CMS-Datenbankschema relevanten Entitäten können aus [Lagl02]
übernommen werden.
Das ER-Diagramm wird mit Microsoft Powerpoint 2000 erstellt.
43

CMS für die MIO-Lernumgebung Architekturentwurf
4.1. Datenbankstruktur
Das folgende ER-Diagramm soll die Datenbank-Struktur des Content Management Systems
näher erläutern. Anhand dieses Schemas können die Zusammenhänge der einzelnen
Gegenstände herausgelesen werden.
Zentraler Punkt dieses Schemas sind die Metadaten. Metadata repräsentiert alle Informationen
über einen Lehrtext. Der Inhalt des Lehrtextes ist separat als Content abgelegt. Jeder Content
hat genau einen Satz an Informationen (Metadata) und umgekehrt.
Über die Metadaten ist jeder Lehrtext mit den übrigen Gegenständen verbunden. Ein Lehrtext
ist zu jeder Zeit in einem Zustand (state), welcher angibt, in welcher Phase des Life Cycle er
sich befindet.
Ein Lehrtext gehört zu einem Thema und hat einen Autor, welcher zu einer oder mehreren
Gruppen gehören kann. Diese wiederum sind Mitglied einer Klasse.
Jeder Lehrtext ist einer oder mehreren Klassen zugeordnet, d.h. jedes Mitglied der Gruppen
einer dieser Klassen hat Zugang zu diesem Dokument.
Die Metadaten geben ausserdem Auskunft darüber, welche Gruppen Editier- oder Prüfrechte
haben.
Abb. 16: ER-Diagramm
Um das Konstrukt durchwegs verstehen zu können, müssen die aus diesem Schema hervorgehenden
Tabellen mitbetrachtet werden. Sie sind vollständig im Anhang zu finden.
Diejenigen, welche einer zusätzlichen Erklärung bedürfen, sind im Folgenden abgedruckt.
44

CMS für die MIO-Lernumgebung Architekturentwurf
Tabellen
Diese in Tabellenform dargestellten Gegenstände und Beziehungen enthalten zusätzlich die
jeweiligen Fremdschlüssel. Grundsätzlich kann die Notation des Schemas aus den weiter oben
vorgestellten Konzepten herausgelesen werden. Erklärungen zu speziellen Beziehungskonstrukten
oder zur Bedeutung spezieller Felder von Gegenständen sind am Ende der
jeweiligen Tabelle angegeben.
metadata
metadata_id int
title text
lock int
version int
date date
*content_type text
persons_id int
themes_id int
classes_id int
state_id int
edit_group_id int
check_group_id int
Tab. 7: Metadata
Metadata beinhaltet alle Informationen über den Lehrtext. Das Feld “lock” hat standardmässig
den Wert 0. Wird ein Lehrtext oder dessen Metadaten bearbeitet, wird das Feld auf 1 gesetzt.
Der entsprechende Lehrtext ist in dieser Zeit für andere Benutzer gesperrt.
„Content_type“ bezeichnet die Art des Inhalts (Lehrtext, Homepage, Mikroartikel). Dieses
Feld steht für eine zukünftige Erweiterung der Umgebung zur Verfügung.
content
content_id int
content text
metadata_id int
Tab. 8: Content
In „content“ wird der eigentliche Inhalt des Lehrtextes gespeichert.
state
state_id int
state text
Tab. 9: State
„State“ beschreibt den Status des Lehrtextes („zu prüfen“, „freigegeben“, „nicht freigegeben“
oder „veraltet“ möglich).
45

CMS für die MIO-Lernumgebung Architekturentwurf
groups_persons
groups_persons_id int
groups_id int
persons_id int
Tab. 10: Groups_persons [Lagl02]
Groups_persons verbindet groups und persons. Da sowohl Personen in mehreren Gruppen
Mitglied sein können (m), als auch Gruppen mehrere Personen beinhalten können (n), muss
ein neues Beziehungsschema definiert werden. Dabei werden die Primärschlüssel von persons
und groups als Fremdschlüssel eingefügt.
classes_groups
classes_groups_id int
classes_id int
groups_id int
Tab. 11: Classes_groups [Lagl02]
Classes_groups verbindet classes und groups. Wie bei groups_persons muss aufgrund der
m:n-Beziehung ein neues Beziehungsschema definiert werden. Die Primärschlüssel von
classes und groups werden als Fremdschlüssel eingefügt.
46

CMS für die MIO-Lernumgebung Architekturentwurf
4.2. Trennung von Inhalt und Layout
Aus der Anforderungsanalyse geht hervor, dass sich die geforderte Trennung von Inhalt,
Gestaltung und Funktionalität mit den vorgeschriebenen Technologien leicht realisieren lässt.
Der Inhalt eines Dokuments wird dabei mit XML beschrieben und für die Gestaltung sorgt ein
XSL-Stylesheet (Template). Als Programmiersprache ist PHP vorgesehen.
Gemäss Anforderungsanalyse soll das zu implementierende System dem Autor die Möglichkeit
bieten, das Template seinen Bedürfnissen anzupassen.
Die Felder „Haupttitel“, „Autor“ und „Thema“ sind im Template schon vorhanden und damit
vorgegeben. Diese können durch die Felder Untertitel1 (Untertitel der Grösse 1), Untertitel2
(Untertitel der Grösse 2) und Textarea ergänzt werden. Titelfelder sind prinzipiell einzeilig,
Textareas werden zehnzeilig angezeigt, wobei deren Inhalt unbegrenzt ist.
Zusätzliche Untertitel- und Textfelder können in beliebiger Anzahl und Reihenfolge eingefügt
werden.
47

CMS für die MIO-Lernumgebung Architekturentwurf
4.3. Struktur der Website
Die Struktur der Website ist im folgenden Diagramm grafisch festgehalten. Das Diagramm ist
hierarchisch aufgebaut, d.h. die Wurzel repräsentiert den Einstieg in die Website, von wo aus
die Ebenen bis zu den Blättern durchlaufen werden können. Links zu verknüpften Seiten sind
mit Pfeilen dargestellt.
Abb. 17: Website-Struktur
48

CMS für die MIO-Lernumgebung Architekturentwurf
Über den Link „CMS“ des Navigationsmenüs der MIO-Umgebung wird der Einstieg in das
Content Management Systems ermöglicht. „Index.html“ stellt die Hauptseite dar, welche sich
als ein in zwei Frames aufgeteiltes Fenster präsentiert. Im oberen Frame befindet sich das
Navigationsmenü (table_of_contents.html), über welches der Inhalt (contents.php) des
unteren Frames bestimmt werden kann.
Abb. 18: Screenprint Index.html
Nach Wahl eines Menüpunkts der Navigation wird über „choose_class.php“ ein Auswahlfeld
mit den vorhandenen Klassen angezeigt.
Die Wahl einer Klasse ist notwendig, da sich jeder Lehrtext auf eine bestimmte Klasse
bezieht. „Contents.php“ übernimmt nach erfolgter Auswahl einer Klasse die Klassen-ID. Der
zusätzlich mitgelieferte Parameter der Navigation-Menüwahl bestimmt die in „contents.php“
abzuarbeitende Funktion (show_content(), new_content(), edit_content(), check_content(),
manage_metadata() oder archive()).
49

CMS für die MIO-Lernumgebung Architekturentwurf
Folgendes Teilkonstrukt soll einen Eindruck vermitteln, wie das Zusammenspiel der
einzelnen Seiten funktioniert und welche Art von Daten überliefert und ausgegeben werden.
Im Beispiel wird der Menüpunkt „Editieren“ angewählt und die entsprechende Funktion
„edit_content()“ in „contents.php“ aufgerufen. Die Funktion „edit_content()“ lässt alle für den
Benutzer zugänglichen Lehrtexte in einem Auswahlfeld anzeigen.
Abb. 19: Screenprint Auswahl Editieren
Die Betätigung des „ok“-Knopfs bestätigt die Wahl des Dokuments und schickt dessen ID an
die Seite „edit_content.php“. „Edit_content.php“ lädt die zur Dokumenten-ID passenden
Daten aus der Datenbank und kreiert den XML-String. Der XSLT-Prozessor „Sablotron“
transformiert den XML-String zusammen mit dem XSL-Stylesheet „content_form.xsl“ in
einen HTML-String.
Das XSL-Stylesheet „content_form.xsl“ stellt ein Template dar, welches von Sablotron mit
den aus der Datenbank geladenen Daten gefüllt und anschliessend im Browser angezeigt wird.
Das Dokument kann nun vom Benutzer bearbeitet werden.
50

CMS für die MIO-Lernumgebung Architekturentwurf
Der Editor ermöglicht dem Benutzer, das Template mit zusätzlichen Titel- oder Textfeldern
zu erweitern („Textarea einfügen“, „Untertitel1 einfügen“ und „Untertitel2 einfügen“) oder
bereits eingefügte wieder zu löschen („Löschen“, jeweils rechts neben entsprechendem Feld).
Die Felder „Autor“ und „Thema“ sind für eine direkte Eingabe gesperrt. Deren Inhalt muss
über „Autor wählen“ und „Thema wählen“ aus einem Auswahlfeld übernommen werden.
Dies garantiert eine korrekte Verlinkung zu einem vorhandenen Element.
Über die neben Textfeldern stehenden Knöpfe „Link/Bild einfügen“ ist es möglich, Links zu
vorhandenen Elementen sowie zu Bildern oder E-Mail-Adressen in den Text einzufügen.
Das System erlaubt auch, die Link-Tags direkt in das Textfeld einzugeben. Aufgrund des
Risikos einer falschen Verlinkung (falsche Zielangabe oder unkorrekte Syntax der Tags) ist
dies aber i.a. nicht zu empfehlen.
Abb. 20: Screenprint Thema und Link in Template („content_form.xsl“) einfügen
51

CMS für die MIO-Lernumgebung Architekturentwurf
Das fertig bearbeitete Dokument wird über „Version erstellen“ gespeichert und angezeigt.
Die Bearbeitung des Templates sowie der Aufruf von Auswahlfeldern und das abschliessende
„Version erstellen“ wird über die Seite „edit_xml.php“ gesteuert. Deren Funktion
„edit_template()“ kreiert nach jeder Benutzeraktion (Benutzer drückt einen der Knöpfe des
Templates) einen neuen XML-String, lässt diesen durch Sablotron mit dem passenden XSL-
Stylesheet („content_form.xsl“) transformieren und im Browser als HTML-String darstellen.
Dabei werden auch die vom Benutzer zwischenzeitlich gemachten Änderungen der Textinhalte
in den neuen XML-String übernommen.
Beim Speichern des Dokuments („Version erstellen“) wird zur Darstellung das XSL-
Stylesheet „content.xsl“ verwendet.
Abb. 21: Screenprint Ausgabe des Dokuments mit Stylesheet „content.xsl“
Die Regeln für einen gültigen XML-Syntax sind in der DTD-Datei „content.dtd“ vorgegeben.
Ist der zu transformierende XML-String regelwidrig zusammengesetzt, gibt der XSLT-
Prozessor eine Fehlermeldung aus.
52

CMS für die MIO-Lernumgebung Architekturentwurf
Im Folgenden wird das restliche Konstrukt der Website vorgestellt.
Nach jeder Menüpunktwahl wird zuerst ein Auswahlfeld der vorhandenen Klassen angezeigt,
von welchen eine ausgewählt werden kann. Alle weiteren Aktionen beziehen sich dann auf
diese Klasse.
Über „Ansicht“ lässt „contents.php“ die Auswahl der aktuellen Lehrtexte anzeigen. Nach
Betätigung des „ok“-Knopfs übergibt die Funktion „show_content()“ die ID des vom
Benutzer gewählten Dokuments an die Seite „show_content.php“. „Show_content.php“ lädt
den entsprechenden XML-String aus der MIO-Datenbank und lässt ihn nach der
Transformation ins HTML-Format im Browser anzeigen.
„Erstellen“ lässt den Benutzer über „new_content.php“ neue Lehrtexte erstellen. Der XML-
String für das anzuzeigende Standardformular wird nicht dynamisch aus der Datenbank
geladen, sondern ist statisch als String im Skript „new_content.php“ vorhanden.
Erstellte Lehrtexte müssen vor der Publikation zuerst geprüft werden. Über den Menüpunkt
„Prüfen“ werden die als „zu prüfen“ markierte Lehrtexte im Auswahlfeld angezeigt. Nach
Betätigung des „ok“-Knopfs wird der gewählte von „check_content.php“ ausgegeben.
Der Prüfer entscheidet über eine Radio-box, ob der Lehrtext freizugeben oder nicht
freizugeben ist. Der Entscheid wird an „set_state.php“ geschickt. „Set_state.php“ nimmt den
entsprechenden Eintrag in der Datenbank vor.
Über „Archiv“ lässt „archive.php“ archivierte Lehrtexte (als „veraltet“ markierte Lehrtexte)
darstellen.
Schliesslich kann der Benutzer über „Metadaten“ die Metadaten der Lehrtexte bearbeiten.
Dazu lässt „contents.php“ die Auswahl der editierbaren Metadaten auflisten. Die gewählten
Metadaten werden anschliessend von „get_metadata“ aus der Datenbank geladen und in
einem herkömmlichen HTML-Formular ausgegeben. Nach Bearbeitung durch den Benutzer
speichert „set_metadata.php“ die gemachten Änderungen in der Datenbank.
Die hier vorgestellte Lösung bzgl. Klassenwahl ist provisorisch. In der neuen Version der
Personenverwaltung [Kaeg02] soll die Klassenwahl vor Aufruf des CMS vorgenommen
werden.
Dies sollte in einer weiteren Version des CMS folgendermassen berücksichtigt werden:
Die vorab gewählte Klasse ist in die Lehrtext-Abfragen der in „contents.php“ abzuarbeitenden
Funktionen (show_content(), new_content(), edit_content(), check_content(), manage_metadata()
oder archive()) miteinzubauen.
Gleichzeitig wird das Skript „choose_class.php“ überflüssig und kann entfernt werden.
Entsprechende Änderungen sind in „table_of_contents.php“ vorzunehmen (die Links der
Navigation müssen neu auf das Skript „contents.php“ zeigen).
53

CMS für die MIO-Lernumgebung Implementierung
5. Implementierung
Nach der Einführung in die Sprache PHP in Kapitel 2 soll nun ein Einblick in den
Programmiercode gegeben werden.
Im Code der MIO-Umgebung musste die Datei frame.php [Mahl02] angepasst werden. Sie ist
für die Anzeige der Navigation der Umgebung zuständig. Die Navigation wurde um den
Menüpunkt „CMS“ ergänzt.
Die MIO-Datenbank [Lagl02] wurde um die Tabellen „metadata“, „content“ und „state“
erweitert.
54

CMS für die MIO-Lernumgebung Implementierung
5.1. Genereller Skriptaufbau
Der grundlegende Skriptaufbau kann von der MIO-Umgebung übernommen werden. Jedes
Skript wird durch die Einbindung von „header.php“ eingeleitet und mit der Einbindung von
„footer.php“ abgeschlossen (siehe [Mahl02]).
„Header.php“ lädt die globalen Variablen und Funktionen der Umgebung, welche teilweise
auch vom CMS benutzt werden müssen. So sind die Variablen vorgegeben, welche für eine
Verbindung zur MySQL-Datenbank benötigt werden. Dabei wird die ADODB-Library
(Active Data Objects DataBase) verwendet, welche einen allgemeingültigen Zugriff auf
verschiedenste Datenbanken (z.B. MySQL, Oracle, MS SQL, Access, Sybase, ODBC und
ADO) ermöglicht. „Header.php“ stellt jeweils bei Ausführung eine Verbindung zur MIO-
Datenbank her. Die Verbindung kann über die globale Variable „$miodb“ angesprochen
werden.
Wird im Skript die Überprüfung der Administratorrechte benötigt, findet jeweils die Funktion
„isAdmin()“ aus „.././inc/functions_auth.inc.php“ [Nier02] Verwendung.
Ist das aktuelle Skript abgearbeitet, wird die Verbindung durch „footer.php“ geschlossen.
Der restliche Inhalt von „header.php“ ist für das CMS nicht relevant.
55

CMS für die MIO-Lernumgebung Implementierung
5.2. Verwendung von $_POST
Die Datenübergabe zwischen zwei PHP-Skripten muss über die PHP-eigenen globalen
Variablen $_GET und $_POST abgewickelt werden. Wie in 2.1.3 erläutert, stehen die Daten
anschliessend als Elemente im Array $_GET[] resp. $_POST[] zur Verfügung.
Werden Daten über ein Formular abgeschickt und ist als Ziel ein PHP-Skript angegeben,
bestimmt das „method“-Attribut, ob die Methode GET oder POST angewendet wird.
Im Unterschied zu POST werden bei GET die Formulardaten über die URL übermittelt,
indem diese an den URL-String angehängt werden.
Die GET-Methode vereinfacht zwar die Handhabung der Daten, hat aber den Nachteil, nur
eine beschränkte Anzahl Zeichen übermitteln zu können. Ist die mögliche Anzahl Zeichen
erreicht, wird der Rest abgeschnitten und nicht mitgeschickt.
Somit ist für das CMS die Anwendung der POST-Methode vorgegeben, da bei Aufruf der
nächsten Seite jeweils der ganze Formularinhalt mitgeschickt wird. Dies ist nötig, weil bei
Wiederaufruf eines Formulars dessen vorheriger Inhalt nicht mehr zur Verfügung steht.
Die Anwendung der POST-Methode schränkt gleichzeitig die Layout-Übernahme der MIO-
Umgebung in das CMS ein:
In der Umgebung werden Auswahlfelder meist als Tabellen dargestellt. Deren rechte Spalten
beinhalten jeweils Links zur Manipulation der Zeileneinträge. Die Datenübergabe mit Links
kann aber nur über die GET-Methode geschehen.
Somit müssen aufgrund der zu verwendenden POST-Methode die Auswahlfelder als
Dropdown-Felder implementiert werden.
Eine mögliche dritte Alternative wäre, die Daten zwischenzeitlich in einem HTTP-Cookie zu
speichern, welches bzgl. der Speichergrösse nicht eingeschränkt ist.
Cookies ermöglichen die Daten-Speicherung innerhalb der jeweiligen Browser-Umgebung.
Da ältere Browser-Versionen mit Cookies teilweise unkorrekt umgehen, wird diese
Alternative wieder verworfen.
Anhand einiger Ausschnitte soll nun der Skript-Code von „edit_xml.php“ vorgestellt und
erklärt werden.
56

CMS für die MIO-Lernumgebung Implementierung
5.3. edit_xml.php
Das Skript „edit_xml.php“ ist für die Bearbeitung des CMS-Templates zuständig. Es
beinhaltet die Hauptfunktion „edit_template()“, die Funktionen „select_author()“ und
„select_theme()“, sowie die Funktion „insert_link()“.
Beim Ausführen von „edit_xml.php“ wird nach Abarbeiten des Headers („header.php“)
automatisch die Hauptfunktion „edit_template()“ aufgerufen.
„Edit_template()“ sorgt dafür, dass die mitgelieferten Formularinhalte des Templates XMLkonform
umgewandelt werden. Der XSLT-Prozessor „Sablotron“ transformiert den
generierten XML-String anschliessend mit einem geeigneten XSL-Stylesheet in eine HTML-
Seite. Diese kann von jedem Browser einwandfrei dargestellt werden.
Solange das Template oder dessen Inhalte bearbeitet werden, verwendet Sablotron das XSL-
Stylesheet „content_form.xsl“, welches die neu generierte HTML-Seite als Formular darstellt.
Erst beim Erstellen einer Version vom Dokument wird das XSL-Stylesheet „content.xsl“ zur
Ansicht des Dokuments verwendet.
Nach jeder Benutzeraktion im Template (Benutzer drückt Knopf) muss die HTML-Seite neu
generiert und angezeigt werden, d.h. jede Aktion führt zu einer Ausführung des Skripts
„edit_xml.php“. Somit ist in „edit_template()“ erst herauszufinden, wo im Template etwas
geändert wurde, d.h. welcher Knopf gedrückt wurde. Dies geschieht mit der Abfrage der
$_POST-Variable:
...
// Folgende Bedingungsanweisungen prüfen, durch welche Aktion (Button) edit_xml.php
// aufgerufen wurde und verarbeiten die jeweiligen in $_POST gespeicherten Variablen
// Button "Neue Version" gedrückt
if (isset($_POST['new_version']))
{
...
}
// Button "Autor wählen" gedrückt
elseif (isset($_POST['select_author']))
{
select_author();
exit;
}
//Autor gewählt, Aufruf von edit_xml.php durch Funktion select_author()
elseif (isset($_POST['selected_author']))
{
…
}
// Button "Thema wählen" gedrückt
elseif (isset($_POST['select_theme']))
{
select_theme();
exit;
}
elseif (!empty($_POST['new_theme']))
{
…
}
//Thema gewählt, Aufruf von edit_xml.php durch Funktion select_theme()
elseif (isset($_POST['selected_theme']))
{
…
57

CMS für die MIO-Lernumgebung Implementierung
}
// Button "Link/Bild einfügen" gedrückt
elseif (isset($_POST['insert_link']))
{
insert_link();
exit;
}
//Link gewählt, Aufruf von edit_xml.php durch Funktion insert_link()
elseif (!empty($_POST['link_form']))
{
...
}
// Button "Löschen" gedrückt
elseif (isset($_POST['delete_field']))
{
…
}
// Button "Textarea einfügen" gedrückt
elseif (isset($_POST['insert_textarea']))
{
…
}
// Button "Untertitel1 einfügen" gedrückt
elseif (isset($_POST['insert_subtitle']))
{
…
}
// Button "Untertitel2 einfügen" gedrückt
elseif (isset($_POST['insert_sub_subtitle']))
{
…
}
...
Bei Betätigung der Knöpfe „Autor wählen“, „Thema wählen“ oder „Link/Bild einfügen“ wird
von „edit_template()“ die entsprechende Funktion („select_author()“, „select_theme()“ oder
„insert_link()“) aufgerufen. Diese Funktionen generieren Auswahlfelder mit entsprechendem
Inhalt. Nach Bestätigung der Wahl durch den Benutzer müssen die Änderungen in das
Template übernommen und dieses neu angezeigt werden. Dafür wird erneut die Funktion
„edit_template()“ aufgerufen.
Die überlieferten Template-Inhalte werden jeweils als Elemente in der globalen PHP-Variable
$_POST gespeicherten. Um die Inhalte weiterverarbeiten zu können, müssen sie zuerst XMLkonform
formatiert (d.h. überflüssige Slashes entfernen, System-Umbruchzeichen durch
-Tags ersetzen) und anschliessend in einen String umgewandelt werden. Der String wird
dann zerlegt und in den Array „$vars“ geschrieben.
...
// die in $_POST gespeicherten Variablen werden xml-konform formatiert
// dabei werden überflüssige Slashes entfernt und System-Umbruchzeichen in Textareas durch
// -Tags ersetzt
// \015 steht für , „Carriage Return“
// anschliessend wird ein String "$post_string" mit allen Variablen in der Form
// "Variablenname=Variableninhalt" erstellt
while(list($key, $val) = each($_POST))
{
$key = stripslashes($key);
$val = stripslashes($val);
$val = preg_replace("/\015/","",$val);
$val = preg_replace("/\015/","",$val);
$val = preg_replace("//","",$val);
58

CMS für die MIO-Lernumgebung Implementierung
}
@$post_string .= "$key=$val&";
// Zerlegen von $post_string und speichern der Stücke im Array $vars
$vars = explode('&',$post_string);
...
Folgende FOR-Schleife durchläuft das erstellte Array und vergleicht jeweils den
Variablennamen mit den Feldern der Switch-Anweisung. Stimmen diese überein, wird der
XML-String um das entsprechende Element mit Inhalt ergänzt. Die Skript-Variable
„$element_count“ sorgt für eine fortlaufende ID-Zuweisung der ins Template eingefügten
Untertitel- und Textfelder. So ist deren Eindeutigkeit garantiert.
Anschliessend wird der XML-String um die benötigten Abschluss-Elemente ergänzt.
...
// Variable, welche die id-nr der Elemente des "Content"-Bereichs festlegt
$element_count = 1;
// Variable, welche den Content für die Datenbank speichert, die Felder maintitle, author,
// theme werden in der DB separat gespeichert (Metadaten)
$content = "";
// in der folgenden for-Schleife wird ein xml-String erstellt
for($i=0;$i

CMS für die MIO-Lernumgebung Implementierung
if((!empty($_POST['new_theme']))|isset($_POST['selected_theme']))
{
$xml_str .= "" . $theme . "";
break;
}
else
{
$xml_str .= "" . $item[1] . "";
}
// für DB
$theme = $item[1];
break;
case "theme_id":
// falls neues Thema,Kommentar eingegeben oder ein Thema gewählt
if((!empty($_POST['new_theme']))|isset($_POST['selected_theme']))
{
$xml_str .= "" . $themes_id . "";
break;
}
else
{
$xml_str .= "" . $item[1] . "";
}
// für DB
$themes_id = $item[1];
break;
case "class_id":
$xml_str .= "" . $item[1] . "";
// für DB
$class_id = $item[1];
break;
case "subtitle_no_".$element_count:
// falls Feld-Nr eines zu löschenden Feldes gegeben und Element-counter
// entsprechendes schon erreicht, wird das zu löschende Feld mit
// demjenigen zur Rechten überschrieben und alle nachfolgenden Felder
// eine Position nach links verschoben
if(isset($field_no_to_delete)&&($element_count>$field_no_to_delete))
{
$shift_fields_left=1;
}
else
{
$shift_fields_left=0;
}
$xml_str.="" . $item[1] . "";
$content.="" . $item[1] . "";
$element_count++;
break;
case "sub_subtitle_no_".$element_count:
// falls Feld-Nr eines zu löschenden Feldes gegeben und Element-counter
// entsprechendes schon erreicht, wird das zu löschende Feld mit
// demjenigen zur Rechten überschrieben und alle nachfolgenden Felder
// eine Position nach links verschoben
if(isset($field_no_to_delete)&&($element_count>$field_no_to_delete))
{
$shift_fields_left=1;
}
else
{
$shift_fields_left=0;
}
$xml_str.="" . $item[1] . "";
60

CMS für die MIO-Lernumgebung Implementierung
}
}
$content .= "" . $item[1] . "";
$element_count++;
break;
case "textarea_no_".$element_count:
// die vor der switch-Anweisung irrtümlich geteilten Stücke (falls im
// Text der Textarea "="-Zeichen vorkommen) werden wieder zusammengefügt
$text = $item[1];
for ($j=2;$j$field_no_to_delete))
{
$shift_fields_left=1;
}
else
{
$shift_fields_left=0;
}
// falls ein Link eingefügt werden soll und die Feldposition stimmt
if (!empty($link) && $element_count == $field_pos)
{
$xml_str.="" . $hr_xml . $link . "";
$content.="" . $hr_xml . $link . "";
$element_count++;
break;
}
// falls ein Bild eingefügt werden soll und die Feldposition stimmt
elseif (!empty($image) && $element_count == $field_pos)
{
$xml_str .= "" . $hr_xml . $image . "";
$content .= "" . $hr_xml . $image . "";
$element_count++;
break;
}
else
{
$xml_str .= "" . $hr_xml . "";
$content .= "" . $hr_xml . "";
$element_count++;
break;
}
case "delete_field":
// falls der Zeiger auf das zu löschende Feld zeigt, wird nur der
// Counter erhöht und beim nächsten switch-Durchgang das nachfolgende
// Feld an die aktuelle Position geschrieben
$element_count++;
break;
// Ergänzen der xml-Strings
$content .= "";
$xml_str = "" . $xml_str . "";
61

CMS für die MIO-Lernumgebung Implementierung
…
Falls „edit_xml.php“ über „Version erstellen“ aufgerufen wurde, wird das Dokument in der
Datenbank gespeichert und der XML-String von Sablotron zur Ansicht (XSL-Stylesheet
„content.xsl“) und nicht in ein Formular (XSL-Stylesheet „content_form.xsl“) umgewandelt.
Um Sablotron verwenden zu können, muss zuerst ein neuer XSLT-Prozessor alloziiert
werden. Anschliessend kann der HTML-String mit Einbezug des gewünschten XSL-
Stylesheets (im Beispiel „content_form.xsl“) generiert und angezeigt werden. Abschliessend
sind die alloziierten Ressourcen des XSLT-Prozessors wieder freizugeben.
Die Anzeige des Templates wird vom Browser gesteuert. Damit nach Bearbeiten des
Template-Formulars die Anzeige automatisch nach unten gescrollt wird, muss auf die Clientseitige
Skriptsprache Java-Script zurückgegriffen werden.
…
$args = array('/_xml' => $xml_str);
// XSLT-Prozessor
$x = xslt_create();
// Transformation des XML-Strings mit XSL-Stylesheet content_form.xsl
$result = xslt_process($x, 'arg:/_xml', 'content_form.xsl', NULL, $args);
if ($result)
{
// Anzeige im Browser
echo $result;
// nach Bearbeitung des Templates wird nach unten zum letzten Feld gescrollt
(diese Anweisung ist nur mit einer Browser-basierten Skriptsprache möglich)
echo "";
echo "{";
echo "window.scrollTo(0,10000000);";
echo "}";
echo "";
}
else
{
echo xslt_error($x);
}
xslt_free($x);
…
Die Funktionen „select_author()” und „select_theme()” bedürfen keiner weiteren Erklärung.
Über die Funktion „insert_link()“ werden in einem Formular Auswahlfelder für die Personen,
Elemente und Bilder der MIO-Umgebung generiert. Zusätzlich enthält das Formular ein Feld
für die Eingabe einer zu verlinkenden E-Mail-Adresse.
Im Fall der Elemente werden diese dynamisch aus der MIO-Datenbank geladen. Pro Element
wird ein Auswahlfeld generiert. So ist garantiert, dass die Auswahl jeweils alle zur Zeit
vorhandenen Elemente beinhaltet.
…
$sql_type = "select type_id, type from type";
$type = $miodb->Execute($sql_type);
$sql ="select elements_id,elements.type_id as
type_id,type,persons_id,groups_id,title,text,forplenum,version,timestamp from elements,type
62

CMS für die MIO-Lernumgebung Implementierung
where elements.type_id=type.type_id";
$result = $miodb->Execute($sql);
if($result == false) die($miodb->ErrorMsg());
// Link zu Element einfügen
while (!$type->EOF)
{
echo "Link zu ".$type->fields['type']." einfügen:";
echo "fields['type']."\">";
echo "";
echo "";
while (!$result->EOF)
{
if ($result->fields['type_id'] == $type->fields['type_id'])
{
echo "fields['elements_id'] . "\">" . $result-
>fields['title']."";
}
}
$result->MoveNext();
$result->MoveFirst();
echo "";
echo "";
$type->MoveNext();
}
echo "";
echo "Bild einfügen:";
echo "";
echo "";
// Bilder sind im Verzeichnis ./../files/images gespeichert
$handle = opendir('./../files/images');
while ($file = readdir ($handle))
{
if ($file != "." && $file != "..")
{
echo "".$file."";
}
}
closedir($handle);
…
Der gewählte Inhalt wird als Link in das aktuelle Textfeld übernommen und in einen
entsprechenden Link-Tag eingefügt.
63

CMS für die MIO-Lernumgebung Implementierung
5.4. XML, XSL und DTD
Die Ausgabe der Lehrtexte im Browser basiert auf den Dateien „content.xsl“,
„content_form.xsl“ und „content.dtd“ und auf dem XML-String. Der XML-String wird nicht
als Datei gespeichert sondern „on-the-fly“ im PHP-Skript generiert.
Nachdem im PHP-Skript der XML-String generiert wurde, transformiert Sablotron diesen mit
dem passenden XSL-Template („content_form.xsl“ für eine Ausgabe im Formular,
„content.xsl“ für eine Anzeige des Dokuments) ins HTML-Format. Dabei werden die Regeln
aus „content.dtd“ berücksichtigt. „Content.dtd“ schreibt genau vor, welche Tags wie und in
welcher Reihenfolge im XML-String verwendet werden dürfen.
Werden die Tags nicht regelkonform eingesetzt, gibt der XSLT-Prozessor beim transformieren
eine entsprechende Fehlermeldung aus.
Das gewählte XSL-Template sorgt schliesslich für ein entsprechendes Layout der Ausgabe. In
„content.xsl“ und „content_form.xsl” werden die XML-Tags aus dem XML-String
interpretiert und als HTML-Tags ausgegeben.
In den XSL-Dateien können neben XML-Tags beliebige HTML-Tags verwendet werden.
Diese übernimmt Sablotron bei der Transformation wie sie sind.
64

CMS für die MIO-Lernumgebung Proof of Concept
6. Proof of Concept
Im Sinne eines „Proof of Concept“ soll nun die Implementation des MIO-Content
Management Systems überprüft werden. Dazu wurde der Lehrstoff aus der Semesterarbeit
von Lukas Haldemann [Hald02] zusammengefasst und für die Eingabe ins CMS in Microsoft
Word aufbereitet.
Die in Microsoft Word durchgeführten Formatierungen des Lehrtextes werden in den
Textareas des CMS übergangen. Zeilenumbrüche und Leerzeilen werden eins zu eins
übernommen, alle weiteren Formatierungen müssen im CMS manuell mit Hilfe der
verwendbaren HTML-Tags vorgenommen werden.
Die Wahl des Autors und des Themas über eine Dropdownliste garantiert eine korrekte
Verlinkung und schützt so vor falschen Eingaben.
Das Hinzufügen neuer Felder ist nur am Ende der Seite möglich, um das Formular möglichst
übersichtlich zu halten. Dies erweist sich nun aber als unpraktisch, da so das Einfügen
zwischen andere Felder nicht möglich ist. Wurde ein Eintrag vergessen oder soll ein
zusätzlicher eingefügt werden, müssen entweder alle Inhalte der nachfolgenden Felder
umkopiert oder an den Inhalt eines schon vorhandenen Feldes angehängt werden. Letzteres
führt möglicherweise zu einer Veränderung der geplanten Gliederung.
Es empfiehlt sich, die notwendigen Formatierungen sofort bei Eingabe des Textes
vorzunehmen.
Das Einfügen und Löschen von Feldern und das Einfügen von Links funktioniert tadellos.
Die Normierung der Textfeldergrösse lässt keine dynamische Anpassung an den Textumfang
zu, was unter Umständen zu fehlender Übersicht führt.
Die mögliche Gliederung mit Untertitel1 und Untertitel2 kann innerhalb der Textfelder z.B.
mit fetter, kursiver oder unterstrichener Formatierung ergänzt werden. Somit ist sie genügend
vielfältig.
Das CMS fügt Links und Bildern jeweils am Ende des entsprechenden Textfeldinhalts ein.
Werden sie an anderer Stelle im Text benötigt, besteht die Möglichkeit, sie mit copy-paste zu
verschieben.
Als Alternative bietet sich die direkte Eingabe der Link-Tags an. Dazu muss das Ziel-Attribut
korrekt angegeben werden, sonst wird das zu verlinkende Element nicht gefunden.
Bei syntaktisch unkorrekter Verwendung der verfügbaren HTML-Tags wird vom System eine
entsprechende Fehlermeldung angezeigt.
Falls dies passiert, ist mit dem „Zurück“-Knopf des Browsers die letzte Aktion rückgängig zu
machen und die Syntax zu korrigieren.
Bei Übernahme von Textteilen aus anderen Quellen mittels „copy-paste“ mussten Satzzeichen
wie Anführungszeichen und Bindestrich ersetzt, d.h. direkt über die Tastatur eingegeben
werden.
Diese Zeichen konnten vom XSLT-Prozessor nicht übersetzt werden, was zu einer
Fehlermeldung führte.
Einfache Anführungszeichen konnten aufgrund datenbanktechnischer Gründe nicht verwendet
werden, weil sie beim Speichern falsch interpretiert wurden.
65

CMS für die MIO-Lernumgebung Proof of Concept
Der Editier-Modus lässt in Textfeldern die Tags von Tabellen und Listen jeweils eingerückt
und mit Zeilenumbrüchen darstellen, was systembedingt (Sablotron) ist.
Bei der Ausgabe der Dokumente werden Tabellen und Listen mit vorangehenden Leerzeilen
dargestellt, was ebenso auf die Interpretation von Sablotron zurückzuführen ist. Dies konnte
nicht umgangen werden.
Ob eine Ergänzung der verwendbaren HTML-Tags durch weitere nötig ist, wird sich in der
Praxis zeigen.
Grundsätzlich empfiehlt sich, vor Gebrauch des CMS die Bedienungsanleitung sorgfältig
durchzulesen, um möglichen Fehlerquellen vorzubeugen.
Die kritisierten Punkte beziehen sich mehrheitlich auf die Client-Seite. Deren Lösung könnte
somit nicht mit Hilfe einer Server-seitigen Scriptsprache wie PHP, sondern müsste mit einer
Client-seitigen Skriptsprache wie Javascript gefunden werden.
Das Proof of Concept hat gezeigt, dass abgesehen von kleineren Mängeln das MIO-Content
Management System ein flexibles, funktionstüchtiges Tool darstellt, welches hält, was es
verspricht.
Aufgrund der Flexibilität des CMS-Tools erübrigt sich die Entwicklung weiterer XSL-
Stylesheets zwar weitgehend, doch ist der Preis dafür eine mögliche Unübersichtlichkeit der
Darstellung aufgrund der nicht dynamisch veränderbaren Textfeldgrössen.
66

CMS für die MIO-Lernumgebung Benutzerdokumentation
7. Benutzerdokumentation
7.1. Einführung
Was ist das Content Management System (CMS)?
Das CMS unterstützt die Verfasser von Lehrtexten (folgend Dokument genannt) für die MIO-
Lernumgebung bei ihrer Arbeit.
Die Eingabe der Lehrtexte erfolgt über ein Formular, welches dynamisch durch den Verfasser
verändert werden kann und so eine flexible Umgebung zur Verfügung stellt.
Die Lehrtexte können ähnlich wie in einer Textverarbeitung manipuliert und zusätzlich durch
eine Auswahl an HTML-Tags ergänzt werden.
Was braucht man zur Nutzung?
Je nach vorhandenen Benutzerrechten ist die Auswahl der editierbaren Texte mehr oder
weniger eingeschränkt.
Über den Menüpunkt "CMS" in der Menüleiste der MIO-Lernumgebung kann auf das System
zugegriffen werden.
67

CMS für die MIO-Lernumgebung Benutzerdokumentation
7.2. Bedienung
7.2.1. Hauptfenster
Nach dem Start des CMS präsentiert sich die Hauptseite als ein in zwei Frames aufgeteiltes
Fenster, von welchen der obere die Navigations- und der untere den Contentbereich
beinhaltet. Im Contentbereich wird jeweils der gewünschte Inhalt angezeigt.
Abb. 22: Screenprint Hauptfenster
68

CMS für die MIO-Lernumgebung Benutzerdokumentation
7.2.2. Funktionen
Die Menüleiste des Navigationsbereichs beinhaltet die Funktionen Ansicht, Erstellen,
Editieren, Prüfen von Content, Verwalten der Metadaten und Archiv-Ansicht.
Im Folgenden werden diese Funktionen erklärt.
Funktion Ansicht
Über die Ansicht können die aktuellen Versionen der Dokumente angeschaut werden, sofern
die benötigten Rechte vorhanden sind.
Das Anwählen des "Ansicht"-Links öffnet ein Auswahlfenster mit den vorhandenen Klassen.
Nach Auswahl der gewünschten Klasse und der anschliessenden Bestätigung über den „ok“-
Knopf öffnet sich ein weiteres Auswahlfenster, welches die aktuellen Versionen der
Dokumente zu dieser Klasse auflistet. Jede Zeile enthält Titel, Autor, Thema, Version und
Erstellungsdatum des jeweiligen Dokuments.
Ist eine Wahl getroffen, wird nach Betätigung des "ok"-Knopfs das gewünschte Dokument
angezeigt.
Abb. 23: Screenprint Ansicht
69

CMS für die MIO-Lernumgebung Benutzerdokumentation
Funktion Erstellen
Das Erstellen eines neuen Dokuments wird über den Menüpunkt "Erstellen" ermöglicht. Die
Eingabe erfolgt in einem Standard-Formular, in welchem die drei Felder "Haupttitel", "Autor"
und "Thema" vorgegeben sind.
Abb. 24: Screenprint Erstellen
Die Einträge dieser Felder sind Pflicht, wobei die direkte Eingabe gesperrt ist. Durch
Betätigung der Knöpfe "Autor wählen" resp. "Thema wählen" werden Auswahlfelder
angezeigt. Diese beinhalten die vorhandenen Einträge für die Felder „Autor“ und „Thema“.
70

CMS für die MIO-Lernumgebung Benutzerdokumentation
Zusätzlich zur Wahl vorhandener Themen können neue Themen aufgenommen und über den
„Speichern“-Knopf in die Datenbank geschrieben werden. Ein neuer Autor muss über die
Lernumgebung eingegeben werden.
Abb. 25: Screenprint Thema wählen
Nach Bestätigung über den "ok"-Knopf wird die Wahl in das entsprechende Feld übernommen.
71

CMS für die MIO-Lernumgebung Benutzerdokumentation
Im Formular besteht die Möglichkeit, weitere Felder zu den vorhandenen hinzuzufügen:
Untertitel1 (Untertitel der Grösse 1, fett),
Untertitel2 (Untertitel der Grösse 2) und
Textarea
Diese zusätzlichen Felder können in beliebiger Anzahl und Reihenfolge eingefügt werden.
Jedes Feld kann jederzeit durch den nebenstehenden Knopf "Löschen" wieder entfernt
werden, wobei die Eingaben im entsprechenden Feld verloren gehen.
Wurde ein "Löschen"-Knopf versehentlich betätigt, besteht die Möglichkeit, über den
"Zurück"-Knopf des Browsers, die Änderung rückgängig zu machen.
Abb. 26: Screenprint Untertitel1, Untertitel2 und Textarea
72

CMS für die MIO-Lernumgebung Benutzerdokumentation
Erklärungen zum Feld Textarea:
Die Eingabe in eine Textarea erfolgt ähnlich wie in einer Textverarbeitung. Das Betätigen der
Enter-Taste bewirkt einen Zeilenumbruch, Leerzeichen und -zeilen können beliebig eingefügt
werden und Umlaute werden als ä, ö und ü und nicht etwa als ü etc. geschrieben.
W I C H T I G:
Bei Übernahme von Textteilen aus einer anderen Quelle mittels „copy-paste“ ist darauf zu
achten, dass Satzzeichen wie „Anführungszeichen“ und „Bindestrich“ ersetzt, d.h. direkt über
die Tastatur eingegeben werden, da diese teilweise vom XSLT-Prozessor nicht interpretiert
werden können. Dies führt zu einer Fehlermeldung.
„Einfache Anführungszeichen“ können aufgrund datenbanktechnischer Gründe nicht
verwendet werden.
Um den Text weiter zu formatieren, können HTML-Tags verwendet werden.
Folgende stehen zur Auswahl:
• Tabelle: mit den Tags , und
• Listen: mit dem Tag
mit dem Tag
• Fett:
• Kursiv:
• Unterstrichen:
• Trennstrich:
• Umbruch: (wie Enter-Taste)
Alle verwendbaren HTML-Elemente (ausser und ) bestehen aus einem einleitenden
und einem abschliessenden Tag.
W I C H T I G:
Die Tags dürfen nur mit den hier angegebenen Attributen verwendet werden! Sie müssen
richtig (d.h. syntaktisch korrekt) eingegeben werden! Ansonsten besteht die Gefahr, dass die
Übersetzung des XML-Strings fehlschlägt und das Dokument fehlerhaft oder gar nicht
angezeigt wird. In diesem Fall gibt der XML-Parser eine Fehlermeldung aus:
73

CMS für die MIO-Lernumgebung Benutzerdokumentation
Abb. 27: Screenprint Syntaktisch unkorrekte Tag-Eingabe
Dem Benutzer muss bewusst sein, dass sich der Text in den Textfeldern wie in der Textverarbeitung
verhält, d.h. jeder Zeilenumbruch nach einem HTML-Tag wird auch als solcher
vom XML-Parser interpretiert und angezeigt.
Der Editier-Modus lässt in Textfeldern die Tags von Tabellen und Listen jeweils eingerückt
und mit Zeilenumbrüchen darstellen (systembedingt).
74

CMS für die MIO-Lernumgebung Benutzerdokumentation
Abb. 28: Screenprint Eingerückte Listen- und Tabellen-Tags in der Textarea
Über den Knopf "Link/Bild einfügen" können Link-Tags eingefügt werden. Zuerst öffnet
sich ein Fenster mit folgenden Auswahlfeldern:
• Link zu Person einfügen:
• Link zu Mikroartikel einfügen:
• Link zu Autor einfügen:
• Link zu Literaturquelle einfügen:
• Link zu Zitat einfügen:
• Link zu Rezension einfügen:
• Link zu Link einfügen:
• Link zu Buch einfügen:
• Link zu Teilnehmer einfügen:
• Link zu Mentoren einfügen:
• Link zu Referenten einfügen:
• Bild einfügen:
Zusätzlich ist ein Eingabefeld für einen E-Mail-Adressen-Link und eines für einen WWW-
Link vorhanden:
• Link zu E-Mail-Adresse einfügen:
(z.B. hans.muster@muster.com)
• WWW-Link einfügen:
(z.B. http://www.muster.com)
75

CMS für die MIO-Lernumgebung Benutzerdokumentation
Abb. 29: Screenprint Link/Bild einfügen
Die Inhalte dieser Auswahlfelder müssen über die Lernumgebung eingegeben werden.
Die Auswahl aus einem der Auswahlfelder muss mit Betätigung des entsprechenden "ok"-
Knopfs bestätigt werden.
76

CMS für die MIO-Lernumgebung Benutzerdokumentation
Links wird am Ende des Textfeldes eingefügt und nicht etwa dort, wo der Cursor steht.
Es kann gleichzeitig nur ein Link übertragen werden. Deshalb muss darauf geachtet werden,
dass nur im gewünschten Feld ein Eintrag ausgewählt wird und die übrigen Felder leer
bleiben. Dieser Vorgang kann beliebig oft wiederholt werden.
Abb. 30: Screenprint Textarea-Eintrag
Um fehlerhafte Syntax zu vermeiden, sollten die in der Textarea eingefügten Link-Tags nicht
mehr verändert werden.
Das System erlaubt, die Link-Tags direkt in das Textfeld einzugeben. Aufgrund des Risikos
einer falschen Verlinkung (falsche Zielangabe oder unkorrekte Syntax der Tags) ist dies aber
i.a. nicht zu empfehlen.
Ist ein Link-Tag im Text nicht mehr erwünscht, kann es wie normaler Text gelöscht werden.
Dabei sollte darauf geachtet werden, dass das End-Tag (z.B. "", erkennbar durch den
vorangestellten Schrägstrich im Tag) mitgelöscht wird.
77

CMS für die MIO-Lernumgebung Benutzerdokumentation
Sind alle Einträge gemacht, wird das Dokument über den Knopf "Version erstellen"
gespeichert und angezeigt.
Abb. 31: Screenprint Ausgabe
Falls ein Dokument mit den gleichen Angaben in den Feldern "Haupttitel", "Autor" und
"Thema" schon in der Datenbank vorhanden ist, wird es durch das aktuelle nicht
überschrieben, sondern als neue Version abgespeichert. Ansonsten wird eine Version 1
erstellt.
Die neue Version erhält automatisch den Vermerk "zu prüfen".
Jedes Betätigen eines Knopfs bewirkt, dass die aktuelle Seite neu übersetzt und wieder
angezeigt wird. Schlägt die Transformation fehl (z.B. aufgrund der Verwendung fehlerhafter
Tags), wird die neu übersetzte Seite fehlerhaft oder gar nicht angezeigt. Durch Betätigung
des „Zurück“-Knopfs des Browsers kann die Aktion rückgängig gemacht und die Ursache
des Fehlschlagens eruiert werden. Nachdem der Fehler korrigiert wurde, kann die gewünschte
Aktion erneut ausgeführt werden.
78

CMS für die MIO-Lernumgebung Benutzerdokumentation
Funktion Editieren
Schon erstellte Dokumente können über den Menüpunkt "Editieren" neu bearbeitet werden.
Nachdem zuerst wiederum die gewünschte Klasse ausgewählt wurde, werden
im Auswahlfenster alle aktuellen Dokumente aufgelistet. Jede Zeile enthält Titel, Autor,
Thema, Version und Erstellungsdatum des jeweiligen Dokuments. Diejenigen Dokumente,
die gerade von anderen Benutzern bearbeitet werden, erscheinen in der Auswahlliste mit dem
Vermerk "gesperrt" und können zur Zeit nicht editiert werden.
Ist eine Wahl getroffen, wird nach Betätigung des "ok"-Knopfs das gewünschte Dokument als
Formular angezeigt. Gleichzeitig wird es für andere Benutzer gesperrt.
Die Seite des Dokuments beinhaltet die Standardfelder „Haupttitel“, „Autor“ und „Thema“
mit etwaigen zusätzlich eingefügten Feldern und deren Inhalt, welcher wie gehabt bearbeitet
werden kann.
Für Erklärungen zur Bedienung dieser Seite siehe 2.2.2. Erstellen.
Die Sperrung eines Dokuments für andere wird erst aufgehoben, wenn es vom Benutzer als
neue Version abgespeichert wird. Falls dieser also vor dem Abspeichern ein weiteres
Dokument oder eine Seite ausserhalb des CMS aufrufen würde, müsste er mit dem „Zurück“-
Knopf des Browsers zurückspringen und die Bearbeitung korrekt abschliessen.
Andernfalls bliebe dieses Dokument in der Datenbank als „gesperrt“ gekennzeichnet
und könnte nicht mehr editiert werden. In diesem Fall müsste der Administrator
benachrichtigt werden.
79

CMS für die MIO-Lernumgebung Benutzerdokumentation
Funktion Prüfen
Soll ein erstelltes oder verändertes Dokument veröffentlicht werden, ist es notwendig, dieses
vorher durch kompetente Stellen prüfen zu lassen. Der Prüfer entscheidet, ob das Dokument
freigegeben wird oder nochmals überarbeitet werden muss. Im letzteren Fall benachrichtigt er
den Redakteur des Dokuments und teilt ihm die notwendigen Änderungen mit.
Nach Auswahl der Klasse stehen in der Auswahlliste diejenigen Dokumente, welche als "zu
prüfen" markiert sind. Wie beim "Editieren" (siehe 2.2.3. Funktion Editieren) sind diejenigen
Dokumente, die gerade von anderen Benutzern bearbeitet werden, als "gesperrt" gekennzeichnet
und stehen im Moment nicht zur Verfügung.
Nach Betätigen des "ok"-Knopfs wird das gewählte Dokument angezeigt.
Am Ende der Seite kann über eine Radio-Box-Auswahl das Dokument zur Veröffentlichung
freigegeben oder abgelehnt werden. Zur Bestätigung wird der "ok"-Knopf gedrückt.
Abb. 32: Screenprint Genehmigen/Ablehnen
80

CMS für die MIO-Lernumgebung Benutzerdokumentation
Metadaten verwalten
Metadaten sind Informationen über ein Dokument. Sie beschreiben es nach formalen und
inhaltlichen Aspekten. Dazu gehören in unserem Fall:
• Haupttitel
• Autor
• Thema
• Version
• Status
• Erstellungsdatum
• Gruppe mit Editierberechtigung
• Gruppe mit Leseberechtigung
• Klasse
Diese Angaben können unabhängig vom Content (Inhalt) des Dokuments jederzeit angeschaut
und bearbeitet werden.
Sind die notwendigen Berechtigungen vorhanden, können über die Auswahlliste und
anschliessendes Betätigen des "ok"-Knopfs die Metadaten des gewünschten Dokuments der
zuvor gewählten Klasse aufgerufen werden.
Auch hier sind diejenigen Dokumente, die zur Zeit von anderen Benutzern bearbeitet werden,
als "gesperrt" gekennzeichnet und stehen nicht zur Verfügung. Die Metadaten älterer
Versionen der Dokumente können nicht mehr bearbeitet werden.
81

CMS für die MIO-Lernumgebung Benutzerdokumentation
Das sich öffnende Formular enthält die weiter oben aufgelisteten Informationen über das
gewählte Dokument.
Abb. 33: Screenprint Metadaten
Mit dem Manipulieren von Metadaten sollte vorsichtig umgegangen werden. Um Inkonsistenz
zwischen verschiedenen Versionen der Dokumente zu vermeiden, sind die Felder „Version“
und „Erstellungsdatum“ schreibgeschützt.
Über den "ok"-Knopf werden die Änderungen zurück in die Datenbank geschrieben.
82

CMS für die MIO-Lernumgebung Benutzerdokumentation
Archiv
Über den Menüpunkt "Archiv" werden dem Benutzer sämtliche archivierte Versionen der
Dokumente einer gewählten Klasse zur Verfügung gestellt.
Die Versionierung dokumentiert die Veränderungen der Dokumente, da diese nach jedem
Editieren als neue Version abgespeichert werden (siehe 2.2.1. Erstellen).
Ist das gewünschte Dokument ausgewählt, wird es nach Betätigung des "ok"-Knopfs angezeigt.
83

CMS für die MIO-Lernumgebung Zusammenfassung und Ausblick
8. Zusammenfassung und Ausblick
In der folgenden Zusammenfassung werden die wichtigsten Ergebnisse aufgeführt und die
aufgetretenen Probleme erörtert.
Der anschliessende Ausblick soll zu Überlegungen für etwaige zukünftige Erweiterungen des
Tools anregen.
8.1. Zusammenfassung
Die Ergebnisse der Arbeit sind eine funktionstüchtige Implementation eines Content
Management Systems, eine Ausarbeitung einer Dokumentation und einer beispielhaften
Lehreinheit sowie einer Bedienungsanleitung.
Die Implementation des CMS erfüllt die Erwartungen bzgl. Funktionalität und Flexibilität.
Die Ausarbeitung der Dokumentation führt genügend in die Thematik und die verwendeten
Technologien ein, so dass sie für das Verständnis des Projekts und der Funktionsweise, die
Wartung und die Erweiterung des Systems ausreicht.
Die Bedienungsanleitung ist klar verständlich und bedarf keinen Vorkenntnissen über das
System.
Das Ziel der Arbeit ist somit erreicht worden.
Zu Problemen führte das Einrichten der Arbeitsumgebung auf einem Windows 2000 System.
Bis zum Schluss war es nicht möglich, die Konfiguration der verwendeten PHP-Version auf
die installierte MIO-Umgebung abzustimmen.
Somit musste das CMS ohne Einbezug der Umgebung entwickelt und am Ende auf dem MIO-
Server am Institut für Informatik in die MIO-Umgebung eingebunden werden. Dies führte
dazu, dass jegliche Überlegungen bzgl. Zugangsberechtigung erst am Schluss umgesetzt und
auf dem MIO-Server integriert und getestet werden konnten, was schliesslich aufgrund
unvorhergesehener Probleme mit dem auf dem MIO-Server installierten XSLT-Prozessor
Sablotron zu erheblichem Zeitdruck führte.
Sablotron interpretierte den XSL-Code teilweise anders wie der auf der eigenen Umgebung
installierte XT [Javaxt]. Somit mussten die XSL-Templates nochmals überarbeitet werden.
8.2. Ausblick
Das CMS-Tool kann in seiner Funktionalität beliebig erweitert werden.
Weitere Anforderungen des „state of the art“ können realisiert und eingebunden werden.
So wäre z.B. die Erweiterung um eine Link-Management-Funktion weitere Überlegungen
wert.
Weitere Ausgabe-Formate neben HTML sind zukünftig wahrscheinlich notwendig (z.B. PDF,
WML etc.), was sich durch geringfügige Änderungen der Skripte leicht realisieren lässt.
Ebenso besteht die Möglichkeit das vorhandene Template durch weitere zu ergänzen.
Bezüglich Formatierungsmöglichkeiten der Lehrtexte ist zu überlegen, ob weitere Tags
eingeführt werden sollten.
84

CMS für die MIO-Lernumgebung Zusammenfassung und Ausblick
Eventuell ist ein Parser einzubinden, der den vom Benutzer formatierten Text auf XML-
Konformität prüft und automatisch korrigiert.
Bilder werden vorerst aus einem Bildverzeichnis geladen. In einer weiteren Version sollte es
in die Datenbank integriert werden.
85

CMS für die MIO-Lernumgebung Literaturverzeichnis
9. Literaturverzeichnis
[Apache] Apache: http://www.apache.org
[Cmseva] Content Management System Evaluation:
http://www.atnf.csiro.au/computing/web/cms_eval.html
[Contma] Contentmanager.de: Content Management, www.contentmanager.de
[Ditt99] Dittrich Prof.Dr.K.: Datenbanksysteme - Skript zur Vorlesung, Institut für
Informatik, Universität Zürich, WS 99/00
[Ecks00] Eckstein R.:XML-kurz und gut, O’Reilly, 2000
[Glin00] Glinz, Prof.Dr.M.: Requirements Engineering - Skript zur Vorlesung,
Institut für Informatik, Universität Zürich, WS 00/01
[Glin98] Glinz, Prof.Dr.M.: Software Engineering I – Skript zur Vorlesung,
Institut für Informatik,Universität Zürich, WS 98/99
[Hald02] Haldemann L.: Metaphern in der Führung von komplexen IT-Projekten –
Semesterarbeit, Institut für Informatik, Universität Zürich, 2002
[Idccom] IDC: The Learning Content Management System -
White Paper http://www.idc.com
[Intern] InternetTime: http://www.internettime.com
[Javaxt] Java XSLT-Prozessor: http://jclark.com/xml/xt.html
[Kaeg02] Kägi U.: Entwicklung eines Tools für die Kundenadministration in der MIO -
Lernumgebung - Semesterarbeit, Institut für Informatik, Universität Zürich, 2002
[KrKo02] Krüger J. D., Kopp M.: Web Content managen, Markt u.Technik, 2002
[Lagl02] Lagler S.: MIO-Lernlandschaft – Semesterarbeit, Institut für Informatik,
Universität Zürich, 2002
[Mahl02] Mahler M.: MIO-Lernlandschaft – Semesterarbeit, Institut für Informatik,
Universität Zürich, 2002
[Midgar] Midgard – Open Source Content Management System:
http://www.midgard-project.org
[Mysqlc] MySQL: http://www.mysql.com
[Netcra] Netcraft: http://www.netcraft.com
[Nier02] Nierlich M.: Authorisationskonzept der MIO-Lernumgebung –
Semesterarbeit Institut für Informatik, Universität Zürich, 2002
86

CMS für die MIO-Lernumgebung Literaturverzeichnis
[Nohr00] Nohr H.: Content Management – Die Einführung von Content
Management Systemen, Fachhochschule Stuttgart, 2000
http://www.hbi-stuttgart.de/nohr
[Pinuts] Pinuts.de: Content Management,
http://www.pinuts.de/ie/cms/content_management_systeme/index.html,
White Paper http://www.pinuts.de/ie/WP_CMS_Einfuehrung.pdf
[Phpcen] Online-Tutorial: http://www.php-center.de
[Phpmya] PhpMyAdmin: http://www.phpmyadmin.org
[Phpnet] Online-Tutorial: http://www.php.net
[RoRi01] Rothfuss G., Ried C.: Content Management mit XML - Grundlagen und
Anwendungen, Springer, 2001
[Selfxm] Online-Tutorial: http://www.selfxml.de
[Shep02] Shepherd, Devan: XML, Markt u.Technik, 2002
[Typo3c] Typo3 - Open Source Content Management System:
http://www.typo3.com
[Wein00] Internet Professionell, Ausgabe 07/2000, Weinstein A.:
Inhalte effektiv verwalten
[Xmlgur] Online-Tutorial: http://www.xmlguru.de
[Zoporg] Zope – Open Source Content Management System: http://www.zope.org
[ZsTr01] Zschau O., Traub D., et al.: Web Content Management –
Websites professionell planen und betreiben, Galileo Business, 2002
87

CMS für die MIO-Lernumgebung Anhang A
Anhang A: Tabellen
metadata
metadata_id int
title text
lock int
version int
date date
*content_type text
persons_id int
themes_id int
classes_id int
state_id int
edit_group_id int
check_group_id int
Tab. 12: Metadata
content
content_id int
content text
metadata_id int
Tab. 13: Content
state
state_id int
state text
Tab. 14: State
groups_persons
groups_persons_id int
groups_id int
persons_id int
Tab. 15: Groups_persons [Lagl02]
classes_groups
classes_groups_id int
classes_id int
groups_id int
Tab. 16: Classes_groups [Lagl02]
88

CMS für die MIO-Lernumgebung Anhang A
classes
classes _id int
classname varchar
classdesc text
Tab. 17: Classes [Lagl02]
groups
groups_id int
groupname varchar
groupsdesc text
Tab. 18: Groups [Lagl02]
themes
themes_id int
*comment text
theme varchar
Tab. 19: Themes [Lagl02]
persons
persons_id int
person_firstname varchar
person_name varchar
password varchar
street varchar
areacode varchar
city varchar
email_address varchar
phone_number varchar
fax_number varchar
birthday date
Tab. 20: Persons [Lagl02]
89

CMS für die MIO-Lernumgebung Anhang B
Anhang B: Metaphern in der Führung komplexer IT-Projekte
[Hald02] aufbereitet als Lehreinheit
Metaphern in der Führung komplexer IT-Projekte
1. Einleitung
In der Praxis ist vielfach zu beobachten, dass Informatikprojekte verzögert werden oder sogar
scheitern, weil zwischenmenschliche Probleme im Projektteam auftreten.
Im Folgenden soll die aktuelle Situation bzgl. der Führung von komplexen IT-Projekten aus
Sicht der Praxis analysiert und sich stellende Probleme aufgezeigt werden. Des weiteren
werden Führungsansätze untersucht, welche IT-Projekte als soziale Systeme betrachten. Vor
diesem Hintergrund werden Metaphern vorgestellt und bzgl. deren situationsbezogener
Anwendung bewertet.
2. Analyse der Situation der Führung komplexer IT-Projekte
2.1. Aktuelle Situation
Eine Umfrage bei vier Projektverantwortlichen in drei Schweizer Unternehmen ergab
Aufschluss über die aktuelle Situation:
Die Erfolgsquote der IT-Projekte genügt nicht, da die Investitionen nicht den erwarteten
Nutzen bringen. Die Komplexität der Entwicklungsprozesse nimmt stark zu.
Die time-to-market wird kürzer, was zu einem immer grösseren Zeitdruck führt.
Unrealistische Zeitpläne sind die Konsequenz. IT-Business-Lösungen sind zunehmend
kontinuierlichem Wandel unterworfen.
Die Diskrepanz des Verständnisses zwischen den Entwicklern und den Anwendern mit ihren
sehr vagen Vorstellungen erschwert die Zusammenarbeit. Die unterschiedlichen Sichtweisen
von Managern, Benutzern/Kunden und Entwicklern führen häufig zu Problemen, die durch
ungenügende und unklare Kommunikation noch verstärkt werden.
Die Unsicherheit des Marktes wirkt sich via Unternehmensleitung bis auf die IT-Projektebene
aus. Verantwortung wird ungern übernommen.
Der Nutzen der IT ist nur schwer quantifizierbar.
Aufgrund der auf Unternehmensebene herrschenden Primärorganisation und der auf
Projektebene herrschenden Sekundärorganisation kann die Doppelunterstellung zu
Interessenkonflikten führen.
90

CMS für die MIO-Lernumgebung Anhang B
2.2. Erwartungen an die Führung
Motivation ist Teil der Führungsaufgabe. Den Mitarbeitern werden Rolle, Aufgabe und Ziel
vorgegeben, was nach Ansicht vieler Praktiker eine motivierende Wirkung hat. Hohe
Eigenverantwortung wirkt ebenso motivierend.
„Nach Fredmund Malik gründet ein schlechtes Arbeitsklima weniger auf einem Motivations-
sondern vielmehr auf einem Vertrauensproblem“ [Baz02].
Die Unternehmenskultur als Leitbild kann ebenso motivierend auf die Mitarbeiter wirken.
Gemäss den Aussagen der befragten Firmenvertreter liegen die Probleme vorwiegend im
zwischenmenschlichen Bereich (soft factors) und weniger im technischen Bereich (hard
factors).
Zwischenmenschliche Probleme werden mehr und mehr zum Stolperstein. Es fehlt an der
Fähigkeit Konflikte zu lösen.
Nach Aussagen der Interview-Partner wird zukünftig Folgendes von Führenden erwartet:
„Menschenkenntnis.“
„Erkennen, ob eine Person am richtigen Ort eingesetzt ist“
„Bewusstsein für soft factors“
„Verschiedene Kulturen prallen aufeinander – ein Projektleiter muss damit umgehen
können“
„Erkennen von verdeckten Konflikten“
„Knowing your limitations.“
3. Konzeptionelle Ansätze zur Führung komplexer IT-Projekte
3.1. Abgrenzung Führung, Leadership und Management
Die Begriffe „Führung“, „Leadership“ und „Management“ werden gerne verwechselt oder
verschieden interpretiert.
Folgend werden die Definitionen nach Hinterhuber [Hint97] verwendet:
Leadership heisst, neue Möglichkeiten erschliessen und umsetzen (oder umsetzen lassen)
sowie die unternehmerischen Veränderungsprozesse so gestalten, dass Werte für die Kunden
geschaffen und dadurch auch die übrigen Partner der Unternehmung zufrieden gestellt
werden.
Management heisst, Probleme auf kreative Art und Weise zu lösen mittels einer Vielzahl von
Instrumenten, Methoden und Einstellungen, mit welchen das Unternehmen
Wettbewerbsvorteile gewinnen kann.
Der Begriff „Führung“ umfasst Leadership und Management.
91

CMS für die MIO-Lernumgebung Anhang B
Leadership als Management als
Entdecken neuer Möglichkeiten, Kreatives Lösen von Aufgaben
verbunden mit der Fähigkeit, diese
umzusetzen
Schaffen von neuen Paradigmen Arbeit innerhalb eines Paradigmas
Arbeit am System Arbeit im System
Mitarbeiter anregen und in die Lage Dinge und Menschen in Bewegung
versetzen,
erbringen
Spitzenleistungen zu setzen mit Methoden und Techniken
Ehrfurcht vor dem Menschen Der Mensch als Hilfe
Einstellung des Dienens Einstellung des Machens
Das Kommende vorbereiten und Die vereinbarten Ziele innovativ
Veränderung
herbeiführen
antizipieren und erreichen und Bestehendes optimieren
Führen mit Wünschen Führen mit konkreten, mess- und
kontrollierbaren Zielen
Vorausdenken und Handeln Denken und Handeln (operationell)
(evolutionell-revolutionär)
Tab. 21: Begriff Leadership vs. Management [Hald02]
3.2. Komplexität
Es gibt verschiedene Definitionen von Komplexität:
• Nach Duden ist Komplexität die „Gesamtheit aller Merkmale und Möglichkeiten oder
Vielschichtigkeit“ [DuBa5].
• Ulrich/Probst [UlPr91] definieren die Komplexität als „die Fähigkeit eines Systems, in
einer gegebenen Zeitspanne eine grosse Zahl von verschiedenen Zuständen annehmen
zu können“.
• Willke [Will00] bezeichnet Komplexität als den „Grad der Vielschichtigkeit,
Vernetzung und Folgelastigkeit eines Entscheidungsfeldes“.
• Nach Neis [Neis] werden Systeme erst durch ihre Komplexität lebendig. Wird diese
reduziert, fällt das System in sich zusammen. Man kann niemals Komplexität
reduzieren, ohne destruktiv zu sein.
In komplexen IT-Projekten verstehen wir Führung folglich als Kombination von
• Management (kreativen Lösen von Aufgaben und Problemen eines Systems mittels
einer Vielzahl von Instrumenten, Methoden und Techniken)
und
• Leadership (Erarbeitung und Erhaltung eines Projektumfelds, das für alle Beteiligten
motivierend wirkt und die Kommunikation und das Engagement aller Beteiligten
fördert).
92

CMS für die MIO-Lernumgebung Anhang B
Die folgenden Ausführungen beschränken sich auf den Leadership-Aspekt.
3.3. Führungsmodelle als soziale Systeme
3.3.1. Willke -Systemtheorie
In Willke’s Systemtheorie hat ein System (und damit auch komplexe IT-Projekte) ein
Eigenleben und lässt sich somit nicht wie Maschinenmodelle mit „Wenn-dann-Programmen“
steuern. Willke geht von einer „Logik des Misslingens“ aus, d.h. dass Interventionsvorhaben
an der Komplexität, Eigenlogik und Widerständigkeit der Probleme scheitern. Zum
Normalfall wird die „Unwahrscheinlichkeit gelingender Intervention“ [Will99], was vor allem
bei komplexen sozialen Systemen zutrifft.
Nach Willke muss ein System zuerst beobachtet werden, bevor es beeinflusst und verändert
und damit gesteuert werden kann.
Dieser Steuerung des Systems stellt sich aber die entwickelte Eigenidentität der Teams in den
Weg, welche durch eine Vereinfachung, d.h. Reduktion der Komplexität des Systems, wieder
zerstört werden würde.
Aus systemtheoretischer Perspektive heisst dies für Manager und IT-Projektleiter, dass es sich
bei Personen und Teams um nichttriviale Systeme handelt, die nicht einfach von aussen
umgepolt, verändert oder umstrukturiert werden können, es sei denn, um den Preis Ihrer
Identität und Autonomie. Das System kann sich nur selbst ändern, der Intervenierende kann
die Veränderung höchstens anstossen.
3.3.2. Visionäre Führungsmodelle
Eine vorhandene Vision ist ein gutes Mittel ist, Teammitglieder zu motivieren, zu überzeugen
und zu Höchstleistungen anzuspornen. Der Leader ist Vorbild, indem er zwar authentisch
vorlebt was er predigt, aber auch Verantwortung abgeben kann.
Hendriks/Ludemann [Hend97] stellen die Vision ins Zentrum und entwickeln ein "Visionäres
Management". Im Sinne eines ganzheitlichen Managers sollten Führungskräfte folgende
Eigenschaften besitzen:
• Absolute Ehrlichkeit
• Fairness
• Selbsterkenntnis
• Beitrag, der zählt
• Undogmatische Spiritualität
• Weniger tun, mehr erreichen
• Das Beste aus sich und anderen herausholen
• Aufgeschlossenheit für Veränderungen
• Spezieller Humor
• Selbstdisziplin
• Gleichgewicht
• Integrität
93

CMS für die MIO-Lernumgebung Anhang B
Collins/Porras [CoPo97] stellen aufgrund ihrer Untersuchung von zeitlosen und
moderesistenten Managementprinzipien den Grundsatz auf:
Core ideology = core values + purpose
Core values = a small set of general
guiding principles, not to be confused
with specific cultural or operating
practices, not to be compromised for
financial gain or short term expediency.
94
Purpose = the organization’s
fundamental reasons for existence
beyond just making money
Dieser Grundsatz kann auf ein zeitlich begrenztes Projektteam übertragen werden. Eine
Ideologie und damit auch Sinn und Zweck eines Projektteams sollte demnach einerseits auf
grundlegenden Werten der Organisation (oder falls nicht vorhanden vom Team selbst
entwickelt), andererseits auf einem übergeordneten Zweck basieren. Die Studie zeigt, dass
eine Unternehmung mit - auf Werten basierender und gelebter - Vision durchwegs erfolgreich
ist.
Eine gemeinsam entwickelte und gelebte Vision, mit welcher sich das ganze Team
identifiziert, bildet eine gemeinsame Basis und ist somit in einem IT-Projekt äusserst
hilfreich, das übergeordnete Ziel des Projekts nicht aus den Augen zu verlieren.
3.3.3. Menschenorientierte Führung
Führungsmodelle konzentrieren sich nach Steiger auf die kommunikativen Aspekte der
Führung [Stei99]. Im Zentrum steht immer der Mensch.
Maxwell beleuchtet den Unterschied zwischen den Idealvorstellungen eines Projektverlaufs
und der Realität: „Leadership, everything rises and falls on leadership“. Eigenschaften wie
Mut, Charakter, Charisma, Kompetenz oder Grosszügigkeit sprechen seiner Meinung nach für
eine starke Führungspersönlichkeit [Maxw99].
3.3.4. Kommunikation und Kooperation im Projekt
Hamsel misst der Kommunikation und Kooperation für den Projekterfolg grosse Bedeutung
bei. Soziale Kompetenz spielt neben fachlichen Qualifikationen eine wesentliche Rolle.
Kürzeres time-to-market und die Verkürzung der Entwicklungszeiten führen zu noch
grösserem Zeitdruck. Deshalb müssen die Grenzen des Machbaren klar kommuniziert
werden.

CMS für die MIO-Lernumgebung Anhang B
3.3.5. Vertrauen
Für Fredmund Malik bildet das Vertrauen die Grundlage der Organisation. Fehlt es, bleiben
alle Massnahmen zur Förderung der Motivation und zur Verbesserung des Betriebsklimas und
der Unternehmenskultur wirkungslos [Baz02].
3.3.6. Situatives Führungsverhalten
Führungsverhalten soll nach Jenny entsprechend der Situation bestimmt werden. Diese wird
von den vier Elementen „Aufgabe“, „Führungsperson“, „Mitarbeiter“ und „Situation“
beeinflusst.
Abb. 34: Einflüsse auf das Führungsverhalten [Hald02]
4. Führungskonzept im MIO-Ansatz
4.1. Metaphern
Die Verwendung von Metaphern fördert oft die Kreativität [RhPo72]. Da durch sie Dinge
anders wahrgenommen werden, bieten Metaphern Chancen für neue Ideen und Lösungen.
Im Folgenden werden vier Metaphern von verschiedenen Führungsverhalten vorgestellt.
Diese basieren auf dem MIO-Ansatz (Institut für Informatik, Universität Zürich) der IT-
Projekte als soziale Systeme betrachtet [Hube00].
95

CMS für die MIO-Lernumgebung Anhang B
Der Meister
Der Meister führt seine Lehrlinge und Gesellen in einem innovativen und langsamen Prozess
in sein Metier ein. Der Meister gestaltet aus sich selbst heraus. Er erwirbt seinen Meister in
langen Jahren als Lehrling und Geselle. Als Ausweis dient ihm die Meisterprüfung. Er ist ein
Vorbild, aber sein sozialer Einfluss weist eine beschränkte Reichweite auf.
Der Feldherr
Der Feldherr schickt seine Heerscharen in den Kampf. Er entscheidet einsam. Sein Überblick
verschafft dem Feldherrn ein Informationsmonopol. Er dirigiert das Geschehen aufgrund
seines überlegenen Wissens und Informationsvorsprungs. Er verkörpert den Auftrag seines
Vorgesetzten, sein Commitment geht bis in den Tod. Sein sozialer Einfluss ist in seiner
Funktion begründet.
Der Raumschiff-Kapitän
Der Raumschiff-Kapitän pflegt einen partizipativen Führungsstil. Er nutzt und fördert die
Innovationskraft seines Teams. Der Kapitän koordiniert sein Team. Jedes Teammitglied
verfügt über eigene Kompetenzen und ein eingeschränktes Vetorecht. Der Raumschiff-
Kapitän ist deshalb in gewisser Weise von seinem Team abhängig. Bei strittigen Fragen
entscheidet er. Er besitzt wenig fachliches Wissen. Die Loyalität seiner Mitarbeiter bestimmt
seinen Einfluss.
Der Gärtner
Der Gärtner führt als oberster Diener, indem er seinem Team optimale Bedingungen schafft
und auf das spontane Entstehen von Innovation vertraut. Der Gärtner verfährt nach dem
Motto „Eine gute Vorbereitung ist die halbe Arbeit“ und bereitet seinen Pflanzen optimale
Rahmenbedingungen. Er schützt sein Projekt vor negativen äusseren Einflüssen, positive
Einflüsse verstärkt er. Er interveniert bei Schwierigkeiten und Problemen, ansonsten lässt er
den Dingen freien Lauf. Er kontrolliert den Fortschritt und bestimmt den Zeitpunkt der Ernte.
Seine Autorität fusst auf einer heiklen Balance von Vertrauen und Distanz gegenüber seinem
Team.
4.2. Projektphasen
Das systemische Projektmanagement [HuKu03] schlägt vier Phasen zur Abwicklung eines IT-
Projekts vor, in welchem es neben der fachlichen Ebene um das Zusammenspiel von Personen
in einem neu zu gründenden sozialen System auf Zeit geht.
Im systemischen Projektmanagement werden in den Phasen Projektetablierung und
Projektkonstituierung Interessenkonflikte frühzeitig transparent gemacht, was zu einer
Zeiteinsparung in der Durchführungsphase führen soll.
96

CMS für die MIO-Lernumgebung Anhang B
Projektetablierung
In der Etablierungsphase wird das soziale System gegründet. Oberste Aufgabe der
Etablierung ist die Kontextanalyse, d.h. das Aufzeigen der relevanten Umwelt des Projekts
mit dem Einbezug von Sponsor, Auftraggeber und anderen bedeutenden Stakeholdern.
Mögliche Methoden können eine Projektumfeld-Analyse, die Analyse potentieller Probleme,
systemische Interviews oder Teamdesign sein.
Projektkonstituierung
In der Konstituierungsphase werden die Projektgrenze, der Projektkontext und das
Projektteam konstituiert. Bei der Bildung des Projektteams wird auf eventuell mitgebrachte
Altlasten, Regeln der Zusammenarbeit, Rollenklärung und Commitment fokussiert. Als
Methode bietet sich das bekannte Kick-Off-Meeting an, das insbesondere der Teambildung
und Auftragklärung dient.
Projektdurchführung
In der Durchführungsphase wird der Projektauftrag realisiert. Aus systemischer Perspektive
ist hier mit Störungen, Änderungen und Unvorhergesehenem adäquat und konstruktiv
umzugehen. Wichtig sind hierbei das Management der Projektgrenze, das Monitoring
schwacher Signale und, falls notwendig, die Intervention. Es lassen sich neun Funktionen auf
den drei Systemebenen unterscheiden:
Systemkontext Systemgrenze Systeminnenwelt
Sensibilisieren
Analysieren
Mediieren
Tab. 22: Systemebenen [Hald02]
Projektabschluss
Repräsentieren
Integrieren
Informieren
97
Kooperieren
Kommunizieren
Moderieren
Ziel der Auflösung ist die Evaluation der Projektarbeit. Die Abschlussphase wird in der Praxis
selten sauber durchgeführt. Doch gerade diese Phase bietet für alle Beteiligten die Chance,
den Umgang mit Unvorhergesehenem, dynamischen und chaotischen Prozessen,
Zielveränderungen, Zeit- und Budgetüberschreitungen und Konflikten zu lernen.
4.3. Situativer Einsatz von Metaphern
Situatives Führungsverhalten ist in IT-Projekten typischerweise in den einzelnen
Projektphasen gefragt.

CMS für die MIO-Lernumgebung Anhang B
Folgende Tabelle soll Aufschluss über die Verwendung der vorgestellten Metaphern in den
einzelnen Projektphasen geben:
Meister Feldherr Kapitän Gärtner
Etablierung - + ++ ++
Konstituierung - +/- ++ +
Durchführung +/- -- + +
Auflösung - - + ++
Tab. 23: Situativer Einsatz von Metaphern [Hald02]
5. Literaturverzeichnis
[Baz02] Basler Zeitung vom 24. Juni 2002
[CoPo97] James C. Collins, Jerry I. Porras: Bulit to Last – successful habits of visionary
companies, New York, 1997
[DuBa5] Duden Band 5
[Hend97] Gay Hendricks, Kate Ludeman: Visionäres Management als Führungskonzept der
Zukunft, Delphi Verlag München 1997
[Hint97] Hans Hinterhuber, Eric Krauthammer: Leadership – mehr als Management,
Wiesbaden 1997
[Hube00] Andreas Huber: IT-Projekte und HR-Management, Konferenz moderne
Informationstechnologie im HR-Management, 12.9.2000, Rüschlikon
[HuKu03] Andreas Huber, Beathe Kuhnt: Führung und Management komplexer IT-Projekte,
Zürich 2003 (geplant)
[Maxw99] John C. Maxwell: The 21 irrefutable qualities of a leader, Nashville 1999
[Neis] Wilhelm Neis, Komplexitätstheorie und Komplexität im Management,
Diplomarbeit FH Köln
http://www.gm.fh-koeln.de/~bundschu/dokumente/komplex.doc
[RhPo72] Rheinische Post vom 17. Juni 1972
[Steig99] Rudolf Steiger, Menschenorientierte Führung – Anregungen für zivile und
militärische Führungskräfte, Frauenfeld 1999, 11. Auflage
[UlPr91] Hans Ulrich und Gilbert J.B. Probst, Anleitung zum ganzheitlichen Denken und
Handeln: ein Brevier für Führungskräfte, Bern/Stuttgart, 1991, 3. Auflage
[Will00] Helmut Willke, Systemtheorie 1: Grundlagen, Stuttgart 2000, 6. Auflage
[Will99] Helmut Willke, Systemtheorie 2: Interventionstheorie, Stuttgart 1999, 3. Auflage
98

CMS für die MIO-Lernumgebung Anhang C
Anhang C: eingerichtete Umgebung
1. Microsoft Windows 2000
2. Apache Webserver Version 1.3.26-win32-src
Folgend ist die an die Umgebung angepasste Konfigurationsdatei „httpd.conf“ abgedruckt:
2.1. httpd.conf
#
# Based upon the NCSA server configuration files originally by Rob McCool.
#
# This is the main Apache server configuration file. It contains the
# configuration directives that give the server its instructions.
# See for detailed information about
# the directives.
#
# Do NOT simply read the instructions in here without understanding
# what they do. They're here only as hints or reminders. If you are unsure
# consult the online docs. You have been warned.
#
# After this file is processed, the server will look for and process
# C:/Programme/Apache Group/Apache/conf/srm.conf and then C:/Programme/Apache Group/Apache/conf/access.conf
# unless you have overridden these with ResourceConfig and/or
# AccessConfig directives here.
#
# The configuration directives are grouped into three basic sections:
# 1. Directives that control the operation of the Apache server process as a
# whole (the 'global environment').
# 2. Directives that define the parameters of the 'main' or 'default' server,
# which responds to requests that aren't handled by a virtual host.
# These directives also provide default values for the settings
# of all virtual hosts.
# 3. Settings for virtual hosts, which allow Web requests to be sent to
# different IP addresses or hostnames and have them handled by the
# same Apache server process.
#
# Configuration and logfile names: If the filenames you specify for many
# of the server's control files begin with "/" (or "drive:/" for Win32), the
# server will use that explicit path. If the filenames do *not* begin
# with "/", the value of ServerRoot is prepended -- so "logs/foo.log"
# with ServerRoot set to "/usr/local/apache" will be interpreted by the
# server as "/usr/local/apache/logs/foo.log".
#
# NOTE: Where filenames are specified, you must use forward slashes
# instead of backslashes (e.g., "c:/apache" instead of "c:\apache").
# If a drive letter is omitted, the drive on which Apache.exe is located
# will be used by default. It is recommended that you always supply
# an explicit drive letter in absolute paths, however, to avoid
# confusion.
#
### Section 1: Global Environment
#
# The directives in this section affect the overall operation of Apache,
# such as the number of concurrent requests it can handle or where it
# can find its configuration files.
#
#
# ServerType is either inetd, or standalone. Inetd mode is only supported on
# Unix platforms.
#
ServerType standalone
#
# ServerRoot: The top of the directory tree under which the server's
# configuration, error, and log files are kept.
#
ServerRoot "C:/Programme/Apache Group/Apache"
#
# PidFile: The file in which the server should record its process
# identification number when it starts.
#
PidFile logs/httpd.pid
#
# ScoreBoardFile: File used to store internal server process information.
# Not all architectures require this. But if yours does (you'll know because
# this file will be created when you run Apache) then you *must* ensure that
# no two invocations of Apache share the same scoreboard file.
#
ScoreBoardFile logs/apache_runtime_status
#
# In the standard configuration, the server will process httpd.conf (this
# file, specified by the -f command line option), srm.conf, and access.conf
# in that order. The latter two files are now distributed empty, as it is
99

CMS für die MIO-Lernumgebung Anhang C
# recommended that all directives be kept in a single file for simplicity.
# The commented-out values below are the built-in defaults. You can have the
# server ignore these files altogether by using "/dev/null" (for Unix) or
# "nul" (for Win32) for the arguments to the directives.
#
#ResourceConfig conf/srm.conf
#AccessConfig conf/access.conf
#
# Timeout: The number of seconds before receives and sends time out.
#
Timeout 300
#
# KeepAlive: Whether or not to allow persistent connections (more than
# one request per connection). Set to "Off" to deactivate.
#
KeepAlive On
#
# MaxKeepAliveRequests: The maximum number of requests to allow
# during a persistent connection. Set to 0 to allow an unlimited amount.
# We recommend you leave this number high, for maximum performance.
#
MaxKeepAliveRequests 100
#
# KeepAliveTimeout: Number of seconds to wait for the next request from the
# same client on the same connection.
#
KeepAliveTimeout 15
#
# Apache on Win32 always creates one child process to handle requests. If it
# dies, another child process is created automatically. Within the child
# process multiple threads handle incoming requests. The next two
# directives control the behaviour of the threads and processes.
#
#
# MaxRequestsPerChild: the number of requests each child process is
# allowed to process before the child dies. The child will exit so
# as to avoid problems after prolonged use when Apache (and maybe the
# libraries it uses) leak memory or other resources. On most systems, this
# isn't really needed, but a few (such as Solaris) do have notable leaks
# in the libraries. For Win32, set this value to zero (unlimited)
# unless advised otherwise.
#
# NOTE: This value does not include keepalive requests after the initial
# request per connection. For example, if a child process handles
# an initial request and 10 subsequent "keptalive" requests, it
# would only count as 1 request towards this limit.
#
MaxRequestsPerChild 0
#
# Number of concurrent threads (i.e., requests) the server will allow.
# Set this value according to the responsiveness of the server (more
# requests active at once means they're all handled more slowly) and
# the amount of system resources you'll allow the server to consume.
#
ThreadsPerChild 50
#
# Listen: Allows you to bind Apache to specific IP addresses and/or
# ports, in addition to the default. See also the
# directive.
#
#Listen 3000
#Listen 12.34.56.78:80
#
# BindAddress: You can support virtual hosts with this option. This directive
# is used to tell the server which IP address to listen to. It can either
# contain "*", an IP address, or a fully qualified Internet domain name.
# See also the and Listen directives.
#
#BindAddress *
#
# Dynamic Shared Object (DSO) Support
#
# To be able to use the functionality of a module which was built as a DSO you
# have to place corresponding `LoadModule' lines at this location so the
# directives contained in it are actually available _before_ they are used.
# Please read the file README.DSO in the Apache 1.3 distribution for more
# details about the DSO mechanism and run `apache -l' for the list of already
# built-in (statically linked and thus always available) modules in your Apache
# binary.
#
# Note: The order in which modules are loaded is important. Don't change
# the order below without expert advice.
#
# Example:
# LoadModule foo_module modules/mod_foo.so
#
#LoadModule vhost_alias_module modules/mod_vhost_alias.so
#LoadModule mime_magic_module modules/mod_mime_magic.so
#LoadModule status_module modules/mod_status.so
#LoadModule info_module modules/mod_info.so
#LoadModule speling_module modules/mod_speling.so
#LoadModule rewrite_module modules/mod_rewrite.so
#LoadModule anon_auth_module modules/mod_auth_anon.so
#LoadModule dbm_auth_module modules/mod_auth_dbm.so
#LoadModule digest_auth_module modules/mod_auth_digest.so
100

CMS für die MIO-Lernumgebung Anhang C
#LoadModule digest_module modules/mod_digest.so
#LoadModule proxy_module modules/mod_proxy.so
#LoadModule cern_meta_module modules/mod_cern_meta.so
#LoadModule expires_module modules/mod_expires.so
#LoadModule headers_module modules/mod_headers.so
#LoadModule usertrack_module modules/mod_usertrack.so
#LoadModule unique_id_module modules/mod_unique_id.so
LoadModule php4_module modules/php4apache.dll
#
# Reconstruction of the complete module list from all available modules
# (static and shared ones) to achieve correct module execution order.
#
# The modules listed below, without a corresponding LoadModule directive,
# are static bound into the standard Apache binary distribution for Windows.
#
# Note: The order in which modules are loaded is important. Don't change
# the order below without expert advice.
#
# [WHENEVER YOU CHANGE THE LOADMODULE SECTION ABOVE, UPDATE THIS TOO!]
#ClearModuleList
#AddModule mod_vhost_alias.c
#AddModule mod_env.c
#AddModule mod_log_config.c
#AddModule mod_mime_magic.c
#AddModule mod_mime.c
#AddModule mod_negotiation.c
#AddModule mod_status.c
#AddModule mod_info.c
#AddModule mod_include.c
#AddModule mod_autoindex.c
#AddModule mod_dir.c
#AddModule mod_isapi.c
#AddModule mod_cgi.c
#AddModule mod_asis.c
#AddModule mod_imap.c
#AddModule mod_actions.c
#AddModule mod_speling.c
#AddModule mod_userdir.c
#AddModule mod_alias.c
#AddModule mod_rewrite.c
#AddModule mod_access.c
#AddModule mod_auth.c
#AddModule mod_auth_anon.c
#AddModule mod_auth_dbm.c
#AddModule mod_auth_digest.c
#AddModule mod_digest.c
#AddModule mod_proxy.c
#AddModule mod_cern_meta.c
#AddModule mod_expires.c
#AddModule mod_headers.c
#AddModule mod_usertrack.c
#AddModule mod_unique_id.c
#AddModule mod_so.c
#AddModule mod_setenvif.c
#
# ExtendedStatus controls whether Apache will generate "full" status
# information (ExtendedStatus On) or just basic information (ExtendedStatus
# Off) when the "server-status" handler is called. The default is Off.
#
#ExtendedStatus On
### Section 2: 'Main' server configuration
#
# The directives in this section set up the values used by the 'main'
# server, which responds to any requests that aren't handled by a
# definition. These values also provide defaults for
# any containers you may define later in the file.
#
# All of these directives may appear inside containers,
# in which case these default settings will be overridden for the
# virtual host being defined.
#
#
# Port: The port to which the standalone server listens. Certain firewall
# products must be configured before Apache can listen to a specific port.
# Other running httpd servers will also interfere with this port. Disable
# all firewall, security, and other services if you encounter problems.
# To help diagnose problems use the Windows NT command NETSTAT -a
#
Port 80
#
# ServerAdmin: Your address, where problems with the server should be
# e-mailed. This address appears on some server-generated pages, such
# as error documents.
#
ServerAdmin mail@domain
#
# ServerName allows you to set a host name which is sent back to clients for
# your server if it's different than the one the program would get (i.e., use
# "www" instead of the host's real name).
#
# Note: You cannot just invent host names and hope they work. The name you
# define here must be a valid DNS name for your host. If you don't understand
# this, ask your network administrator.
# If your host doesn't have a registered DNS name, enter its IP address here.
# You will have to access it by its address (e.g., http://123.45.67.89/)
# anyway, and this will make redirections work in a sensible way.
#
# 127.0.0.1 is the TCP/IP local loop-back address, often named localhost. Your
# machine always knows itself by this address. If you use Apache strictly for
101

CMS für die MIO-Lernumgebung Anhang C
# local testing and development, you may use 127.0.0.1 as the server name.
#
ServerName 127.0.0.1
#
# DocumentRoot: The directory out of which you will serve your
# documents. By default, all requests are taken from this directory, but
# symbolic links and aliases may be used to point to other locations.
#
DocumentRoot "C:/Programme/Apache Group/Apache/htdocs"
#
# Each directory to which Apache has access, can be configured with respect
# to which services and features are allowed and/or disabled in that
# directory (and its subdirectories).
#
# First, we configure the "default" to be a very restrictive set of
# permissions.
#
Options FollowSymLinks
AllowOverride None
#
# Note that from this point forward you must specifically allow
# particular features to be enabled - so if something's not working as
# you might expect, make sure that you have specifically enabled it
# below.
#
#
# This should be changed to whatever you set DocumentRoot to.
#
#
# This may also be "None", "All", or any combination of "Indexes",
# "Includes", "FollowSymLinks", "ExecCGI", or "MultiViews".
#
# Note that "MultiViews" must be named *explicitly* --- "Options All"
# doesn't give it to you.
#
Options Indexes FollowSymLinks MultiViews
#
# This controls which options the .htaccess files in directories can
# override. Can also be "All", or any combination of "Options", "FileInfo",
# "AuthConfig", and "Limit"
#
AllowOverride None
#
# Controls who can get stuff from this server.
#
Order allow,deny
Allow from all
#
# UserDir: The name of the directory which is appended onto a user's home
# directory if a ~user request is received.
#
# Under Win32, we do not currently try to determine the home directory of
# a Windows login, so a format such as that below needs to be used. See
# the UserDir documentation for details.
#
UserDir "C:/Programme/Apache Group/Apache/users/"
#
# Control access to UserDir directories. The following is an example
# for a site where these directories are restricted to read-only.
#
#
# AllowOverride FileInfo AuthConfig Limit
# Options MultiViews Indexes SymLinksIfOwnerMatch IncludesNoExec
#
# Order allow,deny
# Allow from all
#
#
# Order deny,allow
# Deny from all
#
#
#
# DirectoryIndex: Name of the file or files to use as a pre-written HTML
# directory index. Separate multiple entries with spaces.
#
DirectoryIndex index.html index.htm index.php index.php3 index.php4 index.phtml
#
# AccessFileName: The name of the file to look for in each directory
# for access control information.
#
AccessFileName .htaccess
#
# The following lines prevent .htaccess files from being viewed by
102

CMS für die MIO-Lernumgebung Anhang C
# Web clients. Since .htaccess files often contain authorization
# information, access is disallowed for security reasons. Comment
# these lines out if you want Web visitors to see the contents of
# .htaccess files. If you change the AccessFileName directive above,
# be sure to make the corresponding changes here.
#
# Also, folks tend to use names such as .htpasswd for password
# files, so this will protect those as well.
#
Order allow,deny
Deny from all
Satisfy All
#
# CacheNegotiatedDocs: By default, Apache sends "Pragma: no-cache" with each
# document that was negotiated on the basis of content. This asks proxy
# servers not to cache the document. Uncommenting the following line disables
# this behavior, and proxies will be allowed to cache the documents.
#
#CacheNegotiatedDocs
#
# UseCanonicalName: (new for 1.3) With this setting turned on, whenever
# Apache needs to construct a self-referencing URL (a URL that refers back
# to the server the response is coming from) it will use ServerName and
# Port to form a "canonical" name. With this setting off, Apache will
# use the hostname:port that the client supplied, when possible. This
# also affects SERVER_NAME and SERVER_PORT in CGI scripts.
#
UseCanonicalName On
#
# TypesConfig describes where the mime.types file (or equivalent) is
# to be found.
#
TypesConfig conf/mime.types
#
# DefaultType is the default MIME type the server will use for a document
# if it cannot otherwise determine one, such as from filename extensions.
# If your server contains mostly text or HTML documents, "text/plain" is
# a good value. If most of your content is binary, such as applications
# or images, you may want to use "application/octet-stream" instead to
# keep browsers from trying to display binary files as though they are
# text.
#
DefaultType text/plain
#
# The mod_mime_magic module allows the server to use various hints from the
# contents of the file itself to determine its type. The MIMEMagicFile
# directive tells the module where the hint definitions are located.
# mod_mime_magic is not part of the default server (you have to add
# it yourself with a LoadModule [see the DSO paragraph in the 'Global
# Environment' section], or recompile the server and include mod_mime_magic
# as part of the configuration), so it's enclosed in an container.
# This means that the MIMEMagicFile directive will only be processed if the
# module is part of the server.
#
MIMEMagicFile conf/magic
#
# HostnameLookups: Log the names of clients or just their IP addresses
# e.g., www.apache.org (on) or 204.62.129.132 (off).
# The default is off because it'd be overall better for the net if people
# had to knowingly turn this feature on, since enabling it means that
# each client request will result in AT LEAST one lookup request to the
# nameserver.
#
HostnameLookups Off
#
# ErrorLog: The location of the error log file.
# If you do not specify an ErrorLog directive within a
# container, error messages relating to that virtual host will be
# logged here. If you *do* define an error logfile for a
# container, that host's errors will be logged there and not here.
#
ErrorLog logs/error.log
#
# LogLevel: Control the number of messages logged to the error.log.
# Possible values include: debug, info, notice, warn, error, crit,
# alert, emerg.
#
LogLevel warn
#
# The following directives define some format nicknames for use with
# a CustomLog directive (see below).
#
LogFormat "%h %l %u %t \"%r\" %>s %b \"%{Referer}i\" \"%{User-Agent}i\"" combined
LogFormat "%h %l %u %t \"%r\" %>s %b" common
LogFormat "%{Referer}i -> %U" referer
LogFormat "%{User-agent}i" agent
#
# The location and format of the access logfile (Common Logfile Format).
# If you do not define any access logfiles within a
103

CMS für die MIO-Lernumgebung Anhang C
# container, they will be logged here. Contrariwise, if you *do*
# define per- access logfiles, transactions will be
# logged therein and *not* in this file.
#
CustomLog logs/access.log common
#
# If you would like to have agent and referer logfiles, uncomment the
# following directives.
#
#CustomLog logs/referer.log referer
#CustomLog logs/agent.log agent
#
# If you prefer a single logfile with access, agent, and referer information
# (Combined Logfile Format) you can use the following directive.
#
#CustomLog logs/access.log combined
#
# Optionally add a line containing the server version and virtual host
# name to server-generated pages (error documents, FTP directory listings,
# mod_status and mod_info output etc., but not CGI generated documents).
# Set to "EMail" to also include a mailto: link to the ServerAdmin.
# Set to one of: On | Off | EMail
#
ServerSignature On
#
# Apache parses all CGI scripts for the shebang line by default.
# This comment line, the first line of the script, consists of the symbols
# pound (#) and exclamation (!) followed by the path of the program that
# can execute this specific script. For a perl script, with perl.exe in
# the C:\Program Files\Perl directory, the shebang line should be:
#!c:/program files/perl/perl
# Note you _must_not_ indent the actual shebang line, and it must be the
# first line of the file. Of course, CGI processing must be enabled by
# the appropriate ScriptAlias or Options ExecCGI directives for the files
# or directory in question.
#
# However, Apache on Windows allows either the Unix behavior above, or can
# use the Registry to match files by extention. The command to execute
# a file of this type is retrieved from the registry by the same method as
# the Windows Explorer would use to handle double-clicking on a file.
# These script actions can be configured from the Windows Explorer View menu,
# 'Folder Options', and reviewing the 'File Types' tab. Clicking the Edit
# button allows you to modify the Actions, of which Apache 1.3 attempts to
# perform the 'Open' Action, and failing that it will try the shebang line.
# This behavior is subject to change in Apache release 2.0.
#
# Each mechanism has it's own specific security weaknesses, from the means
# to run a program you didn't intend the website owner to invoke, and the
# best method is a matter of great debate.
#
# To enable the this Windows specific behavior (and therefore -disable- the
# equivilant Unix behavior), uncomment the following directive:
#
#ScriptInterpreterSource registry
#
# The directive above can be placed in individual blocks or the
# .htaccess file, with either the 'registry' (Windows behavior) or 'script'
# (Unix behavior) option, and will override this server default option.
#
#
# Aliases: Add here as many aliases as you need (with no limit). The format is
# Alias fakename realname
#
#
# Note that if you include a trailing / on fakename then the server will
# require it to be present in the URL. So "/icons" isn't aliased in this
# example, only "/icons/". If the fakename is slash-terminated, then the
# realname must also be slash terminated, and if the fakename omits the
# trailing slash, the realname must also omit it.
#
Alias /icons/ "C:/Programme/Apache Group/Apache/icons/"
Options Indexes MultiViews
AllowOverride None
Order allow,deny
Allow from all
# This Alias will project the on-line documentation tree under /manual/
# even if you change the DocumentRoot. Comment it if you don't want to
# provide access to the on-line documentation.
#
Alias /manual/ "C:/Programme/Apache Group/Apache/htdocs/manual/"
Options Indexes FollowSymlinks MultiViews
AllowOverride None
Order allow,deny
Allow from all
#
# ScriptAlias: This controls which directories contain server scripts.
# ScriptAliases are essentially the same as Aliases, except that
# documents in the realname directory are treated as applications and
104

CMS für die MIO-Lernumgebung Anhang C
# run by the server when requested rather than as documents sent to the client.
# The same rules about trailing "/" apply to ScriptAlias directives as to
# Alias.
#
ScriptAlias /cgi-bin/ "C:/Programme/Apache Group/Apache/cgi-bin/"
#
# "C:/Programme/Apache Group/Apache/cgi-bin" should be changed to whatever your ScriptAliased
# CGI directory exists, if you have that configured.
#
AllowOverride None
Options None
Order allow,deny
Allow from all
# End of aliases.
#
# Redirect allows you to tell clients about documents which used to exist in
# your server's namespace, but do not anymore. This allows you to tell the
# clients where to look for the relocated document.
# Format: Redirect old-URI new-URL
#
#
# Directives controlling the display of server-generated directory listings.
#
#
# FancyIndexing is whether you want fancy directory indexing or standard
#
# Note, add the option TrackModified to the IndexOptions default list only
# if all indexed directories reside on NTFS volumes. The TrackModified flag
# will report the Last-Modified date to assist caches and proxies to properly
# track directory changes, but it does _not_ work on FAT volumes.
#
IndexOptions FancyIndexing
#
# AddIcon* directives tell the server which icon to show for different
# files or filename extensions. These are only displayed for
# FancyIndexed directories.
#
AddIconByEncoding (CMP,/icons/compressed.gif) x-compress x-gzip
AddIconByType (TXT,/icons/text.gif) text/*
AddIconByType (IMG,/icons/image2.gif) image/*
AddIconByType (SND,/icons/sound2.gif) audio/*
AddIconByType (VID,/icons/movie.gif) video/*
AddIcon /icons/binary.gif .bin .exe
AddIcon /icons/binhex.gif .hqx
AddIcon /icons/tar.gif .tar
AddIcon /icons/world2.gif .wrl .wrl.gz .vrml .vrm .iv
AddIcon /icons/compressed.gif .Z .z .tgz .gz .zip
AddIcon /icons/a.gif .ps .ai .eps
AddIcon /icons/layout.gif .html .shtml .htm .pdf
AddIcon /icons/text.gif .txt
AddIcon /icons/c.gif .c
AddIcon /icons/p.gif .pl .py
AddIcon /icons/f.gif .for
AddIcon /icons/dvi.gif .dvi
AddIcon /icons/uuencoded.gif .uu
AddIcon /icons/script.gif .conf .sh .shar .csh .ksh .tcl
AddIcon /icons/tex.gif .tex
AddIcon /icons/bomb.gif core
AddIcon /icons/back.gif ..
AddIcon /icons/hand.right.gif README
AddIcon /icons/folder.gif ^^DIRECTORY^^
AddIcon /icons/blank.gif ^^BLANKICON^^
#
# DefaultIcon is which icon to show for files which do not have an icon
# explicitly set.
#
DefaultIcon /icons/unknown.gif
#
# AddDescription allows you to place a short description after a file in
# server-generated indexes. These are only displayed for FancyIndexed
# directories.
# Format: AddDescription "description" filename
#
#AddDescription "GZIP compressed document" .gz
#AddDescription "tar archive" .tar
#AddDescription "GZIP compressed tar archive" .tgz
#
# ReadmeName is the name of the README file the server will look for by
# default, and append to directory listings.
#
# HeaderName is the name of a file which should be prepended to
# directory indexes.
#
# If MultiViews are amongst the Options in effect, the server will
# first look for name.html and include it if found. If name.html
# doesn't exist, the server will then look for name.txt and include
# it as plaintext if found.
#
ReadmeName README
105

CMS für die MIO-Lernumgebung Anhang C
HeaderName HEADER
#
# IndexIgnore is a set of filenames which directory indexing should ignore
# and not include in the listing. Shell-style wildcarding is permitted.
#
IndexIgnore .??* *~ *# HEADER* README* RCS CVS *,v *,t
# End of indexing directives.
#
# Document types.
#
#
# AddEncoding allows you to have certain browsers (Mosaic/X 2.1+) uncompress
# information on the fly. Note: Not all browsers support this.
# Despite the name similarity, the following Add* directives have nothing
# to do with the FancyIndexing customization directives above.
#
AddEncoding x-compress Z
AddEncoding x-gzip gz tgz
#
# AddLanguage allows you to specify the language of a document. You can
# then use content negotiation to give a browser a file in a language
# it can understand.
#
# Note 1: The suffix does not have to be the same as the language
# keyword --- those with documents in Polish (whose net-standard
# language code is pl) may wish to use "AddLanguage pl .po" to
# avoid the ambiguity with the common suffix for perl scripts.
#
# Note 2: The example entries below illustrate that in quite
# some cases the two character 'Language' abbreviation is not
# identical to the two character 'Country' code for its country,
# E.g. 'Danmark/dk' versus 'Danish/da'.
#
# Note 3: In the case of 'ltz' we violate the RFC by using a three char
# specifier. But there is 'work in progress' to fix this and get
# the reference data for rfc1766 cleaned up.
#
# Danish (da) - Dutch (nl) - English (en) - Estonian (ee)
# French (fr) - German (de) - Greek-Modern (el)
# Italian (it) - Korean (kr) - Norwegian (no) - Norwegian Nynorsk (nn)
# Portugese (pt) - Luxembourgeois* (ltz)
# Spanish (es) - Swedish (sv) - Catalan (ca) - Czech(cz)
# Polish (pl) - Brazilian Portuguese (pt-br) - Japanese (ja)
# Russian (ru)
#
AddLanguage da .dk
AddLanguage nl .nl
AddLanguage en .en
AddLanguage et .ee
AddLanguage fr .fr
AddLanguage de .de
AddLanguage el .el
AddLanguage he .he
AddCharset ISO-8859-8 .iso8859-8
AddLanguage it .it
AddLanguage ja .ja
AddCharset ISO-2022-JP .jis
AddLanguage kr .kr
AddCharset ISO-2022-KR .iso-kr
AddLanguage nn .nn
AddLanguage no .no
AddLanguage pl .po
AddCharset ISO-8859-2 .iso-pl
AddLanguage pt .pt
AddLanguage pt-br .pt-br
AddLanguage ltz .lu
AddLanguage ca .ca
AddLanguage es .es
AddLanguage sv .sv
AddLanguage cz .cz
AddLanguage ru .ru
AddLanguage tw .tw
AddLanguage zh-tw .tw
AddCharset Big5 .Big5 .big5
AddCharset WINDOWS-1251 .cp-1251
AddCharset CP866 .cp866
AddCharset ISO-8859-5 .iso-ru
AddCharset KOI8-R .koi8-r
AddCharset UCS-2 .ucs2
AddCharset UCS-4 .ucs4
AddCharset UTF-8 .utf8
# LanguagePriority allows you to give precedence to some languages
# in case of a tie during content negotiation.
#
# Just list the languages in decreasing order of preference. We have
# more or less alphabetized them here. You probably want to change this.
#
LanguagePriority en da nl et fr de el it ja kr no pl pt pt-br ru ltz ca es sv tw
#
# AddType allows you to tweak mime.types without actually editing it, or to
# make certain files to be certain types.
#
AddType application/x-tar .tgz
AddType application/x-httpd-php .php
AddType application/x-httpd-php-source .phps
106

CMS für die MIO-Lernumgebung Anhang C
#
# AddHandler allows you to map certain file extensions to "handlers",
# actions unrelated to filetype. These can be either built into the server
# or added with the Action command (see below)
#
# If you want to use server side includes, or CGI outside
# ScriptAliased directories, uncomment the following lines.
#
# To use CGI scripts:
#
#AddHandler cgi-script .cgi
#
# To use server-parsed HTML files
#
#AddType text/html .shtml
#AddHandler server-parsed .shtml
#
# Uncomment the following line to enable Apache's send-asis HTTP file
# feature
#
#AddHandler send-as-is asis
#
# If you wish to use server-parsed imagemap files, use
#
#AddHandler imap-file map
#
# To enable type maps, you might want to use
#
#AddHandler type-map var
# End of document types.
#
# Action lets you define media types that will execute a script whenever
# a matching file is called. This eliminates the need for repeated URL
# pathnames for oft-used CGI file processors.
# Format: Action media/type /cgi-script/location
# Format: Action handler-name /cgi-script/location
#
Action application/x-httpd-php "/cgi-bin/php4.exe"
#
# MetaDir: specifies the name of the directory in which Apache can find
# meta information files. These files contain additional HTTP headers
# to include when sending the document
#
#MetaDir .web
#
# MetaSuffix: specifies the file name suffix for the file containing the
# meta information.
#
#MetaSuffix .meta
#
# Customizable error response (Apache style)
# these come in three flavors
#
# 1) plain text
#ErrorDocument 500 "The server made a boo boo.
# n.b. the single leading (") marks it as text, it does not get output
#
# 2) local redirects
#ErrorDocument 404 /missing.html
# to redirect to local URL /missing.html
#ErrorDocument 404 /cgi-bin/missing_handler.pl
# N.B.: You can redirect to a script or a document using server-side-includes.
#
# 3) external redirects
#ErrorDocument 402 http://some.other-server.com/subscription_info.html
# N.B.: Many of the environment variables associated with the original
# request will *not* be available to such a script.
#
# Customize behaviour based on the browser
#
#
# The following directives modify normal HTTP response behavior.
# The first directive disables keepalive for Netscape 2.x and browsers that
# spoof it. There are known problems with these browser implementations.
# The second directive is for Microsoft Internet Explorer 4.0b2
# which has a broken HTTP/1.1 implementation and does not properly
# support keepalive when it is used on 301 or 302 (redirect) responses.
#
BrowserMatch "Mozilla/2" nokeepalive
BrowserMatch "MSIE 4\.0b2;" nokeepalive downgrade-1.0 force-response-1.0
#
# The following directive disables HTTP/1.1 responses to browsers which
# are in violation of the HTTP/1.0 spec by not being able to grok a
# basic 1.1 response.
#
BrowserMatch "RealPlayer 4\.0" force-response-1.0
BrowserMatch "Java/1\.0" force-response-1.0
BrowserMatch "JDK/1\.0" force-response-1.0
107

CMS für die MIO-Lernumgebung Anhang C
# End of browser customization directives
#
# Allow server status reports, with the URL of http://servername/server-status
# Change the "somenet.com" to match your domain to enable.
#
#
# SetHandler server-status
# Order deny,allow
# Deny from all
# Allow from somenet.com
#
#
# Allow remote server configuration reports, with the URL of
# http://servername/server-info (requires that mod_info.c be loaded).
# Change the "somenet.com" to match your domain to enable.
#
#
# SetHandler server-info
# Order deny,allow
# Deny from all
# Allow from somenet.com
#
#
# There have been reports of people trying to abuse an old bug from pre-1.1
# days. This bug involved a CGI script distributed as a part of Apache.
# By uncommenting these lines you can redirect these attacks to a logging
# script on phf.apache.org. Or, you can record them yourself, using the script
# support/phf_abuse_log.cgi.
#
#
# Deny from all
# ErrorDocument 403 http://phf.apache.org/phf_abuse_log.cgi
#
#
# Proxy Server directives. Uncomment the following lines to
# enable the proxy server:
#
#
# ProxyRequests On
#
# Order deny,allow
# Deny from all
# Allow from somenet.com
#
#
# Enable/disable the handling of HTTP/1.1 "Via:" headers.
# ("Full" adds the server version; "Block" removes all outgoing Via: headers)
# Set to one of: Off | On | Full | Block
#
# ProxyVia On
#
# To enable the cache as well, edit and uncomment the following lines:
# (no cacheing without CacheRoot)
#
# CacheRoot "C:/Programme/Apache Group/Apache/proxy"
# CacheSize 5
# CacheGcInterval 4
# CacheMaxExpire 24
# CacheLastModifiedFactor 0.1
# CacheDefaultExpire 1
# NoCache a-domain.com another-domain.edu joes.garage-sale.com
#
# End of proxy directives.
### Section 3: Virtual Hosts
#
# VirtualHost: If you want to maintain multiple domains/hostnames on your
# machine you can setup VirtualHost containers for them. Most configurations
# use only name-based virtual hosts so the server doesn't need to worry about
# IP addresses. This is indicated by the asterisks in the directives below.
#
# Please see the documentation at
# for further details before you try to setup virtual hosts.
#
# You may use the command line option '-S' to verify your virtual host
# configuration.
#
# Use name-based virtual hosting.
#
#NameVirtualHost *
#
# VirtualHost example:
# Almost any Apache directive may go into a VirtualHost container.
# The first VirtualHost section is used for requests without a known
# server name.
#
#
# ServerAdmin webmaster@dummy-host.example.com
# DocumentRoot /www/docs/dummy-host.example.com
# ServerName dummy-host.example.com
# ErrorLog logs/dummy-host.example.com-error_log
# CustomLog logs/dummy-host.example.com-access_log common
#
108

CMS für die MIO-Lernumgebung Anhang C
3. MySQL Version 3.23.51-win
4. PHP Version php-4.2.1-Win32
Folgend ist die an die Umgebung angepasste Datei „php.ini“ abgedruckt:
4.1. php.ini
[PHP]
;;;;;;;;;;;
; WARNING ;
;;;;;;;;;;;
; This is the default settings file for new PHP installations.
; By default, PHP installs itself with a configuration suitable for
; development purposes, and *NOT* for production purposes.
; For several security-oriented considerations that should be taken
; before going online with your site, please consult php.ini-recommended
; and http://php.net/manual/en/security.php.
;;;;;;;;;;;;;;;;;;;
; About this file ;
;;;;;;;;;;;;;;;;;;;
; This file controls many aspects of PHP's behavior. In order for PHP to
; read it, it must be named 'php.ini'. PHP looks for it in the current
; working directory, in the path designated by the environment variable
; PHPRC, and in the path that was defined in compile time (in that order).
; Under Windows, the compile-time path is the Windows directory. The
; path in which the php.ini file is looked for can be overridden using
; the -c argument in command line mode.
;
; The syntax of the file is extremely simple. Whitespace and Lines
; beginning with a semicolon are silently ignored (as you probably guessed).
; Section headers (e.g. [Foo]) are also silently ignored, even though
; they might mean something in the future.
;
; Directives are specified using the following syntax:
; directive = value
; Directive names are *case sensitive* - foo=bar is different from FOO=bar.
;
; The value can be a string, a number, a PHP constant (e.g. E_ALL or M_PI), one
; of the INI constants (On, Off, True, False, Yes, No and None) or an expression
; (e.g. E_ALL & ~E_NOTICE), or a quoted string ("foo").
;
; Expressions in the INI file are limited to bitwise operators and parentheses:
; | bitwise OR
; & bitwise AND
; ~ bitwise NOT
; ! boolean NOT
;
; Boolean flags can be turned on using the values 1, On, True or Yes.
; They can be turned off using the values 0, Off, False or No.
;
; An empty string can be denoted by simply not writing anything after the equal
; sign, or by using the None keyword:
;
; foo = ; sets foo to an empty string
; foo = none ; sets foo to an empty string
; foo = "none" ; sets foo to the string 'none'
;
; If you use constants in your value, and these constants belong to a
; dynamically loaded extension (either a PHP extension or a Zend extension),
; you may only use these constants *after* the line that loads the extension.
;
; All the values in the php.ini-dist file correspond to the builtin
; defaults (that is, if no php.ini is used, or if you delete these lines,
; the builtin defaults will be identical).
;;;;;;;;;;;;;;;;;;;;
; Language Options ;
;;;;;;;;;;;;;;;;;;;;
; Enable the PHP scripting language engine under Apache.
engine = On
; Allow the

CMS für die MIO-Lernumgebung Anhang C
; to a certain size - you can use a maximum number of bytes instead of 'On', as
; a value for this directive (e.g., output_buffering=4096).
output_buffering = Off
; You can redirect all of the output of your scripts to a function. For
; example, if you set output_handler to "ob_gzhandler", output will be
; transparently compressed for browsers that support gzip or deflate encoding.
; Setting an output handler automatically turns on output buffering.
output_handler =
; The unserialize callback function will called (with the undefind class'
; name as parameter), if the unserializer finds an undefined class
; which should be instanciated.
; A warning appears if the specified function is not defined, or if the
; function doesn't include/implement the missing class.
; So only set this entry, if you really want to implement such a
; callback-function.
unserialize_callback_func=
; Transparent output compression using the zlib library
; Valid values for this option are 'off', 'on', or a specific buffer size
; to be used for compression (default is 4KB)
;
; Note: output_handler must be empty if this is set 'On' !!!!
;
zlib.output_compression = Off
; Implicit flush tells PHP to tell the output layer to flush itself
; automatically after every output block. This is equivalent to calling the
; PHP function flush() after each and every call to print() or echo() and each
; and every HTML block. Turning this option on has serious performance
; implications and is generally recommended for debugging purposes only.
implicit_flush = Off
; Whether to enable the ability to force arguments to be passed by reference
; at function call time. This method is deprecated and is likely to be
; unsupported in future versions of PHP/Zend. The encouraged method of
; specifying which arguments should be passed by reference is in the function
; declaration. You're encouraged to try and turn this option Off and make
; sure your scripts work properly with it in order to ensure they will work
; with future versions of the language (you will receive a warning each time
; you use this feature, and the argument will be passed by value instead of by
; reference).
allow_call_time_pass_reference = On
; Safe Mode
;
safe_mode = Off
; By default, Safe Mode does a UID compare check when
; opening files. If you want to relax this to a GID compare,
; then turn on safe_mode_gid.
safe_mode_gid = Off
; When safe_mode is on, UID/GID checks are bypassed when
; including files from this directory and its subdirectories.
; (directory must also be in include_path or full path must
; be used when including)
safe_mode_include_dir =
; When safe_mode is on, only executables located in the safe_mode_exec_dir
; will be allowed to be executed via the exec family of functions.
safe_mode_exec_dir =
; open_basedir, if set, limits all file operations to the defined directory
; and below. This directive makes most sense if used in a per-directory
; or per-virtualhost web server configuration file.
;
;open_basedir =
; Setting certain environment variables may be a potential security breach.
; This directive contains a comma-delimited list of prefixes. In Safe Mode,
; the user may only alter environment variables whose names begin with the
; prefixes supplied here. By default, users will only be able to set
; environment variables that begin with PHP_ (e.g. PHP_FOO=BAR).
;
; Note: If this directive is empty, PHP will let the user modify ANY
; environment variable!
safe_mode_allowed_env_vars = PHP_
; This directive contains a comma-delimited list of environment variables that
; the end user won't be able to change using putenv(). These variables will be
; protected even if safe_mode_allowed_env_vars is set to allow to change them.
safe_mode_protected_env_vars = LD_LIBRARY_PATH
; This directive allows you to disable certain functions for security reasons.
; It receives a comma-delimited list of function names. This directive is
; *NOT* affected by whether Safe Mode is turned On or Off.
disable_functions =
; Colors for Syntax Highlighting mode. Anything that's acceptable in
; would work.
highlight.string = #CC0000
highlight.comment = #FF9900
highlight.keyword = #006600
highlight.bg = #FFFFFF
highlight.default = #0000CC
highlight.html = #000000
;
; Misc
;
; Decides whether PHP may expose the fact that it is installed on the server
; (e.g. by adding its signature to the Web server header). It is no security
110

CMS für die MIO-Lernumgebung Anhang C
; threat in any way, but it makes it possible to determine whether you use PHP
; on your server or not.
expose_php = On
;;;;;;;;;;;;;;;;;;;
; Resource Limits ;
;;;;;;;;;;;;;;;;;;;
max_execution_time = 30 ; Maximum execution time of each script, in seconds
memory_limit = 8M ; Maximum amount of memory a script may consume (8MB)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Error handling and logging ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; error_reporting is a bit-field. Or each number up to get desired error
; reporting level
; E_ALL - All errors and warnings
; E_ERROR - fatal run-time errors
; E_WARNING - run-time warnings (non-fatal errors)
; E_PARSE - compile-time parse errors
; E_NOTICE - run-time notices (these are warnings which often result
; from a bug in your code, but it's possible that it was
; intentional (e.g., using an uninitialized variable and
; relying on the fact it's automatically initialized to an
; empty string)
; E_CORE_ERROR - fatal errors that occur during PHP's initial startup
; E_CORE_WARNING - warnings (non-fatal errors) that occur during PHP's
; initial startup
; E_COMPILE_ERROR - fatal compile-time errors
; E_COMPILE_WARNING - compile-time warnings (non-fatal errors)
; E_USER_ERROR - user-generated error message
; E_USER_WARNING - user-generated warning message
; E_USER_NOTICE - user-generated notice message
;
; Examples:
;
; - Show all errors, except for notices
;
;error_reporting = E_ALL & ~E_NOTICE
;
; - Show only errors
;
;error_reporting = E_COMPILE_ERROR|E_ERROR|E_CORE_ERROR
;
; - Show all errors except for notices
;
error_reporting = E_ALL; display all errors, warnings and notices
; Print out errors (as a part of the output). For production web sites,
; you're strongly encouraged to turn this feature off, and use error logging
; instead (see below). Keeping display_errors enabled on a production web site
; may reveal security information to end users, such as file paths on your Web
; server, your database schema or other information.
display_errors = On
; Even when display_errors is on, errors that occur during PHP's startup
; sequence are not displayed. It's strongly recommended to keep
; display_startup_errors off, except for when debugging.
display_startup_errors = Off
; Log errors into a log file (server-specific log, stderr, or error_log (below))
; As stated above, you're strongly advised to use error logging in place of
; error displaying on production web sites.
log_errors = On
; Store the last error/warning message in $php_errormsg (boolean).
track_errors = Off
; Disable the inclusion of HTML tags in error messages.
;html_errors = Off
; String to output before an error message.
;error_prepend_string = ""
; String to output after an error message.
;error_append_string = ""
; Log errors to specified file.
error_log = c:php\error.log
; Log errors to syslog (Event Log on NT, not valid in Windows 95).
;error_log = syslog
; Warn if the + operator is used with strings.
warn_plus_overloading = Off
;;;;;;;;;;;;;;;;;
; Data Handling ;
;;;;;;;;;;;;;;;;;
;
; Note - track_vars is ALWAYS enabled as of PHP 4.0.3
; The separator used in PHP generated URLs to separate arguments.
; Default is "&".
;arg_separator.output = "&"
; List of separator(s) used by PHP to parse input URLs into variables.
; Default is "&".
; NOTE: Every character in this directive is considered as separator!
;arg_separator.input = ";&"
111

CMS für die MIO-Lernumgebung Anhang C
; This directive describes the order in which PHP registers GET, POST, Cookie,
; Environment and Built-in variables (G, P, C, E & S respectively, often
; referred to as EGPCS or GPC). Registration is done from left to right, newer
; values override older values.
variables_order = "GPCS"
; Whether or not to register the EGPCS variables as global variables. You may
; want to turn this off if you don't want to clutter your scripts' global scope
; with user data. This makes most sense when coupled with track_vars - in which
; case you can access all of the GPC variables through the $HTTP_*_VARS[],
; variables.
;
; You should do your best to write your scripts so that they do not require
; register_globals to be on; Using form variables as globals can easily lead
; to possible security problems, if the code is not very well thought of.
register_globals = Off
; This directive tells PHP whether to declare the argv&argc variables (that
; would contain the GET information). If you don't use these variables, you
; should turn it off for increased performance.
register_argc_argv = Off
; Maximum size of POST data that PHP will accept.
post_max_size = 8M
; This directive is deprecated. Use variables_order instead.
gpc_order = "GPC"
; Magic quotes
;
; Magic quotes for incoming GET/POST/Cookie data.
magic_quotes_gpc = On
; Magic quotes for runtime-generated data, e.g. data from SQL, from exec(), etc.
magic_quotes_runtime = Off
; Use Sybase-style magic quotes (escape ' with '' instead of \').
magic_quotes_sybase = Off
; Automatically add files before or after any PHP document.
auto_prepend_file =
auto_append_file =
; As of 4.0b4, PHP always outputs a character encoding by default in
; the Content-type: header. To disable sending of the charset, simply
; set it to be empty.
;
; PHP's built-in default is text/html
default_mimetype = "text/html"
;default_charset = "iso-8859-1"
; Always populate the $HTTP_RAW_POST_DATA variable.
;always_populate_raw_post_data = On
;;;;;;;;;;;;;;;;;;;;;;;;;
; Paths and Directories ;
;;;;;;;;;;;;;;;;;;;;;;;;;
; UNIX: "/path1:/path2"
;include_path = ".:/php/includes"
;
; Windows: "\path1;\path2"
;include_path = ".;c:\php\includes"
include_path = ".;c:\Programme\Apache Group\Apache\htdocs\miowww\adodb"
; The root of the PHP pages, used only if nonempty.
; if PHP was not compiled with FORCE_REDIRECT, you SHOULD set doc_root
; if you are running php as a CGI under any web server (other than IIS)
; see documentation for security issues. The alternate is to use the
; cgi.force_redirect configuration below
doc_root = "c:\Programme\Apache Group\Apache\htdocs"
; The directory under which PHP opens the script using /~usernamem used only
; if nonempty.
user_dir =
; Directory in which the loadable extensions (modules) reside.
extension_dir = "c:\php\extensions"
; Whether or not to enable the dl() function. The dl() function does NOT work
; properly in multithreaded servers, such as IIS or Zeus, and is automatically
; disabled on them.
enable_dl = On
; cgi.force_redirect is necessary to provide security running PHP as a CGI under
; most web servers. Left undefined, PHP turns this on by default. You can
; turn it off here AT YOUR OWN RISK
; **You CAN safely turn this off for IIS, in fact, you MUST.**
; cgi.force_redirect = 1
; if cgi.force_redirect is turned on, and you are not running under Apache or Netscape
; (iPlanet) web servers, you MAY need to set an environment variable name that PHP
; will look for to know it is OK to continue execution. Setting this variable MAY
; cause security issues, KNOW WHAT YOU ARE DOING FIRST.
; cgi.redirect_status_env = ;
;;;;;;;;;;;;;;;;
; File Uploads ;
;;;;;;;;;;;;;;;;
; Whether to allow HTTP file uploads.
file_uploads = On
; Temporary directory for HTTP uploaded files (will use system default if not
112

CMS für die MIO-Lernumgebung Anhang C
; specified).
upload_tmp_dir = C:\PHP\uploadtemp ; temporary directory for HTTP uploaded files (will use system default if not specified)
; Maximum allowed size for uploaded files.
upload_max_filesize = 2M
;;;;;;;;;;;;;;;;;;
; Fopen wrappers ;
;;;;;;;;;;;;;;;;;;
; Whether to allow the treatment of URLs (like http:// or ftp://) as files.
allow_url_fopen = On
; Define the anonymous ftp password (your email address)
;from="john@doe.com"
;;;;;;;;;;;;;;;;;;;;;;
; Dynamic Extensions ;
;;;;;;;;;;;;;;;;;;;;;;
;
; If you wish to have an extension loaded automatically, use the following
; syntax:
;
; extension=modulename.extension
;
; For example, on Windows:
;
; extension=msql.dll
;
; ... or under UNIX:
;
; extension=msql.so
;
; Note that it should be the name of the module only; no directory information
; needs to go here. Specify the location of the extension with the
; extension_dir directive above.
;Windows Extensions
;Note that MySQL and ODBC support is now built in, so no dll is needed for it.
;
;extension=php_bz2.dll
;extension=php_ctype.dll
;extension=php_cpdf.dll
;extension=php_curl.dll
;extension=php_cybercash.dll
;extension=php_db.dll
;extension=php_dba.dll
;extension=php_dbase.dll
;extension=php_dbx.dll
extension=php_domxml.dll
;extension=php_dotnet.dll
;extension=php_exif.dll
;extension=php_fbsql.dll
;extension=php_fdf.dll
;extension=php_filepro.dll
;extension=php_gd.dll
;extension=php_gettext.dll
;extension=php_hyperwave.dll
;extension=php_iconv.dll
;extension=php_ifx.dll
;extension=php_iisfunc.dll
;extension=php_imap.dll
;extension=php_ingres.dll
;extension=php_interbase.dll
;extension=php_java.dll
;extension=php_ldap.dll
;extension=php_mbstring.dll
;extension=php_mcrypt.dll
;extension=php_mhash.dll
;extension=php_ming.dll
;extension=php_mssql.dll
;extension=php_oci8.dll
;extension=php_openssl.dll
;extension=php_oracle.dll
;extension=php_pdf.dll
;extension=php_pgsql.dll
;extension=php_printer.dll
;extension=php_shmop.dll
;extension=php_snmp.dll
;extension=php_sockets.dll
;extension=php_sybase_ct.dll
;extension=php_tokenizer.dll
;extension=php_w32api.dll
extension=php_xslt.dll
;extension=php_yaz.dll
;extension=php_zlib.dll
;;;;;;;;;;;;;;;;;;;
; Module Settings ;
;;;;;;;;;;;;;;;;;;;
[Syslog]
; Whether or not to define the various syslog variables (e.g. $LOG_PID,
; $LOG_CRON, etc.). Turning it off is a good idea performance-wise. In
; runtime, you can define these variables by calling define_syslog_variables().
define_syslog_variables = Off
[mail function]
; For Win32 only.
SMTP = localhost ; for Win32 only
113

CMS für die MIO-Lernumgebung Anhang C
; For Win32 only.
sendmail_from = me@localhost.com ; for Win32 only
; For Unix only. You may supply arguments as well (default: "sendmail -t -i").
;sendmail_path =
[Java]
;java.class.path = .\php_java.jar
;java.home = c:\jdk
;java.library = c:\jdk\jre\bin\hotspot\jvm.dll
;java.library.path = .\
[SQL]
sql.safe_mode = Off
[ODBC]
;odbc.default_db = Not yet implemented
;odbc.default_user = Not yet implemented
;odbc.default_pw = Not yet implemented
; Allow or prevent persistent links.
odbc.allow_persistent = On
; Check that a connection is still valid before reuse.
odbc.check_persistent = On
; Maximum number of persistent links. -1 means no limit.
odbc.max_persistent = -1
; Maximum number of links (persistent + non-persistent). -1 means no limit.
odbc.max_links = -1
; Handling of LONG fields. Returns number of bytes to variables. 0 means
; passthru.
odbc.defaultlrl = 4096
; Handling of binary data. 0 means passthru, 1 return as is, 2 convert to char.
; See the documentation on odbc_binmode and odbc_longreadlen for an explanation
; of uodbc.defaultlrl and uodbc.defaultbinmode
odbc.defaultbinmode = 1
[MySQL]
; Allow or prevent persistent links.
mysql.allow_persistent = On
; Maximum number of persistent links. -1 means no limit.
mysql.max_persistent = -1
; Maximum number of links (persistent + non-persistent). -1 means no limit.
mysql.max_links = -1
; Default port number for mysql_connect(). If unset, mysql_connect() will use
; the $MYSQL_TCP_PORT or the mysql-tcp entry in /etc/services or the
; compile-time value defined MYSQL_PORT (in that order). Win32 will only look
; at MYSQL_PORT.
mysql.default_port = 3306
; Default socket name for local MySQL connects. If empty, uses the built-in
; MySQL defaults.
mysql.default_socket =
; Default host for mysql_connect() (doesn't apply in safe mode).
mysql.default_host = 127.0.0.1
; Default user for mysql_connect() (doesn't apply in safe mode).
mysql.default_user = miowww
; Default password for mysql_connect() (doesn't apply in safe mode).
; Note that this is generally a *bad* idea to store passwords in this file.
; *Any* user with PHP access can run 'echo cfg_get_var("mysql.default_password")
; and reveal this password! And of course, any users with read access to this
; file will be able to reveal the password as well.
mysql.default_password =
[mSQL]
; Allow or prevent persistent links.
msql.allow_persistent = On
; Maximum number of persistent links. -1 means no limit.
msql.max_persistent = -1
; Maximum number of links (persistent+non persistent). -1 means no limit.
msql.max_links = -1
[PostgresSQL]
; Allow or prevent persistent links.
pgsql.allow_persistent = On
; Detect broken persistent links always with pg_pconnect(). Need a little overhead.
pgsql.auto_reset_persistent = Off
; Maximum number of persistent links. -1 means no limit.
pgsql.max_persistent = -1
; Maximum number of links (persistent+non persistent). -1 means no limit.
pgsql.max_links = -1
[Sybase]
; Allow or prevent persistent links.
sybase.allow_persistent = On
; Maximum number of persistent links. -1 means no limit.
sybase.max_persistent = -1
; Maximum number of links (persistent + non-persistent). -1 means no limit.
114

CMS für die MIO-Lernumgebung Anhang C
sybase.max_links = -1
;sybase.interface_file = "/usr/sybase/interfaces"
; Minimum error severity to display.
sybase.min_error_severity = 10
; Minimum message severity to display.
sybase.min_message_severity = 10
; Compatability mode with old versions of PHP 3.0.
; If on, this will cause PHP to automatically assign types to results according
; to their Sybase type, instead of treating them all as strings. This
; compatability mode will probably not stay around forever, so try applying
; whatever necessary changes to your code, and turn it off.
sybase.compatability_mode = Off
[Sybase-CT]
; Allow or prevent persistent links.
sybct.allow_persistent = On
; Maximum number of persistent links. -1 means no limit.
sybct.max_persistent = -1
; Maximum number of links (persistent + non-persistent). -1 means no limit.
sybct.max_links = -1
; Minimum server message severity to display.
sybct.min_server_severity = 10
; Minimum client message severity to display.
sybct.min_client_severity = 10
[bcmath]
; Number of decimal digits for all bcmath functions.
bcmath.scale = 0
[browscap]
;browscap = extra/browscap.ini
[Informix]
; Default host for ifx_connect() (doesn't apply in safe mode).
ifx.default_host =
; Default user for ifx_connect() (doesn't apply in safe mode).
ifx.default_user =
; Default password for ifx_connect() (doesn't apply in safe mode).
ifx.default_password =
; Allow or prevent persistent links.
ifx.allow_persistent = On
; Maximum number of persistent links. -1 means no limit.
ifx.max_persistent = -1
; Maximum number of links (persistent + non-persistent). -1 means no limit.
ifx.max_links = -1
; If on, select statements return the contents of a text blob instead of its id.
ifx.textasvarchar = 0
; If on, select statements return the contents of a byte blob instead of its id.
ifx.byteasvarchar = 0
; Trailing blanks are stripped from fixed-length char columns. May help the
; life of Informix SE users.
ifx.charasvarchar = 0
; If on, the contents of text and byte blobs are dumped to a file instead of
; keeping them in memory.
ifx.blobinfile = 0
; NULL's are returned as empty strings, unless this is set to 1. In that case,
; NULL's are returned as string 'NULL'.
ifx.nullformat = 0
[Session]
; Handler used to store/retrieve data.
session.save_handler = files
; Argument passed to save_handler. In the case of files, this is the path
; where data files are stored. Note: Windows users have to change this
; variable in order to use PHP's session functions.
session.save_path = C:\php\sessiondata ; argument passed to save_handler
; Whether to use cookies.
session.use_cookies = 1
; Name of the session (used as cookie name).
session.name = PHPSESSID
; Initialize session on request startup.
session.auto_start = 0
; Lifetime in seconds of cookie or, if 0, until browser is restarted.
session.cookie_lifetime = 0
; The path for which the cookie is valid.
session.cookie_path = /
; The domain for which the cookie is valid.
session.cookie_domain =
115

CMS für die MIO-Lernumgebung Anhang C
; Handler used to serialize data. php is the standard serializer of PHP.
session.serialize_handler = php
; Percentual probability that the 'garbage collection' process is started
; on every session initialization.
session.gc_probability = 1
; After this number of seconds, stored data will be seen as 'garbage' and
; cleaned up by the garbage collection process.
session.gc_maxlifetime = 1440
; Check HTTP Referer to invalidate externally stored URLs containing ids.
; HTTP_REFERER has to contain this substring for the session to be
; considered as valid.
session.referer_check =
; How many bytes to read from the file.
session.entropy_length = 0
; Specified here to create the session id.
session.entropy_file =
;session.entropy_length = 16
;session.entropy_file = /dev/urandom
; Set to {nocache,private,public} to determine HTTP caching aspects.
session.cache_limiter = nocache
; Document expires after n minutes.
session.cache_expire = 180
; use transient sid support if enabled by compiling with --enable-trans-sid.
session.use_trans_sid = 1
url_rewriter.tags = "a=href,area=href,frame=src,input=src,form=fakeentry"
[MSSQL]
; Allow or prevent persistent links.
mssql.allow_persistent = On
; Maximum number of persistent links. -1 means no limit.
mssql.max_persistent = -1
; Maximum number of links (persistent+non persistent). -1 means no limit.
mssql.max_links = -1
; Minimum error severity to display.
mssql.min_error_severity = 10
; Minimum message severity to display.
mssql.min_message_severity = 10
; Compatability mode with old versions of PHP 3.0.
mssql.compatability_mode = Off
; Valid range 0 - 2147483647. Default = 4096.
;mssql.textlimit = 4096
; Valid range 0 - 2147483647. Default = 4096.
;mssql.textsize = 4096
; Limits the number of records in each batch. 0 = all records in one batch.
;mssql.batchsize = 0
[Assertion]
; Assert(expr); active by default.
;assert.active = On
; Issue a PHP warning for each failed assertion.
;assert.warning = On
; Don't bail out by default.
;assert.bail = Off
; User-function to be called if an assertion fails.
;assert.callback = 0
; Eval the expression with current error_reporting(). Set to true if you want
; error_reporting(0) around the eval().
;assert.quiet_eval = 0
[Ingres II]
; Allow or prevent persistent links.
ingres.allow_persistent = On
; Maximum number of persistent links. -1 means no limit.
ingres.max_persistent = -1
; Maximum number of links, including persistents. -1 means no limit.
ingres.max_links = -1
; Default database (format: [node_id::]dbname[/srv_class]).
ingres.default_database =
; Default user.
ingres.default_user =
; Default password.
ingres.default_password =
[Verisign Payflow Pro]
; Default Payflow Pro server.
pfpro.defaulthost = "test-payflow.verisign.com"
116

CMS für die MIO-Lernumgebung Anhang C
; Default port to connect to.
pfpro.defaultport = 443
; Default timeout in seconds.
pfpro.defaulttimeout = 30
; Default proxy IP address (if required).
;pfpro.proxyaddress =
; Default proxy port.
;pfpro.proxyport =
; Default proxy logon.
;pfpro.proxylogon =
; Default proxy password.
;pfpro.proxypassword =
[Sockets]
; Use the system read() function instead of the php_read() wrapper.
sockets.use_system_read = On
[com]
; path to a file containing GUIDs, IIDs or filenames of files with TypeLibs
;com.typelib_file =
; allow Distributed-COM calls
;com.allow_dcom = true
; autoregister constants of a components typlib on com_load()
;com.autoregister_typelib = true
; register constants casesensitive
;com.autoregister_casesensitive = false
; show warnings on duplicate constat registrations
;com.autoregister_verbose = true
[Printer]
;printer.default_printer = ""
[mbstring]
;mbstring.internal_encoding = EUC-JP
;mbstring.http_input = auto
;mbstring.http_output = SJIS
;mbstring.detect_order = auto
;mbstring.substitute_character = none;
[FrontBase]
;fbsql.allow_persistent = On
;fbsql.autocommit = On
;fbsql.default_database =
;fbsql.default_database_password =
;fbsql.default_host =
;fbsql.default_password =
;fbsql.default_user = "_SYSTEM"
;fbsql.generate_warnings = Off
;fbsql.max_connections = 128
;fbsql.max_links = 128
;fbsql.max_persistent = -1
;fbsql.max_results = 128
;fbsql.batchSize = 1000
; Local Variables:
; tab-width: 4
; End:
117

CMS für die MIO-Lernumgebung Anhang D
Anhang D: Source-Code
1. frame.php
Untitled Document
MIO
Personen
Gruppen
Klassen
Themen
Mikroartikel
Typen
Inputs/Outputs
Sternzeichen
Blöcke
Termine
Materialien
Landschaft
CMS
Materialübersicht
Dateiprüfungen
LogoutBenutzer:
Gruppe(n):

CMS für die MIO-Lernumgebung Anhang D
if (isset($miodb)){
$miodb->Close();
}
?>
2. index.html
Content Management System
3. table_of_contents.html
Content Management System
Ansicht
Erstellen
Editieren
Prüfen
Metadaten
Archiv
4. choose_class.php

CMS für die MIO-Lernumgebung Anhang D
case "new_content":
$cms_action="new_content";
break;
case "edit_content":
$cms_action="edit_content";
break;
case "check_content":
$cms_action="check_content";
break;
case "manage_metadata":
$cms_action="manage_metadata";
break;
case "archive":
$cms_action="archive";
break;
}
}
else
{
exit;
}
// die Funktion isAdmin() wird aus der Umgebung (.././inc/functions_auth.inc.php) geladen und überprüft, ob der Benutzer
Administratorrechte besitzt
// Administratoren können auch Lehrtexte aus Klassen, die nicht aktiv sind, erstellen/bearbeiten/prüfen etc.
if (isAdmin())
{
$result = $miodb->Execute("select classes.classes_id as classes_id,classname,active from classes");
if($result == false) die($miodb->ErrorMsg());
}
else
{
$result = $miodb->Execute("select distinct classes.classes_id as classes_id,classname,active from
classes,classes_groups,groups_persons where classes.classes_id=classes_groups.classes_id and
classes_groups.groups_id=groups_persons.groups_id and groups_persons.persons_id=".$user_id." and classes.active=1 and not
(classes.classes_id=1)");
if($result == false) die($miodb->ErrorMsg());
}
echo "";
echo "Bitte Klasse wählen:";
echo "";
while (!$result->EOF)
{
if ($result->fields["active"] == 1)
{
$state="aktiv";
}
else
{
$state="nicht aktiv";
}
}
echo "fields["classes_id"] . "\">" . $result->fields["classname"] .", ".$state."";
$result->MoveNext();
echo "";
echo "";
echo "";
echo "";
// Einbinden des Footers
require("footer.php");
?>
120

CMS für die MIO-Lernumgebung Anhang D
5. contents.php

CMS für die MIO-Lernumgebung Anhang D
}
echo "";
echo "";
echo "";
}
function new_content()
{
// diese Funktion zeigt Standardformular zum Erstellen von Dokumenten mit gewähltem Eintrag der Klasse an
// globale Variablen müssen innerhalb von Funktionen als solche definiert werden
global $miodb;
global $class_id;
global $user_id;
// Lehrtexte erstellen dürfen: alle Referenten der spezifischen Klasse und Administratoren
$result = $miodb->Execute("select groupname from classes_groups,groups,groups_persons where
classes_groups.classes_id=".$class_id." and classes_groups.groups_id=groups_persons.groups_id and
groups_persons.persons_id=".$user_id." and classes_groups.groups_id=groups.groups_id and groups.groupname like 'Referenten'");
if($result == false) die($miodb->ErrorMsg());
// die Funktion isAdmin() wird aus der Umgebung (.././inc/functions_auth.inc.php) geladen und überprüft, ob der Benutzer
Administratorrechte besitzt
if (isAdmin() || !$result->EOF)
{
// String-Bildung des Inhalts der DTD-Datei
$content_dtd = implode('', file('content.dtd'));
// Generieren des xml-strings
$xml_str = "".$cla
ss_id."";
$args = array('/_xml' => $xml_str);
// XSLT-Prozessor
$x = xslt_create();
// Transformation des XML-Strings mit XSL-Stylesheet content.xsl
$result = xslt_process($x, 'arg:/_xml', 'content_form.xsl', NULL, $args);
if ($result)
{
// Anzeige im Browser
echo $result;
}
else
{
echo xslt_error($x);
}
xslt_free($x);
}
else
{
echo "Keine Berechtigung!";
}
}
function edit_content()
{
// diese Funktion generiert ein Auswahl-Feld mit den vorhandenen Dokumenten, welche nicht den Status "veraltet" haben
// anschliessend wird "edit_content.php" aufgerufen, um das gewählte Dokument zu editieren
// globale Variablen müssen innerhalb von Funktionen als solche definiert werden
global $miodb;
global $class_id;
global $user_id;
// Folgende Anfrage lädt alle relevanten Daten, um die Lehrtexte editieren zu können
// über die joins werden diejenigen herausgefiltert, für welche die Berechtigung zum editieren vorhanden ist und die im Status
"zu prüfen" oder "nicht freigegeben" sind
// Lehrtexte editieren dürfen: der Autor und Administratoren solange der Lehrtext nicht geprüft und freigegeben ist
// die Funktion isAdmin() wird aus der Umgebung (.././inc/functions_auth.inc.php) geladen und überprüft, ob der Benutzer
Administratorrechte besitzt
if (isAdmin())
{
$result = $miodb->Execute("select metadata.metadata_id as metadata_id,title,version,metadata.state_id as
state_id,state,metadata.lock as content_lock,date,content,concat(person_name,' ',person_firstname) as author,theme from
metadata,content,persons,themes,state where content.metadata_id=metadata.metadata_id and metadata.themes_id=themes.themes_id
and persons.persons_id=metadata.persons_id and metadata.state_id=state.state_id and metadata.class_id=".$class_id." and (state
like 'zu prüfen' or state like 'nicht freigegeben') order by title,theme");
if($result == false) die($miodb->ErrorMsg());
}
else
{
// falls Benutzer Mitglied der klassenspezifischen Studienleitung
$result_Studienleitung = $miodb->Execute("select metadata.metadata_id as metadata_id,title,version,metadata.state_id as
state_id,state,metadata.lock as content_lock,date,content,concat(person_name,' ',person_firstname) as
author,theme,metadata.edit_group_id from metadata,content,persons,themes,state,classes_groups,groups_persons where
content.metadata_id=metadata.metadata_id and metadata.themes_id=themes.themes_id and persons.persons_id=metadata.persons_id and
metadata.state_id=state.state_id and classes_groups.classes_id=".$class_id." and
classes_groups.groups_id=metadata.edit_group_id and classes_groups.groups_id=groups_persons.groups_id and
groups_persons.persons_id=".$user_id." and metadata.class_id=".$class_id." and (state like 'zu prüfen' or state like 'nicht
122

CMS für die MIO-Lernumgebung Anhang D
freigegeben') order by title,theme");
if($result_Studienleitung == false) die($miodb->ErrorMsg());
// falls Benutzer Autor
$result_Autor = $miodb->Execute("select distinct metadata.metadata_id as metadata_id,title,version,metadata.state_id as
state_id,state,metadata.lock as content_lock,date,content,concat(person_name,' ',person_firstname) as author,theme from
metadata,content,persons,themes,state where content.metadata_id=metadata.metadata_id and metadata.themes_id=themes.themes_id
and persons.persons_id=metadata.persons_id and metadata.state_id=state.state_id and metadata.persons_id=".$user_id." and
metadata.class_id=".$class_id." and (state like 'zu prüfen' or state like 'nicht freigegeben') order by title,theme");
if($result_Autor == false) die($miodb->ErrorMsg());
if (!$result_Studienleitung->EOF && !$result_Autor->EOF)
{
$result = $miodb->Execute("select distinct metadata.metadata_id as metadata_id,title,version,metadata.state_id as
state_id,state,metadata.lock as content_lock,date,content,concat(person_name,' ',person_firstname) as
author,theme,metadata.edit_group_id from metadata,content,persons,themes,state,classes_groups,groups_persons where
content.metadata_id=metadata.metadata_id and metadata.themes_id=themes.themes_id and persons.persons_id=metadata.persons_id and
metadata.state_id=state.state_id and ((classes_groups.classes_id=".$class_id." and
classes_groups.groups_id=metadata.edit_group_id and classes_groups.groups_id=groups_persons.groups_id and
groups_persons.persons_id=".$user_id.") or (metadata.persons_id=".$user_id.")) and metadata.class_id=".$class_id." and (state
like 'zu prüfen' or state like 'nicht freigegeben') order by title,theme");
if($result == false) die($miodb->ErrorMsg());
}
elseif (!$result_Studienleitung->EOF)
{
$result = $result_Studienleitung;
}
else
{
$result = $result_Autor;
}
}
echo "";
echo "Editieren:";
echo "";
while (!$result->EOF)
{
// gesperrte Dokumente in Auswahlfenster kennzeichnen
if ($result->fields['content_lock'] == 1)
{
$lock = ", gesperrt";
echo "fields["metadata_id"] . "\">" . $result->fields["title"].", ".$result-
>fields["author"].", ".$result->fields["theme"].", Version: ".$result->fields["version"].", ".$result->fields["date"] . $lock
."";
}
else
{
echo "fields["metadata_id"] . "\">" . $result->fields["title"].", ".$result-
>fields["author"].", ".$result->fields["theme"].", Version: ".$result->fields["version"].", ".$result->fields["date"]
."";
}
}
$result->MoveNext();
echo "";
echo "";
echo "";
}
function check_content()
{
// diese Funktion generiert ein Auswahl-Feld mit den vorhandenen Dokumenten, welche den Status "zu prüfen" haben
// anschliessend wird "check_content.php" aufgerufen, um das ausgewählte Dokument zu prüfen
// globale Variablen müssen innerhalb von Funktionen als solche definiert werden
global $miodb;
global $class_id;
global $user_id;
// Folgende Anfrage lädt alle relevanten Daten, um die Lehrtexte prüfen zu können
// über die joins werden diejenigen herausgefiltert, für welche die Berechtigung zum Prüfen vorhanden ist und die im Status "zu
prüfen" sind
// Lehrtexte prüfen dürfen: die klassenspezifische Studienleitung und Administratoren
// die Funktion isAdmin() wird aus der Umgebung (.././inc/functions_auth.inc.php) geladen und überprüft, ob der Benutzer
Administratorrechte besitzt
if (isAdmin())
{
$result = $miodb->Execute("select metadata.metadata_id as metadata_id,title,version,metadata.state_id as
state_id,class_id,state,date,content,concat(person_name,' ',person_firstname) as author,theme,metadata.lock as content_lock
from metadata,content,persons,themes,state where content.metadata_id=metadata.metadata_id and
themes.themes_id=metadata.themes_id and persons.persons_id=metadata.persons_id and metadata.state_id=state.state_id and state
like 'zu prüfen' and metadata.class_id=".$class_id." order by title,theme");
if($result == false) die($miodb->ErrorMsg());
}
else
{
$result = $miodb->Execute("select distinct metadata.metadata_id as metadata_id,title,version,metadata.state_id as
state_id,class_id,state,date,content,concat(person_name,' ',person_firstname) as author,theme,metadata.lock as
content_lock,check_group_id from metadata,content,persons,themes,state,classes_groups,groups_persons where
content.metadata_id=metadata.metadata_id and themes.themes_id=metadata.themes_id and persons.persons_id=metadata.persons_id and
metadata.state_id=state.state_id and state like 'zu prüfen' and classes_groups.classes_id=".$class_id." and
classes_groups.groups_id=metadata.check_group_id and classes_groups.groups_id=groups_persons.groups_id and
groups_persons.persons_id=".$user_id." and metadata.class_id=".$class_id." order by title,theme");
if($result == false) die($miodb->ErrorMsg());
}
echo "";
echo "Prüfen:";
123

CMS für die MIO-Lernumgebung Anhang D
echo "";
while (!$result->EOF)
{
// gesperrte Dokumente in Auswahlfenster kennzeichnen
if ($result->fields['content_lock']==1)
{
$lock = ", gesperrt";
echo "fields["metadata_id"] . "\">" . $result->fields["title"].", ".$result-
>fields["author"].", ".$result->fields["theme"].", Version: ".$result->fields["version"].", ".$result->fields["date"] . $lock
."";
}
else
{
echo "fields["metadata_id"] . "\">" . $result->fields["title"].", ".$result-
>fields["author"].", ".$result->fields["theme"].", Version: ".$result->fields["version"].", ".$result->fields["date"] .
"";
}
}
$result->MoveNext();
echo "";
echo "";
echo "";
}
function archive()
{
// diese Funktion generiert ein Auswahl-Feld mit den vorhandenen Dokumenten, welche den Status "veraltet" haben
// anschliessend wird "archive.php" aufgerufen, um das Archiv-Dokument zu betrachten
// globale Variablen müssen innerhalb von Funktionen als solche definiert werden
global $miodb;
global $class_id;
global $user_id;
// Folgende Anfrage lädt alle relevanten Daten, um die archivierten Lehrtexte anzeigen zu können
// über die joins werden diejenigen herausgefiltert, für welche die Berechtigung zum anschauen vorhanden ist
// Lehrtexte anschauen dürfen: Referenten der spezifischen Klasse und Administratoren
// die Funktion isAdmin() wird aus der Umgebung (.././inc/functions_auth.inc.php) geladen und überprüft, ob der Benutzer
Administratorrechte besitzt
if (isAdmin())
{
$result = $miodb->Execute("select metadata.metadata_id as
metadata_id,title,version,state,date,content,class_id,concat(person_name,' ',person_firstname) as author,theme from
metadata,content,persons,themes,state where metadata.metadata_id=content.metadata_id and metadata.class_id=".$class_id." and
themes.themes_id=metadata.themes_id and persons.persons_id=metadata.persons_id and metadata.state_id=state.state_id and state
like 'veraltet' order by title,theme");
if($result == false) die($miodb->ErrorMsg());
}
else
{
$result = $miodb->Execute("select distinct metadata.metadata_id as
metadata_id,title,version,state,date,content,class_id,concat(person_name,' ',person_firstname) as author,theme from
metadata,content,persons,themes,state,classes_groups,groups_persons,groups where metadata.metadata_id=content.metadata_id and
metadata.class_id=".$class_id." and themes.themes_id=metadata.themes_id and persons.persons_id=metadata.persons_id and
metadata.state_id=state.state_id and state like 'veraltet' and classes_groups.classes_id=metadata.class_id and
classes_groups.groups_id=groups_persons.groups_id and groups_persons.persons_id=".$user_id." and
classes_groups.groups_id=groups.groups_id and groups.groupname like 'Referenten' order by title,theme");
if($result == false) die($miodb->ErrorMsg());
}
echo "";
echo "Archiv:";
echo "";
while (!$result->EOF)
{
echo "fields["metadata_id"] . "\">" . $result->fields["title"].", ".$result-
>fields["author"].", ".$result->fields["theme"].", Version: ".$result->fields["version"].", ".$result->fields["date"] .
"";
}
$result->MoveNext();
echo "";
echo "";
echo "";
}
function manage_metadata()
{
// diese Funktion generiert ein Auswahl-Feld mit den vorhandenen Dokumenten, welche nicht den Status "veraltet" haben
// anschliessend wird "get_metadata.php" aufgerufen, um die Metadaten des ausgewählte Dokuments zu editieren
// globale Variablen müssen innerhalb von Funktionen als solche definiert werden
global $miodb;
global $class_id;
global $user_id;
// Folgende Anfrage lädt alle relevanten Daten, um die Metadaten eines Lehrtextes bearbeiten zu können
// über die joins werden diejenigen herausgefiltert, für welche die Berechtigung zum Bearbeiten vorhanden ist
// Lehrtexte prüfen dürfen: die klassenspezifische Studienleitung und Administratoren
// die Funktion isAdmin() wird aus der Umgebung (.././inc/functions_auth.inc.php) geladen und überprüft, ob der Benutzer
Administratorrechte besitzt
if (isAdmin())
124

CMS für die MIO-Lernumgebung Anhang D
{
$result = $miodb->Execute("select metadata.metadata_id as metadata_id,title,version,metadata.state_id as
state_id,class_id,state,date,content,concat(person_name,' ',person_firstname) as author,theme,metadata.lock as
content_lock,content_type from metadata,content,persons,themes,state where content.metadata_id=metadata.metadata_id and
themes.themes_id=metadata.themes_id and persons.persons_id=metadata.persons_id and metadata.state_id=state.state_id and
metadata.class_id=".$class_id." and not (state like 'veraltet') order by title,theme");
if($result == false) die($miodb->ErrorMsg());
}
else
{
$result = $miodb->Execute("select distinct metadata.metadata_id as metadata_id,title,version,metadata.state_id as
state_id,class_id,state,date,content,concat(person_name,' ',person_firstname) as author,theme,metadata.lock as
content_lock,content_type from metadata,content,persons,themes,state,classes_groups,groups,groups_persons where
content.metadata_id=metadata.metadata_id and themes.themes_id=metadata.themes_id and persons.persons_id=metadata.persons_id and
metadata.state_id=state.state_id and metadata.class_id=".$class_id." and not (state like 'veraltet') and
classes_groups.classes_id=".$class_id." and classes_groups.groups_id=metadata.check_group_id and
classes_groups.groups_id=groups_persons.groups_id and groups_persons.persons_id=".$user_id." order by title,theme");
if($result == false) die($miodb->ErrorMsg());
}
echo "";
echo "Metadaten verwalten:";
echo "";
while (!$result->EOF)
{
// gesperrte Dokumente in Auswahlfenster kennzeichnen
if ($result->fields['content_lock']==1)
{
$lock = ", gesperrt";
echo "fields["metadata_id"] . "\">" . $result->fields["title"].", ".$result-
>fields["author"].", ".$result->fields["theme"].", Version: ".$result->fields["version"].", ".$result->fields["date"] . $lock
."";
}
else
{
echo "fields["metadata_id"] . "\">" . $result->fields["title"].", ".$result-
>fields["author"].", ".$result->fields["theme"].", Version: ".$result->fields["version"].", ".$result->fields["date"]
."";
}
}
$result->MoveNext();
echo "";
echo "";
echo "";
}
// Einbinden des Footers
require("footer.php");
?>
6. show_content.php
fields['title']."".$result-
>fields['author']."".$result->fields['persons_id']."".$result-
>fields['theme']."".$result->fields['themes_id']."".$result->fields['content']."";
$args = array('/_xml' => $xml_str);
// XSLT-Prozessor
$x = xslt_create();
// Transformation des XML-Strings mit XSL-Stylesheet content.xsl
$result = xslt_process($x, 'arg:/_xml', 'content.xsl', NULL, $args);
if ($result)
{
// Anzeige im Browser
125

CMS für die MIO-Lernumgebung Anhang D
echo $result;
}
else
{
echo xslt_error($x);
}
xslt_free($x);
// Einbinden des Footers
require("footer.php");
?>
7. new_content.php
$xml_str);
// XSLT-Prozessor
$x = xslt_create();
// Transformation des XML-Strings mit XSL-Stylesheet content.xsl
$result = xslt_process($x, 'arg:/_xml', 'content_form.xsl', NULL, $args);
if ($result)
{
// Anzeige im Browser
echo $result;
}
else
{
echo xslt_error($x);
}
xslt_free($x);
// Einbinden des Footers
require("footer.php");
?>
8. edit_content.php
Execute($sql);
if($result == false) die($miodb->ErrorMsg());
// falls zu bearbeitendes Dokument gesperrt
if ($result->fields['content_lock'] == 1)
{
echo "Gewähltes Dokument gesperrt!";
exit;
}
// Sperren des zu bearbeitenden Dokuments
$sql = "update metadata set metadata.lock=1 where metadata_id=".$id;
126

CMS für die MIO-Lernumgebung Anhang D
$result = $miodb->Execute($sql);
if($result == false) die($miodb->ErrorMsg());
$sql = "select metadata.metadata_id,title,metadata.persons_id as persons_id,metadata.themes_id,content,concat(person_name,'
',person_firstname) as author,theme,version,class_id from metadata,content,persons,themes where metadata.metadata_id=".$id."
and metadata.metadata_id=content.metadata_id and themes.themes_id=metadata.themes_id and
persons.persons_id=metadata.persons_id order by title,theme";
$result = $miodb->Execute($sql);
if($result == false) die($miodb->ErrorMsg());
// Generieren des xml-Strings
$xml_str = "" .$result->fields['title']."".$result-
>fields['author']."".$result->fields['persons_id']."".$result-
>fields['theme']."".$result->fields['themes_id']."".$result-
>fields['class_id']."".$result->fields['content']."";
$args = array('/_xml' => $xml_str);
// XSLT-Prozessor
$x = xslt_create();
// Transformation des XML-Strings mit XSL-Stylesheet content_form.xsl
$result = xslt_process($x, 'arg:/_xml', 'content_form.xsl', NULL, $args);
if ($result)
{
// Anzeige im Browser
echo $result;
}
else
{
echo xslt_error($x);
}
xslt_free($x);
// Einbinden des Footers
require("footer.php");
?>
9. archive.php
fields['title']."".$result-
>fields['author']."".$result->fields['persons_id']."".$result-
>fields['theme']."".$result->fields['themes_id']."".$result->fields['content']."";
$args = array('/_xml' => $xml_str);
// XSLT-Prozessor
$x = xslt_create();
// Transformation des XML-Strings mit XSL-Stylesheet content.xsl
$result = xslt_process($x, 'arg:/_xml', 'content.xsl', NULL, $args);
if ($result)
{
// Anzeige im Browser
echo $result;
}
else
{
echo xslt_error($x);
}
xslt_free($x);
// Einbinden des Footers
require("footer.php");
?>
127

CMS für die MIO-Lernumgebung Anhang D
10. check_content.php
fields['title']."".$result-
>fields['author']."".$result->fields['persons_id']."".$result-
>fields['theme']."".$result->fields['themes_id']."".$result->fields['content']."";
$args = array('/_xml' => $xml_str);
// XSLT-Prozessor
$x = xslt_create();
// Transformation des XML-Strings mit XSL-Stylesheet content.xsl
$result = xslt_process($x, 'arg:/_xml', 'content.xsl', NULL, $args);
if ($result)
{
// Anzeige im Browser
echo $result;
}
else
{
echo xslt_error($x);
}
xslt_free($x);
echo "";
echo "";
echo "Freigeben";
echo "Ablehnen / Überarbeiten";
echo "";
echo "";
echo "";
// Einbinden des Footers
require("footer.php");
?>
11. set_state.php

CMS für die MIO-Lernumgebung Anhang D
require("header.php");
if(isset($_POST['check']))
{
$id = $_POST['id'];
if ($_POST['check'] == 'Freigeben')
{
$sql = "select state_id from state where state like 'freigegeben'";
$state = $miodb->Execute($sql);
if($state == false) die($miodb->ErrorMsg());
$state_id = $state->fields['state_id'];
$sql = "update metadata set state_id='".$state_id."' where metadata_id=".$id;
$result = $miodb->Execute($sql);
if($result == false) die($miodb->ErrorMsg());
echo "Dokument freigegeben!";
}
else
{
$sql = "select state_id from state where state like 'nicht freigegeben'";
$state = $miodb->Execute($sql);
if($state == false) die($miodb->ErrorMsg());
$state_id = $state->fields['state_id'];
$sql = "update metadata set state_id='".$state_id."' where metadata_id=".$id;
$result = $miodb->Execute($sql);
if($result == false) die($miodb->ErrorMsg());
echo "Überarbeitung des Dokuments nötig! Bitte Mitteilung an den Autor senden!";
}
}
else
{
echo "access failed!";
}
// bearbeitetes Dokument entsperren
$sql = "update metadata set metadata.lock=0 where metadata_id=".$id;
$result = $miodb->Execute($sql);
if($result == false) die($miodb->ErrorMsg());
// Einbinden des Footers
require("footer.php");
?>
12. get_metadata.php

CMS für die MIO-Lernumgebung Anhang D
// Haupttitel
echo "Haupttitel: fields['title']."\" size=\"75\"
maxlength=\"200\" style=\"background-color: #dddddc; font-family:Verdana\">";
echo "";
// Autor
$sql_author = "select persons_id,concat(person_name,' ',person_firstname) as author from persons";
$authors = $miodb->Execute($sql_author);
if($authors == false) die($miodb->ErrorMsg());
echo "Autor: ";
while (!$authors->EOF)
{
if ($authors->fields['author'] == $result->fields['author'])
{
echo "fields['persons_id'] . "\">" . $authors->fields['author'] . "";
}
else
{
echo "fields['persons_id'] . "\">" . $authors->fields['author'] . "";
}
$authors->MoveNext();
}
echo "";
echo "";
// Thema
$sql_theme = "select themes_id,theme from themes";
$themes = $miodb->Execute($sql_theme);
if($themes == false) die($miodb->ErrorMsg());
echo "Thema: ";
while (!$themes->EOF)
{
if ($themes->fields['theme'] == $result->fields['theme'])
{
echo "fields['themes_id'] . "\">" . $themes->fields['theme'] . "";
}
else
{
echo "fields['themes_id'] . "\">" . $themes->fields['theme'] . "";
}
$themes->MoveNext();
}
echo "";
echo "";
// Version
echo "Version: fields['version']."\"
size=\"5\" maxlength=\"5\" style=\"background-color: #dddddc; font-family:Verdana\"> (nicht editierbar)";
echo "";
// Status
$sql_state = "select state_id,state from state";
$states = $miodb->Execute($sql_state);
if($states == false) die($miodb->ErrorMsg());
echo "Status: ";
while (!$states->EOF)
{
if ($states->fields['state'] == $result->fields['state'])
{
echo "fields['state_id'] . "\">" . $states->fields['state'] . "";
}
else
{
echo "fields['state_id'] . "\">" . $states->fields['state'] . "";
}
$states->MoveNext();
}
echo "";
echo "";
// Erstellungsdatum
echo "Erstellungsdatum: fields['date']."\"
size=\"10\" maxlength=\"10\" style=\"background-color: #dddddc; font-family:Verdana\"> (nicht editierbar)";
echo "";
// Gruppe mit Leserechten
$sql_group = "select groups_id,groupname from groups";
$groups = $miodb->Execute($sql_group);
if($groups == false) die($miodb->ErrorMsg());
echo "Gruppe mit Prüfrechten: ";
while (!$groups->EOF)
{
if ($groups->fields['groups_id'] == $result->fields['check_group_id'])
{
echo "fields['groups_id'] . "\">" . $groups->fields['groupname'] . "";
}
else
{
echo "fields['groups_id'] . "\">" . $groups->fields['groupname'] . "";
}
$groups->MoveNext();
130

CMS für die MIO-Lernumgebung Anhang D
}
echo "";
echo "";
// Gruppe mit Schreibrechten
$sql_group = "select groups_id,groupname from groups";
$groups = $miodb->Execute($sql_group);
if($groups == false) die($miodb->ErrorMsg());
echo "Gruppe mit Schreibrechten: ";
while (!$groups->EOF)
{
if ($groups->fields['groups_id'] == $result->fields['edit_group_id'])
{
echo "fields['groups_id'] . "\">" . $groups->fields['groupname'] . "";
}
else
{
echo "fields['groups_id'] . "\">" . $groups->fields['groupname'] . "";
}
$groups->MoveNext();
}
echo "";
echo "";
// Klasse zu welcher lehrtext gehört
$sql_class = "select classes_id,classname from classes";
$classes = $miodb->Execute($sql_class);
if($classes == false) die($miodb->ErrorMsg());
echo "Klasse: ";
while (!$classes->EOF)
{
if ($classes->fields['classes_id'] == $result->fields['class_id'])
{
echo "fields['classes_id'] . "\">" . $classes->fields['classname'] .
"";
}
else
{
echo "fields['classes_id'] . "\">" . $classes->fields['classname'] . "";
}
$classes->MoveNext();
}
echo "";
echo "";
echo "";
echo "";
echo "";
echo "";
echo "";
// Einbinden des Footers
require("footer.php");
?>
13. set_metadata.php

CMS für die MIO-Lernumgebung Anhang D
// Einbinden des Footers
require("footer.php");
?>
14. edit_xml.php
Execute($sql);
if($result == false) die($miodb->ErrorMsg());
$author = $result->fields["person_name"]." ". $result->fields["person_firstname"];
}
// Dekodieren der URL-codierten Variable
$post_string = urldecode($_POST['post_string']);
// Zerlegen von $post_string und speichern der Stücke im Array $vars
$vars = explode('&',$post_string);
$x = count($vars);
// Button "Thema wählen" gedrückt
elseif (isset($_POST['select_theme']))
{
select_theme();
exit;
}
elseif (!empty($_POST['new_theme']))
{
if (!empty($_POST['new_comment']))
132

CMS für die MIO-Lernumgebung Anhang D
}
{
$comment = $_POST['new_comment'];
}
else
{
$comment = "";
}
$theme = $_POST['new_theme'];
// neues Thema in DB speichern
$sql = "insert into themes values ('','".$comment."','".$theme."')";
$result = $miodb->Execute($sql);
if($result == false) die($miodb->ErrorMsg());
// Herausfinden der theme_id des neu gespeicherten Themas
$sql = "select max(themes_id) as themes_id from themes";
$result = $miodb->Execute($sql);
if($result == false) die($miodb->ErrorMsg());
$themes_id = $result->fields["themes_id"];
// Dekodieren der URL-codierten Variable
$post_string = urldecode($_POST['post_string']);
// Zerlegen von $post_string und speichern der Stücke im Array $vars
$vars = explode('&',$post_string);
$x = count($vars);
//Thema gewählt, Aufruf von edit_xml.php durch Funktion select_theme()
elseif (isset($_POST['selected_theme']))
{
$themes_id = $_POST['selected_theme'];
}
// der themes_id zugehöriges Thema herausfinden
$sql = "select theme from themes where themes_id=".$_POST['selected_theme']." order by theme";
$result = $miodb->Execute($sql);
if($result == false) die($miodb->ErrorMsg());
$theme = $result->fields["theme"];
// Dekodieren der URL-codierten Variable
$post_string = urldecode($_POST['post_string']);
// Zerlegen von $post_string und speichern der Stücke im Array $vars
$vars = explode('&',$post_string);
$x = count($vars);
// Button "Link/Bild einfügen" gedrückt
elseif (isset($_POST['insert_link']))
{
insert_link();
exit;
}
//Link gewählt, Aufruf von edit_xml.php durch Funktion insert_link()
elseif (!empty($_POST['link_form']))
{
// Dekodieren der URL-codierten Variable
$post_string = urldecode($_POST['post_string']);
// Zerlegen von $post_string und speichern der Stücke im Array $vars
$vars = explode('&',$post_string);
$x = count($vars);
//Position des Feldes herausfinden, in welches der Link eingefügt werden soll
for($i=0;$iExecute($sql);
if($result == false) die($miodb->ErrorMsg());
$author = $result->fields["person_name"]." ". $result->fields["person_firstname"];
// Link-String kreieren, der in Textarea eingefügt wird
$link = "fields["persons_id"] . "\">" .
$result->fields["username"] . "";
}
//Link zu Element einfügen
$sql_type = "select type_id, type from type";
$type = $miodb->Execute($sql_type);
while (!$type->EOF)
{
// die von insert_link() überlieferte Variable heisst z.B. für den Typ Zitat: "link_element_zitat"
$link_element = "link_element_".$type->fields['type'];
if (!empty($_POST[$link_element]))
{
133

CMS für die MIO-Lernumgebung Anhang D
$link_type = $type->fields['type'];
$link_element = $_POST[$link_element];
$sql = "select title from elements where elements_id=".$link_element;
$result = $miodb->Execute($sql);
if($result == false) die($miodb->ErrorMsg());
$link = "" . $result-
>fields["title"] . "";
break;
}
}
}
$type->MoveNext();
//Link zu Email-Adresse einfügen
if (!empty($_POST['link_mail']))
{
$mail = $_POST['link_mail'];
$link = "" . $mail ."";
}
//WWW-Link einfügen
if (!empty($_POST['www_link']))
{
$mail = $_POST['www_link'];
$link = "" . $mail ."";
}
//Link zu Bild einfügen
elseif (!empty($_POST['image']))
{
// Bilder sind im Verzeichnis "../files/images" gespeichert
$img = "./../files/images/". urldecode($_POST['image']);
$image = "";
}
// Dekodieren der URL-codierten Variable
$post_string = urldecode($_POST['post_string']);
// Zerlegen von $post_string und speichern der Stücke im Array $vars
$vars = explode('&',$post_string);
$x = count($vars);
// Button "Löschen" gedrückt
elseif (isset($_POST['delete_field']))
{
while(list($key, $val) = each($_POST))
{
$key = stripslashes($key);
$val = stripslashes($val);
$val = preg_replace("/\015/","",$val);
$val = preg_replace("/\015/","",$val);
$val = preg_replace("//","",$val);
}
@$post_string .= "$key=$val&";
// Zerlegen von $post_string und speichern der Stücke im Array $vars
$vars = explode('&',$post_string);
// das gesuchte Arrayfeld steht ein Feld vor dem Eintrag "delete_field=löschen"
$array_field_to_delete = array_search("delete_field=löschen", $vars)-1;
$i = $array_field_to_delete;
do {
$vars[$i] = $vars[$i+1];
$i++;
}
while ($i+1 < count($vars));
// die ersten 6 felder nicht löschbar (title,author,author_id,theme,theme_id,class_id), weil aber array bei 0 und nicht
bei 1 beginnt, müssen nur 5 feld-Nummern abgezogen werden
$field_no_to_delete = $array_field_to_delete-5;
}
$x = count($vars);
// Button "Textarea einfügen" gedrückt
elseif (isset($_POST['insert_textarea']))
{
while(list($key, $val) = each($_POST))
{
$key = stripslashes($key);
$val = stripslashes($val);
$val = preg_replace("/\015/","",$val);
$val = preg_replace("/\015/","",$val);
$val = preg_replace("//","",$val);
}
@$post_string .= "$key=$val&";
// Zerlegen von $post_string und speichern der Stücke im Array $vars
$vars = explode('&',$post_string);
//Felder title,author,author_id,theme,theme_id,class_id (weil diese ausserhalb des "content"-Bereichs liegen) + Insert-
Button = 7 abziehen
$post_string .= "textarea_no_".(count($vars)-7)."=";
// Zerlegen von $post_string und speichern der Stücke im Array $vars
$vars = explode('&',$post_string);
134

CMS für die MIO-Lernumgebung Anhang D
}
$x = count($vars);
// Button "Untertitel1 einfügen" gedrückt
elseif (isset($_POST['insert_subtitle']))
{
while(list($key, $val) = each($_POST))
{
$key = stripslashes($key);
$val = stripslashes($val);
$val = preg_replace("/\015/","",$val);
$val = preg_replace("/\015/","",$val);
$val = preg_replace("//","",$val);
}
@$post_string .= "$key=$val&";
// Zerlegen von $post_string und speichern der Stücke im Array $vars
$vars = explode('&',$post_string);
//Felder title,author,author_id,theme,theme_id,class_id (weil diese ausserhalb des "content"-Bereichs liegen) + Insert-
Button = 7 abziehen
$post_string .= "subtitle_no_".(count($vars)-7)."=";
}
// Zerlegen von $post_string und speichern der Stücke im Array $vars
$vars = explode('&',$post_string);
$x = count($vars);
// Button "Untertitel2 einfügen" gedrückt
elseif (isset($_POST['insert_sub_subtitle']))
{
while(list($key, $val) = each($_POST))
{
$key = stripslashes($key);
$val = stripslashes($val);
$val = preg_replace("/\015/","",$val);
$val = preg_replace("/\015/","",$val);
$val = preg_replace("//","",$val);
}
@$post_string .= "$key=$val&";
// Zerlegen von $post_string und speichern der Stücke im Array $vars
$vars = explode('&',$post_string);
//Felder title,author,author_id,theme,theme_id,class_id (weil diese ausserhalb des "content"-Bereichs liegen) + Insert-
Button = 7 abziehen
$post_string .= "sub_subtitle_no_".(count($vars)-7)."=";
}
// Zerlegen von $post_string und speichern der Stücke im Array $vars
$vars = explode('&',$post_string);
$x = count($vars);
// Variable, welche die id-nr der Elemente des "Content"-Bereichs festlegt
$element_count = 1;
// Variable, welche den Content für die Datenbank speichert, die Felder maintitle,author,theme werden in der DB separat
gespeichert (Metadaten)
$content = "";
// in der folgenden for-Schleife wird ein xml-String erstellt
for($i=0;$i

CMS für die MIO-Lernumgebung Anhang D
}
case "theme":
$xml_str .= "" . $item[1] . "";
// für DB
$author_id = $item[1];
break;
// falls neues Thema,Kommentar eingegeben oder ein Thema gewählt
if ((!empty($_POST['new_theme'])) | isset($_POST['selected_theme']))
{
$xml_str .= "" . $theme . "";
break;
}
else
{
$xml_str .= "" . $item[1] . "";
}
// für DB
$theme = $item[1];
break;
case "theme_id":
// falls neues Thema,Kommentar eingegeben oder ein Thema gewählt
if ((!empty($_POST['new_theme'])) | isset($_POST['selected_theme']))
{
$xml_str .= "" . $themes_id . "";
break;
}
else
{
$xml_str .= "" . $item[1] . "";
}
// für DB
$themes_id = $item[1];
break;
case "class_id":
$xml_str .= "" . $item[1] . "";
// für DB
$class_id = $item[1];
break;
case "subtitle_no_".$element_count:
// falls Feld-Nr eines zu löschenden Feldes gegeben und Element-counter entsprechendes schon erreicht,
// wird das zu löschende Feld mit demjenigen zur Rechten überschrieben und alle nachfolgenden Felder eine Position
nach links verschoben
if (isset($field_no_to_delete) && ($element_count > $field_no_to_delete))
{
$shift_fields_left=1;
}
else
{
$shift_fields_left=0;
}
$xml_str .= "" . $item[1] . "";
$content .= "" . $item[1] . "";
$element_count++;
break;
case "sub_subtitle_no_".$element_count:
// falls Feld-Nr eines zu löschenden Feldes gegeben und Element-counter entsprechendes schon erreicht,
// wird das zu löschende Feld mit demjenigen zur Rechten überschrieben und alle nachfolgenden Felder eine Position
nach links verschoben
if (isset($field_no_to_delete) && ($element_count > $field_no_to_delete))
{
$shift_fields_left=1;
}
else
{
$shift_fields_left=0;
}
$xml_str .= "" . $item[1] . "";
$content .= "" . $item[1] . "";
$element_count++;
break;
case "textarea_no_".$element_count:
// die vor der switch-Anweisung irrtümlich geteilten Stücke (falls im Text der Textarea "="-Zeichen vorkommen)
werden wieder zusammengefügt
$text = $item[1];
for ($j=2;$j $field_no_to_delete))
136

CMS für die MIO-Lernumgebung Anhang D
{
$shift_fields_left=1;
}
else
{
$shift_fields_left=0;
}
// falls ein Link eingefügt werden soll und die Feldposition stimmt
if (!empty($link) && $element_count == $field_pos)
{
$xml_str .= "" . $hr_xml . $link . "";
$content .= "" . $hr_xml . $link . "";
$element_count++;
break;
}
// falls ein Bild eingefügt werden soll und die Feldposition stimmt
elseif (!empty($image) && $element_count == $field_pos)
{
$xml_str .= "" . $hr_xml . $image . "";
$content .= "" . $hr_xml . $image . "";
$element_count++;
break;
}
else
{
$xml_str .= "" . $hr_xml . "";
$content .= "" . $hr_xml . "";
$element_count++;
break;
}
case "delete_field":
// falls der Zeiger auf das zu löschende Feld zeigt, wird nur der Counter erhöht und beim nächsten switch-
Durchgang das nachfolgende Feld an die aktuelle Position geschrieben
$element_count++;
break;
}
}
// Ergänzen der xml-Strings
$content .= "";
$xml_str = "" . $xml_str . "";
// String-Bildung vom Inhalt der DTD-Datei
$content_dtd = implode('', file('content.dtd'));
// falls Button "Version erstellen" gedrückt, wird der xml-String als Ausgabe (template:content.xsl) gespeichert und das
Dokument in die DB eingetragen
// sonst wird nur der xml-String als Formular (template:content_form.xsl) gespeichert
if (isset($_POST['new_version']))
{
$sql = "select metadata_id, version, metadata.state_id, state.state_id, state.state, class_id, edit_group_id,
check_group_id from metadata,state where title='". $maintitle."' and persons_id=". $author_id." and themes_id=". $themes_id."
and metadata.state_id=state.state_id and not (state like 'veraltet')";
$result = $miodb->Execute($sql);
$id = $result->fields['metadata_id'];
if(!$result == false && !$result->EOF)
{
// die Werte von check_group_id und edit_group_id werden von der alten Version übernommen
$check_group_id = $result->fields['check_group_id'];
$edit_group_id = $result->fields['edit_group_id'];
// falls eine ältere Version des aktuellen Dokuments existiert, wird die Versions-Nr um eins erhöht
@$version = ($result->fields['version'])+1;
// das ältere Dokument erhält den Status "veraltet"
$sql = "select state_id from state where state like 'veraltet'";
$state = $miodb->Execute($sql);
if($result == false) die($miodb->ErrorMsg());
$sql = "update metadata set metadata.state_id=".$state->fields['state_id']." where metadata_id=".$id;
$result = $miodb->Execute($sql);
if($result == false) die($miodb->ErrorMsg());
// das ältere Dokument wird entsperrt
$sql = "update metadata set metadata.lock=0 where metadata_id=".$id;
$result = $miodb->Execute($sql);
if($result == false) die($miodb->ErrorMsg());
}
else
{
// Standardwert für check_group_id und edit_group_id ist die Studienleitung der spezifischen Klasse
$sql = "select groups.groups_id as groups_id from groups,classes_groups where
classes_groups.classes_id=".$class_id." and classes_groups.groups_id=groups.groups_id and groups.groupname like
'Studienleitung'";
$result = $miodb->Execute($sql);
if($result == false) die($miodb->ErrorMsg());
}
if (!$result->EOF)
{
$check_group_id = $result->fields['groups_id'];
$edit_group_id = $result->fields['groups_id'];
}
else
{
$check_group_id = 1;
$edit_group_id = 1;
}
@$version=1;
137

CMS für die MIO-Lernumgebung Anhang D
// Ergänzen des xml-Strings
$xml_str = "" . $xml_str;
// aktuelles Datum
$today = date("Y-m-d");
$sql = "select state_id from state where state like 'zu prüfen'";
$result = $miodb->Execute($sql);
if($result == false) die($miodb->ErrorMsg());
$standard_state = $result->fields['state_id'];
// Schreiben des neuen Dokuments in die DB mit Status "zu prüfen"
$result_metadata = $miodb->Execute("insert into metadata values ('','".$maintitle."','".
$author_id."','".$themes_id."','','" . $version."','" .$standard_state."','" . $today."','','" .$edit_group_id."','".
$check_group_id."','".$class_id."')");
if($result_metadata == false) die($miodb->ErrorMsg());
}
// Herausfinden der metadata_id der neu gespeicherten Metadaten
$max_id = $miodb->Execute("select max(metadata_id) as metadata_id from metadata");
if($max_id == false) die($miodb->ErrorMsg());
$metadata_id = $max_id->fields['metadata_id'];
$result_content = $miodb->Execute("insert into content values ('','".$content."','".$metadata_id."')");
if($result_content == false) die($miodb->ErrorMsg());
$args = array('/_xml' => $xml_str);
// XSLT-Prozessor
$x = xslt_create();
// Transformation des XML-Strings mit XSL-Stylesheet content_form.xsl
$result = xslt_process($x, 'arg:/_xml', 'content.xsl', NULL, $args);
if ($result)
{
// Anzeige im Browser als Formular
echo $result;
}
else
{
echo xslt_error($x);
}
xslt_free($x);
else
{
// Ergänzen des xml-Strings
$xml_str = " " . $xml_str;
$args = array('/_xml' => $xml_str);
// XSLT-Prozessor
$x = xslt_create();
// Transformation des XML-Strings mit XSL-Stylesheet content.xsl
$result = xslt_process($x, 'arg:/_xml', 'content_form.xsl', NULL, $args);
if ($result)
{
// Anzeige im Browser
echo $result;
// nach Bearbeitung des Templates wird nach unten zum letzten Feld gescrollt (diese Anweisung ist nur mit einer
Browser-basierten Skriptsprache möglich)
echo "";
echo "{";
echo "window.scrollTo(0,10000000);";
echo "}";
echo "";
}
else
{
echo xslt_error($x);
}
}
}
xslt_free($x);
// Folgende Funktionen werden je nach Inhalt der $_POST-Variablen am Anfang der main()-Funktion aufgerufen
// nach Abarbeiten des jeweiligen Funktions-codes wird durch submit-Aktion das Formular abgeschickt
// da im Formular-Kopf kein "action"-Attribut angegeben ist, wird nach der submit-Aktion edit_xml.php erneut aufgerufen
function select_author()
{
// in dieser Funktion wird ein Auswahlfeld mit den vorhandenen Autoren generiert
// globale Variablen müssen innerhalb von Funktionen als solche definiert werden
global $miodb;
while(list($key, $val) = each($_POST))
{
$key = urlencode(stripslashes($key));
$val = preg_replace("/\015/","",$val);
$val = preg_replace("/\015/","",$val);
$val = preg_replace("//","",$val);
$val = urlencode(stripslashes($val));
138

CMS für die MIO-Lernumgebung Anhang D
}
@$post_string .= "$key=$val&";
$result = $miodb->Execute("select persons_id,username,person_firstname,person_name from persons order by
person_name,person_firstname");
if($result == false) die($miodb->ErrorMsg());
echo "";
echo "Autor/in w&auml;hlen:";
echo "";
echo "";
echo "";
while (!$result->EOF)
{
echo "fields["persons_id"] . "\">" . $result->fields["username"] .", ".$result-
>fields["person_name"] .", " .$result->fields["person_firstname"] ."";
}
$result->MoveNext();
echo "";
echo "";
echo "";
echo "";
echo "";
}
function select_theme()
{
// in dieser Funktion wird ein Auswahlfeld mit den vorhandenen Themen generiert
// ausserdem werden Felder generiert, mit welchen neue Themen eingegeben werden können
// globale Variablen müssen innerhalb von Funktionen als solche definiert werden
global $miodb;
while(list($key, $val) = each($_POST))
{
$key = urlencode(stripslashes($key));
$val = preg_replace("/\015/","",$val);
$val = preg_replace("/\015/","",$val);
$val = preg_replace("//","",$val);
$val = urlencode(stripslashes($val));
}
@$post_string .= "$key=$val&";
$result = $miodb->Execute("select themes_id,comment,theme from themes order by theme");
if($result == false) die($miodb->ErrorMsg());
echo "";
echo "Vorhandenes Thema w&auml;hlen:";
echo "";
echo "";
echo "";
while (!$result->EOF)
{
if (!empty($result->fields["comment"]))
{
$comment = ", ".$result->fields["comment"];
}
else
{
$comment = "";
}
}
echo "fields["themes_id"] . "\">" .$result->fields["theme"] . $comment . "";
$result->MoveNext();
echo "";
echo "";
echo "";
echo "";
echo "Neues Thema eingeben:";
echo "";
echo "Kommentar:";
echo "";
echo "";
echo "";
echo "Thema:";
echo "";
echo" ";
echo "";
echo "";
echo "";
echo "";
echo "";
139

CMS für die MIO-Lernumgebung Anhang D
echo "";
}
function insert_link()
{
// in dieser Funktion werden Auswahlfeld mit den vorhandenen Personen,Elementen und Bilder generiert
// ausserdem wird ein Feld generiert, mit welchem eine Email-Adresse eingefügt werden kann
// die Auswahl wird anschliessend als Link-Tag in die Textarea eingefügt
// globale Variablen müssen innerhalb von Funktionen als solche definiert werden
global $miodb;
while(list($key, $val) = each($_POST))
{
$key = urlencode(stripslashes($key));
$val = preg_replace("/\015/","",$val);
$val = preg_replace("/\015/","",$val);
$val = preg_replace("//","",$val);
}
$val = urlencode(stripslashes($val));
@$post_string .= "$key=$val&";
$result = $miodb->Execute("select persons_id,username,signs_id,concat(person_name,' ',person_firstname) as person from persons
order by person");
if($result == false) die($miodb->ErrorMsg());
echo "";
echo "";
echo "";
// Link zu Person einfügen
echo "Link zu Person einf&uuml;gen:";
echo "";
echo "";
echo "";
while (!$result->EOF)
{
echo "fields["persons_id"] . "\">" . $result->fields["username"].", ".$result-
>fields["person"]. "";
}
$result->MoveNext();
echo "";
echo "";
echo "";
// Link zu Email-Adresse einfügen
echo "Link zu Email-Adresse einf&uuml;gen:";
echo "";
echo "(z.B. hans.muster@muster.com)";
echo "";
//WWW-Link einfügen
echo "WWW-Link einf&uuml;gen:";
echo "";
echo "(z.B. http://www.muster.com)";
echo "";
$sql_type = "select type_id, type from type";
$type = $miodb->Execute($sql_type);
$sql ="select elements_id,elements.type_id as type_id,type, persons_id, groups_id, title,text,forplenum, version, timestamp
from elements, type where elements.type_id=type.type_id";
$result = $miodb->Execute($sql);
if($result == false) die($miodb->ErrorMsg());
// Link zu Element einfügen
while (!$type->EOF)
{
echo "Link zu ".$type->fields['type']." einf&uuml;gen:";
echo "fields['type']."\">";
echo "";
echo "";
while (!$result->EOF)
{
if ($result->fields['type_id'] == $type->fields['type_id'])
{
echo "fields['elements_id'] . "\">" . $result->fields['title']."";
}
}
$result->MoveNext();
$result->MoveFirst();
echo "";
echo "";
$type->MoveNext();
}
echo "";
140

CMS für die MIO-Lernumgebung Anhang D
echo "Bild einf&uuml;gen:";
echo "";
echo "";
// Bilder sind im Verzeichnis ./../files/images gespeichert
$handle = opendir('./../files/images');
while ($file = readdir ($handle))
{
if ($file != "." && $file != "..")
{
echo "".$file."";
}
}
closedir($handle);
echo "";
echo "";
echo "";
echo "";
echo "";
echo "";
echo "";
}
// Einbinden des Footers
require("footer.php");
?>
15. content.xsl
Autor/in:
Thema:
141

CMS für die MIO-Lernumgebung Anhang D
16. content_form.xsl
Haupttitel:
Autor/in:
Thema:
&#160;
&#160;
&#160;
Untertitel1:
subtitle_
Untertitel2:
sub_subtitle_
142

CMS für die MIO-Lernumgebung Anhang D
Textarea: textarea_
17. content.dtd
18. Bedienungsanleitung_CMS.html
Bedienungsanleitung CMS
143

CMS für die MIO-Lernumgebung Anhang D
Bedienungsanleitung
für das Content Management System der MIO-Lernumgebung
Inhaltsverzeichnis
1. Einführung
2. Bedienung
2.1. Hauptfenster
2.2. Funktionen
2.2.1. Funktion Ansicht
2.2.2. Funktion Erstellen
2.2.3. Funktion Editieren
2.2.4. Funktion Prüfen
2.2.5. Metadaten verwalten
2.2.6. Archiv
1. Einführung
Was ist das Content Management System (CMS)?
Das CMS unterstützt die Verfasser von Lehrtexten (folgend Dokument genannt) für die
MIO-Lernumgebung bei ihrer Arbeit.
Die Eingabe der Lehrtexte erfolgt über ein Formular, welches dynamisch durch den Verfasser
verändert werden kann und so eine flexible Umgebung zur Verfügung stellt.
Die Lehrtexte können ähnlich wie in einer Textverarbeitung manipuliert und zusätzlich
durch eine Auswahl an HTML-Tags ergänzt werden.
Was braucht man zur Nutzung?
Je nach vorhandenen Benutzerrechten ist die Auswahl der editierbaren Texte mehr oder
weniger eingeschränkt.
Über den Menüpunkt "CMS" in der Menüleiste der MIO-Lernumgebung kann auf das
System zugegriffen werden.
2. Bedienung
2.1. Hauptfenster
Nach dem Start des CMS präsentiert sich die Hauptseite als ein in zwei Frames
aufgeteiltes Fenster, von welchen der obere die Navigations- und der untere den
Contentbereich beinhaltet. Im Contentbereich wird jeweils der gewünschte Inhalt angezeigt.
Abb.: Hauptfenster
2.2. Funktionen
Die Menüleiste des Navigationsbereichs beinhaltet die Funktionen Ansicht, Erstellen,
Editieren, Prüfen von Content, Verwalten der Metadaten und Archiv-Ansicht.
Im Folgenden werden diese Funktionen erklärt.
2.2.1. Funktion Ansicht
Über die Ansicht können die aktuellen Versionen der Dokumente angeschaut werden, sofern
die benötigten Rechte vorhanden sind.
Das Anwählen des "Ansicht"-Links öffnet ein Auswahlfenster mit den vorhandenen
Klassen. Nach Auswahl der gewünschten Klasse und der anschliessenden Bestätigung über
den "ok"-Knopf öffnet sich ein weiteres Auswahlfenster, welches die aktuellen Versionen
der Dokumente zu dieser Klasse auflistet. Jede Zeile enthält Titel, Autor, Thema, Version
und Erstellungsdatum des jeweiligen Dokuments.
Ist eine Wahl getroffen, wird nach Betätigung des "ok"-Knopfs das gewünschte
Dokument angezeigt.
Abb.: Ansicht
2.2.2. Funktion Erstellen
Das Erstellen eines neuen Dokuments wird über den Menüpunkt "Erstellen"
ermöglicht. Die Eingabe erfolgt in einem Standard-Formular, in welchem die drei Felder
"Haupttitel", "Autor" und "Thema" vorgegeben sind.
Abb.: Erstellen
Die Einträge dieser Felder sind Pflicht, wobei die direkte Eingabe gesperrt ist. Durch
Betätigung der Knöpfe "Autor wählen" resp. "Thema wählen" werden Auswahlfelder
angezeigt. Diese beinhalten die vorhandenen Einträge für die Felder "Autor" und "Thema".
Zusätzlich zur Wahl vorhandener Themen können neue Themen aufgenommen und über den
"Speichern"-Knopf in die Datenbank geschrieben werden. Ein neuer Autor muss über
die Lernumgebung eingegeben werden.
Abb.: Thema wählen
Nach Bestätigung über den "ok"-Knopf wird die Wahl in das entsprechende Feld
übernommen.
Im Formular besteht die Möglichkeit, weitere Felder zu den vorhandenen hinzuzufügen:
Untertitel1 (Untertitel der Grösse 1, fett),
Untertitel2 (Untertitel der Grösse 2) und
144

CMS für die MIO-Lernumgebung Anhang D
Textarea
Diese zusätzlichen Felder können in beliebiger Anzahl und Reihenfolge eingefügt werden.
Jedes Feld kann jederzeit durch den nebenstehenden Knopf "Löschen" wieder entfernt
werden, wobei die Eingaben im entsprechenden Feld verloren gehen.
Wurde ein "Löschen"-Knopf versehentlich betätigt, besteht die Möglichkeit, über den
"Zurück"-Knopf des Browsers, die Änderung rückgängig zu machen.
Abb.: Untertitel1, Untertitel2 und Textarea
Erklärungen zum Feld Textarea:
Die Eingabe in eine Textarea erfolgt ähnlich wie in einer Textverarbeitung. Das
Betätigen der Enter-Taste bewirkt einen Zeilenumbruch, Leerzeichen und -zeilen können
beliebig eingefügt werden und Umlaute werden als ä, ö und ü und nicht etwa als &uuml; etc.
geschrieben.
W I C H T I G:
Bei Übernahme von Textteilen aus einer anderen Quelle mittels "copy-paste" ist darauf
zu achten, dass Satzzeichen wie "Anführungszeichen" und "Bindestrich" ersetzt, d.h.
direkt über die Tastatur eingegeben werden, da diese teilweise vom XSLT-Prozessor nicht
interpretiert werden können. Dies führt zu einer Fehlermeldung.
"Einfache Anführungszeichen" können aufgrund datenbanktechnischer Gründe nicht verwendet
werden.
Um den Text weiter zu formatieren, können HTML-Tags verwendet werden.
Folgende stehen zur Auswahl:
Tabelle: &lt;table border="?"&gt;&lt;/table&gt; mit den Tags &lt;tr&gt;&lt;/tr&gt;,
&lt;th&gt;&lt;/th&gt; und &lt;td&gt;&lt;/td&gt;
Listen: &lt;ul&gt;&lt;/ul&gt; mit dem Tag &lt;li&gt;&lt;/li&gt;&lt;ol&gt;&lt;/ol&gt;
mit dem Tag &lt;li&gt;&lt;/li&gt;
Fett: &lt;b&gt;&lt;/b&gt;
Kursiv: &lt;i&gt;&lt;/i&gt;
Unterstrichen: &lt;u&gt;&lt;/u&gt;
Trennstrich: &lt;hr&gt;
Umbruch: &lt;br&gt; (wie Enter-Taste)
Alle verwendbaren HTML-Elemente (ausser &lt;hr&gt; und &lt;br&gt;) bestehen aus einem
einleitenden und einem abschliessenden Tag.
W I C H T I G:
Die Tags dürfen nur mit den hier angegebenen Attributen verwendet werden! Sie
müssen richtig (d.h. syntaktisch korrekt) eingegeben werden! Ansonsten besteht die Gefahr,
dass die Übersetzung des XML-Strings fehlschlägt und das Dokument fehlerhaft oder gar
nicht angezeigt wird. In diesem Fall gibt der XML-Parser eine Fehlermeldung aus:
Abb.: Syntaktisch unkorrekte Tag-Eingabe
Dem Benutzer muss bewusst sein, dass sich der Text in den Textfeldern wie in der
Textverarbeitung verhält, d.h. jeder Zeilenumbruch nach einem HTML-Tag wird auch als
solcher vom XML-Parser interpretiert und angezeigt.
Der Editier-Modus lässt in Textfeldern die Tags von Tabellen und Listen jeweils eingerückt
und mit Zeilenumbrüchen darstellen (systembedingt).
Abb.: Eingerückte Listen- und Tabellen-Tags in der Textarea
Über den Knopf "Link/Bild einfügen" können Link-Tags eingefügt werden. Zuerst
öffnet sich ein Fenster mit folgenden Auswahlfeldern:
Link zu Person einfügen:
Link zu Mikroartikel einfügen:
Link zu Autor einfügen:
Link zu Literaturquelle einfügen:
Link zu Zitat einfügen:
Link zu Rezension einfügen:
Link zu Link einfügen:
Link zu Buch einfügen:
Link zu Teilnehmer einfügen:
Link zu Mentoren einfügen:
Link zu Referenten einfügen:
Bild einfügen:
Zusätzlich ist ein Eingabefeld für einen E-Mail-Adressen-Link und eines für
einen WWW-Link vorhanden:
Link zu E-Mail-Adresse einfügen:
(z.B. hans.muster@muster.com)
WWW-Link einfügen:
(z.B. http://www.muster.com)
145

CMS für die MIO-Lernumgebung Anhang D
Abb.: Link/Bild einfügen
Die Inhalte dieser Auswahlfelder müssen über die Lernumgebung eingegeben werden.
Die Auswahl aus einem der Auswahlfelder muss mit Betätigung des entsprechenden
"ok"-Knopfs bestätigt werden.
Links wird am Ende des Textfeldes eingefügt und nicht etwa dort, wo der Cursor steht.
Es kann gleichzeitig nur ein Link übertragen werden. Deshalb muss darauf geachtet werden,
dass nur im gewünschten Feld ein Eintrag ausgewählt wird und die übrigen Felder leer
bleiben. Dieser Vorgang kann beliebig oft wiederholt werden.
Abb.: Textarea-Eintrag
Um fehlerhafte Syntax zu vermeiden, sollten die in der Textarea eingefügten Link-Tags
nicht mehr verändert werden.
Das System erlaubt, die Link-Tags direkt in das Textfeld einzugeben. Aufgrund des Risikos
einer falschen Verlinkung (falsche Zielangabe oder unkorrekte Syntax der Tags) ist dies
aber i.a. nicht zu empfehlen.
Ist ein Link-Tag im Text nicht mehr erwünscht, kann es wie normaler Text gelöscht werden.
Dabei sollte darauf geachtet werden, dass das End-Tag (z.B. "", erkennbar durch den
vorangestellten Schrägstrich im Tag) mitgelöscht wird.
Sind alle Einträge gemacht, wird das Dokument über den Knopf "Version erstellen"
gespeichert und angezeigt.
Abb.: Ausgabe
Falls ein Dokument mit den gleichen Angaben in den Feldern "Haupttitel", "Autor" und
"Thema" schon in der Datenbank vorhanden ist, wird es durch das aktuelle nicht
überschrieben, sondern als neue Version abgespeichert. Ansonsten wird eine Version 1
erstellt.
Die neue Version erhält automatisch den Vermerk "zu prüfen".
Jedes Betätigen eines Knopfs bewirkt, dass die aktuelle Seite neu übersetzt und wieder
angezeigt wird. Schlägt die Transformation fehl (z.B. aufgrund der Verwendung fehlerhafter
Tags), wird die neu übersetzte Seite fehlerhaft oder gar nicht angezeigt.
Durch Betätigung des "Zurück"-Knopfs des Browsers kann die Aktion rückgängig
gemacht und die Ursache des Fehlschlagens eruiert werden. Nachdem der Fehler korrigiert
wurde, kann die gewünschte Aktion erneut ausgeführt werden.
2.2.3. Funktion Editieren
Schon erstellte Dokumente können über den Menüpunkt "Editieren" neu bearbeitet
werden. Nachdem zuerst wiederum die gewünschte Klasse ausgewählt wurde, werden
im Auswahlfenster alle aktuellen Dokumente aufgelistet Jede Zeile enthält Titel, Autor,
Thema, Version und Erstellungsdatum des jeweiligen Dokuments. Diejenigen Dokumente, die
gerade von anderen Benutzern bearbeitet werden, erscheinen in der Auswahlliste mit dem
Vermerk "gesperrt" und können zur Zeit nicht editiert werden.
Ist eine Wahl getroffen, wird nach Betätigung des "ok"-Knopfs das gewünschte
Dokument als Formular angezeigt. Gleichzeitig wird es für andere Benutzer gesperrt.
Die Seite des Dokuments beinhaltet die Standardfelder "Haupttitel", "Autor" und "Thema"
mit etwaigen zusätzlich eingefügten Feldern und deren Inhalt, welcher wie gehabt
bearbeitet werden kann.
Für Erklärungen zur Bedienung dieser Seite siehe 2.2.2. Erstellen.
Die Sperrung eines Dokuments für andere wird erst aufgehoben, wenn es vom Benutzer als
neue Version abgespeichert wird. Falls dieser also vor dem Abspeichern ein weiteres
Dokument oder eine Seite ausserhalb des CMS aufrufen würde, müsste er mit dem
"Zurück"-Knopf des Browsers zurückspringen und die Bearbeitung korrekt abschliessen.
Andernfalls bliebe dieses Dokument in der Datenbank als "gesperrt" gekennzeichnet und
könnte nicht mehr editiert werden. In diesem Fall müsste der Administrator benachrichtigt
werden.
2.2.4. Funktion Prüfen
Soll ein erstelltes oder verändertes Dokument veröffentlicht werden, ist es notwendig,
dieses vorher durch kompetente Stellen prüfen zu lassen. Der Prüfer entscheidet, ob das
Dokument freigegeben wird oder nochmals überarbeitet werden muss. In letzterem Fall teilt
er dem Redakteur des Dokuments die notwendigen Änderungen mit.
Nach Auswahl der Klasse stehen in der Auswahlliste diejenigen Dokumente, welche als
"zu prüfen" markiert sind. Wie beim "Editieren" (siehe 2.2.3. Funktion Editieren)
sind diejenigen Dokumente,
die gerade von anderen Benutzern bearbeitet werden, als "gesperrt" gekennzeichnet
und stehen im Moment nicht zur Verfügung.
Nach Betätigung des "ok"-Knopfs wird das gewählte Dokument angezeigt.
Am Ende der Seite kann über eine Radio-Box-Auswahl das Dokument zur Veröffentlichung
freigegeben oder abgelehnt werden. Zur Bestätigung wird der "ok"-Knopf gedrückt.
Abb.: Genehmigen/Ablehnen
146

CMS für die MIO-Lernumgebung Anhang D
2.2.5. Metadaten verwalten
Metadaten sind Informationen über ein Dokument. Sie beschreiben es nach formalen und
inhaltlichen Aspekten. Dazu gehören in unserem Fall:
Haupttitel
Autor
Thema
Version
Status
Erstellungsdatum
Gruppe mit Editierberechtigung
Gruppe mit Leseberechtigung
Diese Angaben können unabhängig vom Content (Inhalt) des Dokuments jederzeit
angeschaut und bearbeitet werden.
Sind die notwendigen Berechtigungen vorhanden, können über die Auswahlliste und
anschliessendes Betätigen des "ok"-Knopfs die Metadaten des gewünschten Dokuments
aufgerufen werden.
Auch hier sind diejenigen Dokumente, die zur Zeit von anderen Benutzern bearbeitet
werden, als "gesperrt" gekennzeichnet und stehen nicht zur Verfügung. Die
Metadaten älterer Versionen der Dokumente können nicht mehr bearbeitet werden.
Das sich öffnende Formular enthält die weiter oben aufgelisteten Informationen über das
gewählte Dokument.
Abb.: Metadaten
Mit dem Manipulieren von Metadaten sollte vorsichtig umgegangen werden. Um Inkonsistenz
zwischen verschiedenen Versionen der Dokumente zu vermeiden, sind die Felder "Version" und
"Erstellungsdatum" schreibgeschützt.
Über den "ok"-Knopf werden die Änderungen zurück in die Datenbank geschrieben.
2.2.6. Archiv
Über den Menüpunkt "Archiv" werden dem Benutzer sämtliche archivierten Versionen der
Dokumente zur Verfügung gestellt.
Die Versionierung dokumentiert die Veränderungen der Dokumente, da diese nach jedem
Editieren als neue Version abgespeichert werden (siehe 2.2.1. Erstellen).
Ist das gewünschte Dokument ausgewählt, wird es nach Betätigen des "ok"-Knopfs
angezeigt.
147