%% LyX 1.1 created this file.  For more info, see http://www.lyx.org/.
%% Do not edit unless you really know what you are doing.
\documentclass[12pt,a4paper,german,fleqn]{report}
\usepackage[T1]{fontenc}
\usepackage[latin1]{inputenc}
\usepackage{babel}
\setcounter{secnumdepth}{3}
\setcounter{tocdepth}{3}
\usepackage{graphics}

\makeatletter


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% LyX specific LaTeX commands.
\providecommand{\LyX}{L\kern-.1667em\lower.25em\hbox{Y}\kern-.125emX\@}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% User specified LaTeX commands.
\usepackage[T1]{fontenc}
\usepackage[latin1]{inputenc}
\usepackage{babel}
\setcounter{secnumdepth}{3}
\setcounter{tocdepth}{3}
\usepackage{graphics}

\makeatletter

\makeatother

\begin{document}


\chapter{Architektur}


\section{Vorgehensweise}

Um die Architektur des Systems zu bestimmen, wird es in mehrere Teile (Subsysteme)
zerlegt. Die Subsysteme bestehen aus einzelnen Modulen, die miteinander in Beziehung
stehen können. Die Beziehungen zwischen den Subsystemen werden über Interfaces
definiert.

Es gibt nun verschiedene Möglichkeiten, das System in Subsysteme zu zerlegen.
Dazu bietet es sich an, von vordefinierten patterns (Mustern) auszugehen, die
jeweils als Vorlagen dienen, das System zu definieren, zu unterteilen und zu
organisieren.

Unsere Vorgehensweise besteht nun darin, zuerst die wichtigsten Use Cases zu
gruppieren. Diese Gruppierungen liefern uns eine Partitionierung der Gesamtfunktionalität
des Systems, sodass in der Entwicklungsphase einzelne Subsysteme möglichst unabhängig
voneinander (Verbindungen zu anderen Subsystemen sind ja über die Interfaces
wohldefiniert) in mehreren Iterationen entwickelt werden können.

Unsere Vorgehensweise bei der Zerteilung in Subsysteme und Module wird von folgenden
Vereinbarungen bestimmt:

\begin{enumerate}
\item Verwendung des Object-Oriented-Pattern
\item Drei Schichten-Modell:

\begin{itemize}
\item User-Interface
\item Business Layer
\item Database
\end{itemize}
\item Verwendung von Java
\item XML wird zur Speicherung von Daten verwendet
\end{enumerate}

\section{Subsysteme}

Ausgehend von den 3 Schichten User-Interface, Business-Layer und Database wird
das System in Subsysteme aufgeteilt, die jeweils wieder aus Modulen bestehen.

Die Interfaces zwischen den Schichten werden weitgehend durch die Module (Klassen)
des Business-Layer bestimmt, sodass der \textbf{Business-Layer eine zentrale
Rolle in der Architektur} einnimmt.

\vspace{0.3cm}
{\par\centering \includegraphics{pic/subsystems.eps} \par}
\vspace{0.3cm}


\subsection{Subsysteme des User-Interface}


\subsubsection*{User-Interface Internetbesuch}


\subsubsection*{User-Interface Verwaltung}

Die Module der Subsysteme des User-Interface sind die Fenster, die im vorigen
Kapitel dargestellt worden sind. Ihre Beziehungen untereinander sind bereits
in den zugehörigen Diagrammen dargestellt worden.

Ihre Beziehungen zu den Subsystemen und Modulen des Business-Layers werden über
Verknüpfungen der OK-, Cancel- etc. Buttons mit den Methoden der Module im Business-Layer
hergestellt. Direkte Beziehungen zu den Modulen der Database sind nicht vorgesehen.

Implementiert werden die Subsysteme des User-Interface als \textbf{Java-Applets}.


\subsection{Subsysteme des Business-Layer}

Die Module der Subsysteme, die zum Business Layer gehören, werden als Klassen
spezifiziert. Die Interfaces der Klassen werden durch ihre Methoden, die Beziehungen
untereinander durch Verweise auf andere Instanzen von den jeweiligen Klassen
hergestellt.

Implementiert werden die Klassen des Business-Layers in \textbf{Java-Servlets}.

Die Kommunikation zu den User-Interfaces erfolgt über die definierten Methoden.
Der Database-Schicht werden XML-Objekt geliefert, umgekehrt bezieht der Business-Layer
seine Daten von der Datenbank in Form von XML-Objekten.


\subsubsection*{Benutzerverwaltung}

\vspace{0.3cm}
{\par\centering \includegraphics{pic/benutzer_verw.eps} \par}
\vspace{0.3cm}

Verknüpfung zur Objektverwaltung: Usergroup-Objectgroup


\subsubsection*{Objektverwaltung}

\vspace{0.3cm}
{\par\centering \includegraphics{pic/objekt_verw.eps} \par}
\vspace{0.3cm}

Verknüpfung zur Museumsverwaltung: PosObject-Showcase


\subsubsection*{Museumsverwaltung}

\vspace{0.3cm}
{\par\centering \includegraphics{pic/museum_verw.eps} \par}
\vspace{0.3cm}


\subsection{Subsysteme der Database-Schicht}


\subsubsection*{Das Database-Interface}

Der Datenaustausch des Database-Interface mit den Subsystemen und Modulen des
Business-Layers erfolgt mittels Austausch von XML-Objekten, die das Database-Interface
in weiterer folge abspeichert.


\section{Durchwanderung der Use Cases in der Architektur}


\subsection{BenutzergruppeErstellen}

Um das Anwendungsfeld der einzelnen Operationen zu verdeutlichen wird teilweise
ein Pseudocode verwendet.

\begin{enumerate}
\item \textit{Verwaltungs UserInterface:} Auswahl: Benutzergruppe erstellen 
\item \textit{Verwaltungs UserInterface:} Eingabe eines Bezeichners f\"{u}r eine
Benutzergruppe 
\item \emph{Usergroup.getInstance(<Bezeichner>)}\\
 Es wird \"{U}berpr\"{u}ft ob es schon eine Benuztergruppe mit dieser Bezeichnung
existiert. Wenn nicht wird null zur\"{u}ckgegeben, ansonsten wird eine Referenz
auf dieses Objekt \"{u}bergeben. 
\item if (usergr ist ungleich null) 

\begin{enumerate}
\item \textit{Verwaltungs UserInterface:} Es wird mitgeteilt, dass diese Gruppe schon
existiert, aber wenn eine Kopie von dieser Usergroup erstellt werden will, soll
ein neuer Bezeichner eingegeben werden. 
\item \label{checkBez} \textit{newUsergr = Usergroup.getInstance(<neuer Bezeichner>)}\\
 Es wird wird \"{u}berpr\"{u}ft ob eine Usergroup mit diesem Bezeichner existiert. 
\item if(newUsergr ist nicht null) 

\begin{enumerate}
\item \textit{Verwaltungs UserInterface:} Erneute Eingabe des Bezeichners. 
\item springe zu Punkt \ref{checkBez}
\end{enumerate}
\item if(newUsergr ist null) 

\begin{enumerate}
\item \textit{newUsergr = new Usergroup(<neuer Bezeichner>)}\\
 Erzeugen eines neuen Objekt von Usergroup 
\item \textit{funct = usergr.functionalities()}\\
 for(i=1 to funct.length())\\


\begin{itemize}
\item \textit{newUsergr.addFunctionality(funct{[}i{]})}\\

\end{itemize}
Alle Funktionalitäten, welche in usergr enthalten sind werden in newUsergr eingetragen. 

\item \textit{ogroups = usergr.opjectgroups()}\\
 for(i=1 to ogroups.length()\\


\begin{itemize}
\item \textit{newUsergr.addObjectgroup(ogroups{[}i{]})}
\end{itemize}
Alle Objektgruppe, welche in usergr enthalten sind, werden in newUsergr eingetragen. 

\item usergr = newUsergr Ab jetzt wird mit der neu erzeugten und mit den Daten der
alten Usergroup geladenen Usergroup weitergearbeitet. 
\item end if 
\end{enumerate}
\item if(usergr ist null) 

\begin{enumerate}
\item \textit{usergr = new Usergroup(<Bezeichner>)}\\
 Ein neues Objekt von Usergroup wird erzeugt und unter usergr abgelegt 
\item end if 
\end{enumerate}
\item end if 
\end{enumerate}
\item \textit{Objectgroup.getAllObjectgroups()}\\
 Es werden alle allgemein vorhandenen Objektgruppen ermittelt. 
\item \textit{Objectgroup.getAllFunctionalities()}\\
 Es werden alle allegemein vorhandenen Funktionalitäten ermittelt. 
\item \textit{usergr.objectgroups()}\\
 Es werden alle beim Usergroup Objekt eigetragenen Objektgruppen ermittelt. 
\item \textit{usergr.functionalities()}\\
 Es werden alle beim Usergroup Objekt eingetragenen Funktionalitäten ermittelt. 
\item \label{eingabe} \textit{Verwaltungs UserInterface:} Alle allgemein vorhandenen
Objektgruppen und Funktionalitäten werden angezeigt und jene welche schon beim
Objekt eingetragen wurden als aktiviert angezeigt. 
\item \textit{Verwaltungs UserInterface:} Es können Objektgruppen und Funktionalitäten
aktiviert und deaktiviert werden. 
\item \textit{Verwaltungs UserInterface:} Auswahl von Objektgruppe speichern. 
\item if(mindesten 1 Funktionalität und mindestens 1 Objektgruppe sind aktiviert) 

\begin{enumerate}
\item \textit{usergr.save()} Die Daten des Usergroup Objekts werden in der Datenbank
abgespeichert. 
\end{enumerate}
\item else 

\begin{enumerate}
\item Gehe zurück zu Punkt \ref{eingabe}. 
\end{enumerate}
\item end if 
\end{enumerate}

\subsection{ObjekteSuchen}

\begin{enumerate}
\item Internetuser startet Applet für ObjekteSuchen im Browser durch Mausklick auf
den entsprechenden Button
\item Internetuser gibt in die Maske Suchbegriff(e) und erweiterte/einfache Suche
ein.
\item Applet übergibt der statischen Suchfunktion searchFor() am Server die Parameter
Suchbegriffe(e) und erweiterte/einfache Suche
\item Suchfunktion durchsucht über das Datenbankinterface die Datenbanken nach entsprechenden
Objekten
\item Datenbankinterface gibt Objekte mit Verweis auf die jeweilige Vitrine zurück
\item Suchfunktion testet gefundene Objekte auf Mehrfachvorkommen und auf Sichtbarkeit
\item Suchfunktion gibt Liste mit gefundenen und geprüften Objekten mit Referenzen
auf die Datenbank an das Applet retour
\item Applet stellt gefundene Objekte in Form einer Liste im Browser dar
\item Internetuser wählt Objekt aus Liste aus
\item Vitrine mit Objekt wird in Datenbank dargestellt
\end{enumerate}

\subsection{MuseumBesuchen}

\begin{enumerate}
\item Museum ausw\"{a}hlen 

\begin{enumerate}
\item Der Internetuser hat die M\"{o}glichkeit ein Museum bzw. aus mehreren Museen
eines auszuw\"{a}hlen. 
\end{enumerate}
\item Stockwerk ausw\"{a}hlen 

\begin{enumerate}
\item {}``Museum{}'' hat eine Liste, in dem alle m\"{o}glichen Stockwerke aufgelistet
sind. Der Internetuser w\"{a}hlt ein Stockwerk aus und kommt so dorthin. 
\end{enumerate}
\item Raum ausw\"{a}hlen 

\begin{enumerate}
\item Hier wird wieder aus einer Liste aller verf\"{u}gbaren R\"{a}ume aus {}``Floor{}''
der gew\"{u}nschte ausgew\"{a}hlt. 
\end{enumerate}
\item Vitrine ausw\"{a}hlen 

\begin{enumerate}
\item Die Liste mit allen Vitrinen aus {}``Room{}'' steht wieder zur Verf\"{u}gung.
Eine Vitrine wird ausgew\"{a}hlt. 
\end{enumerate}
\item Objekt ausw\"{a}hlen 

\begin{enumerate}
\item Aus der Liste der in einer Vitrine dargestellten Objekte aus {}``Showcase{}''
wird das darzustellende Objekt ausgew\"{a}hlt. 
\item Die Position und die Informationen zu einem Objekt aus {}``Object{}''werden
geholt. 
\end{enumerate}
\end{enumerate}

\subsection{VitrineErstellen}

Mit der Durchwanderung des Use Case VitrineErstellen im Klassendiagramm wird
\char`\"{}uberpr\char`\"{}uft, ob die zur Verf\char`\"{}ugung gestellten Funktionalit\char`\"{}aten
des Klassendiagramms ausreichend sind, damit das Use Case vollst\char`\"{}andig
implementiert ist. Mit Hilfe des schon obengenannten Flow of Events f\char`\"{}ur
den Use Case VitrineErstellen, wird der Use Case durchwandert und dabei wird
betrachtet, ob jeder Punkt im Flow of Events implementiert ist und was die jeweiligen
Klasssen und Methoden dazu beitragen. 

\begin{enumerate}
\item Der Vorgang beginnt mit der Selektion \glqq Vitrine erstellen\grqq.\\
\\
\textbf{Im Klassendiagramm:}\\
 Mit der Selektion \glqq Vitrine erstellen\grqq \ wird die Methode \textit{getInstance():Showcase}
in der Klasse \textit{Showcase} aufgerufen. Mi dieser Methode(=Konstruktor)
wird eine Instanz von Showcase (=Vitrine) gebildet und die Attribute \textit{id}
(=Prim\char`\"{}arschl\char`\"{}ussel der Vitrine), \textit{name} (Titel der
Vitrine) und description (=Beschreibung der Vitrine) initalisiert. 
\item Festlegung wie die Vitrine dargestellt werden soll.\\
\\
\textbf{Im Klassendiagramm:}\\
 Mit der Methode \textit{setSkin(): void} in der Klasse \textit{Showcase} wird
das Aussehen der Vitrine festgelegt. 
\item Beschreibung der Vitrine\\
\\
\textbf{Im Klassendiagramm:}\\
 Wie schon oben erw\char`\"{}ahnt, wird mit der Methode \textit{getInstance():Showcase}
das Attribut description initalisiert. 
\item if (Vitrine Raum zuweisen) 

\begin{enumerate}
\item Vitrine Raum zu weisen. 
\end{enumerate}
\textbf{Im Klassendiagramm:}\\
 Um einer Vitrine einen Raum zu zuweisen, wird die Mehtode \textit{addShowcase():void}
von der Klasse \textit{Room} aufgerufen. Das L\char`\"{}oschen einer Zuweisung
einer Vitrine zu einem Raum erfolgt mit \textit{deleteShowcase():void} aus der
Klasse \textit{Room}. Im Vector \textit{showcases} in der Klasse \textit{Room}
wird gespeichert, welche Vitrinen einem Raum zugewiesen sind. 

\item if (Objekt in Vitrine positionieren) 

\begin{enumerate}
\item while (weitere Objekte positionieren) 

\begin{enumerate}
\item Objektpositionierung 
\end{enumerate}
\item end 
\end{enumerate}
\textbf{Im Klassendiagramm:}\\
 Mit den Methoden \textit{addObjekt():void} bzw. \textit{deleteObject():void}
von der Klasse \textit{Showcase} kann ein Objekt in einer Vitrine positioniert
bzw. gel\char`\"{}oscht werden. Welche Objekte einer Vitrine zugeordnet sind,
wird im Vector \textit{objekts} gespeichert. Die Position des Objekts in der
Vitrine wird im Typ \textit{PosObjekt} festgehalten. 

\item if (Speichern) 

\begin{enumerate}
\item Der ganze Vorgang \glqq Vitrine erstellen\grqq \ wird in der Datenbank abgespeichert. 
\item Ende des Vorgangs \glqq Vitrine erstellen\grqq. 
\end{enumerate}
\item if (Abrechen) 
\item Ende des Vorgangs \glqq Vitrine erstellen\grqq \ ohne den Vorgang in der Datenbank
zu speichern. 
\end{enumerate}
\textbf{Im Klassendiagramm:}\\
 Immer wenn ein Vorgang abgeschlossen ist, wie z.B. Objekt positionieren, wird
das Ergebnis in der Datenbank abgespeichert. D.h. \textit{Speichern} bedeutet
einfach die Sitzung ist abgeschlossen. Mit \textit{Abbrechen} wird mittels einer
Hilfsmethode in \textit{Showcase} alles, was in dieser Sitzung \glqq Vitrine
erstellen\grqq \ in der Datenbank gespeichert wurde, wieder gel\char`\"{}oscht. 


\chapter{Projektplan für die Construction Phase}


\section{Kategorisierung der Use Cases}

Wichtigkeit und Risiko werden jeweils in Stufen von 1-10 (10 = höchste Wichtigkeit
bzw. größtes Risiko), Entwicklungszeit in geschätzten Mannwochen angegeben.


\subsection{Objektverwaltung}


\subsubsection{Artefakte eingeben}

\begin{itemize}
\item Wichtigkeit: 10
\item Risiko: 10
\item Entwicklungszeit: 15
\end{itemize}

\subsubsection{Artefakte löschen}

\begin{itemize}
\item Wichtigkeit: 10
\item Risiko: 5
\item Entwicklungszeit: 1
\end{itemize}

\subsubsection{Objektgruppen erstellen}

\begin{itemize}
\item Wichtigkeit: 10
\item Risiko: 6
\item Entwicklungszeit: 5
\end{itemize}

\subsection{Benutzerverwaltung}


\subsubsection{Benutzergruppe erstellen}

\begin{itemize}
\item Wichtigkeit: 10
\item Risiko: 10
\item Entwicklungszeit: 16
\end{itemize}

\subsubsection{Rechte festlegen}

\begin{itemize}
\item Wichtigkeit: 10
\item Risiko: 7
\item Entwicklungszeit: 5
\end{itemize}

\subsubsection{Identifizierung eines neuen Mitarbeiters}

\begin{itemize}
\item Wichtigkeit: 10
\item Risiko: 6
\item Entwicklungszeit: 1
\end{itemize}

\subsection{Museumsverwaltung}


\subsubsection{Museum erstellen}

\begin{itemize}
\item Wichtigkeit: 10
\item Risiko: 6
\item Entwicklungszeit: 5
\end{itemize}

\subsubsection{Vitrine erstellen}

\begin{itemize}
\item Wichtigkeit: 10
\item Risiko: 8
\item Entwicklungszeit: 12
\end{itemize}

\subsection{Sonstige}


\subsubsection{Katalog erstellen}

\begin{itemize}
\item Wichtigkeit: 5
\item Risiko: 1
\item Entwicklungszeit: 5
\end{itemize}

\subsubsection{CD-ROM erzeugen}

\begin{itemize}
\item Wichtigkeit: 5
\item Risiko: 1
\item Entwicklungszeit: 5
\end{itemize}

\subsubsection{Suchen von Objekten}

\begin{itemize}
\item Wichtigkeit: 8
\item Risiko: 3
\item Entwicklungszeit: 5
\end{itemize}

\subsubsection{Datensicherung}

\begin{itemize}
\item Wichtigkeit: 10
\item Risiko: 1
\item Entwicklungszeit: 2
\end{itemize}

\section{Iterationen}

Aufgrund der oben geschätzten Entwicklungszweiten, Wichtigkeiten und der Größe
des Entwicklungsteams wird eine Iterationslänge von 4 Wochen festgelegt.

Insgesamt wird es 4 Iterationen geben.

Genannt sind jeweils die Use Cases und die zu schaffenden Voraussetzungen


\subsection*{Iteration 1}

\textbf{Artefakte eingeben und löschen, Objektgruppe erstellen:}

Teil des User-Interface Verwaltung

Objektverwaltung

Datenbank-Interface


\subsection*{Iteration 2}

\textbf{Museum erstellen, Vitrine erstellen, Museumsbesuch:}

Museumsverwaltung

Teil des User-Interface Verwaltung 

Datenbank-Interface

User-Interface Internetbesuch


\subsection*{Iteration 3}

\textbf{Benutzergruppe erstellen, Identifizierung eines neuen Mitarbeiters,
Rechte festlegen:}

Benutzerverwaltung

Teil des User-Interface Verwaltung

Datenbank-Interface


\subsection*{Iteration 4}

\textbf{Suchen von Objekten, Datensicherung, CD-ROM erzeugen, Katalog erstellen:}

Alle Subsysteme des Business-Layer

Alle User-Interfaces

Datenbank-Interface
\end{document}
