IPA-Dokumentation 2013 ResMan Reporting

IPA-Dokumentation 2013 

ResMan Reporting 

Kunde TCSB 

Projektname ResMan Reporting 

Projektnummer - 

Autor Elisa Schnabel 

Ausgabedatum 21.05.2013 

Version 1.0 

Eidgenössisches Departement für Wirtschaft, 

Bildung und Forschung WBF 

Staatssekretariat für Wirtschaft SECO 

Status In Arbeit In Prüfung Genehmigt, zur 

Nutzung 

Beteiligter Personenkreis 

Benutzer, Anwender Gruppenleiter TCSB 

Prüfung Thomas D‘Ascoli ,Fachvorgesetzter 

Martin Frieden, Hauptexperte 

Claudio Siegenthaler , 2. Experte 

Genehmigung Thomas D’Ascoli, Fachvorgesetzter 

zur Information, Kenntnis Thomas Rohrer, Berufsbildner

Dokumentinformationen 

Änderungskontrolle, Prüfung, Genehmigung 

Version Datum Name / Rolle Beschreibung 

IPA-Dokumentation 

Vorlage 2009-12-23 W. Aeby Dokumentvorlage QV2010, Version V1.0 

0.1 

0.2 

2013-04-29 

2013-04-30 

Elisa Schnabel 


Eröffnung, Ablauf und Umfeld, 

Voranalyse 

Technisches Konzept 

0.3 2013-05-01 Elisa Schnabel Technisches Konzept 

0.4 2013-05-14 Elisa Schnabel Realisierung Systemarchitektur 

0.5 2013-05-16 Elisa Schnabel Realisierung GUI 

0.6 2013-05-16 Elisa Schnabel Realisierung, Glossar 

0.7 2013-05-17 Elisa Schnabel Quellen 

0.8 2013-05-17 Elisa Schnabel Testprotokoll 

0.9 2013-05-21 Elisa Schnabel Schlussbericht , Persönliches Fazit 

1.0 2013-05-21 Elisa Schnabel Abgabeversion 

Verwendete Abkürzungen 

Abkürzung Bedeutung 

BIT 

DB 

DTO 

EM 

GUI 

Bundesamt für Informatik und Telekommunikation 

Datenbank 

Data Transfer Object 

EntityManager 

Graphical User Interface 

IPA Individuelle Praktische Arbeit 

OdA Organisation der Arbeit 

QC 

OE 

Quality Center 

Organisationseinheit 

ResMan Ressourcen Manager 

CRUD Create Read Update Delete 

Elisa Schnabel 21.05.2013 Seite 2 von 128

Inhaltsverzeichnis 


Dokumentinformationen...................................................................................................... 2 

Inhaltsverzeichnis ................................................................................................................ 3 

Abbildungsverzeichnis ........................................................................................................ 5 

Tabellenverzeichnis ............................................................................................................. 6 

Management Summary ........................................................................................................ 7 

Teil 1: Ablauf und Umfeld .................................................................................................... 8 

1. Aufgabenstellung ................................................................................................... 9 

1.1 Ausgangslage ...................................................................................................... 9 

1.2 Auftragsformulierung ........................................................................................... 9 

1.3 Mittel und Methoden .......................................................................................... 10 

1.4 Projektorganisation ............................................................................................ 11 

1.5 Projektrollen ...................................................................................................... 11 

2. Vorkenntnisse ...................................................................................................... 12 

3. Vorarbeiten ........................................................................................................... 13 

4. Firmenstandards .................................................................................................. 14 

5. Datensicherung .................................................................................................... 15 

6. Zeitplan ................................................................................................................. 16 

7. Arbeitsjournal ....................................................................................................... 17 

7.1 Erster Tag: Montag, 29.04.2013 ........................................................................ 18 

7.2 Zweiter Tag: Dienstag, 30.04.2013 .................................................................... 19 

7.3 Dritter Tag: Donnerstag, 02.05.2013 (Halber Tag, Morgens) ............................. 20 

7.4 Vierter Tag: Freitag, 03.05.2013 ........................................................................ 21 

7.5 Fünfter Tag: Montag, 06.05.2013 ....................................................................... 22 

7.6 Sechster Tag: Dienstag, 07.05.2013 .................................................................. 23 

7.7 Siebter Tag: Montag, 13.05.2013 ....................................................................... 24 

7.8 Achter Tag: Dienstag, 14.05.2013 ..................................................................... 25 

7.9 Neunter Tag: Donnerstag, 16.05.2013 (Halber Tag, Morgens) .......................... 26 

7.11 Zehnter Tag: Freitag, 17.05.2013 ...................................................................... 27 

7.12 Elfter Tag: Dienstag, 21.05.2013 ....................................................................... 28 

7.13 Arbeitszeit total .................................................................................................. 28 

8. Schlussbericht ..................................................................................................... 29 

8.1 Vergleich Ist/Soll ................................................................................................ 29 

8.2 Persönliches Fazit ............................................................................................. 29 

9. Unterschriften ...................................................................................................... 30 

Teil 2: Projektdokumentation ............................................................................................ 31 

10. Voranalyse ............................................................................................................ 32 

10.1 Analyse Ist Zustand / Soll-Zustand .................................................................... 32 

10.2 Pflichtenheft / Systemanforderungen ................................................................. 33 

10.3 Varianten ........................................................................................................... 34 

10.4 Variantenentscheid ............................................................................................ 36 

10.5 Informationssicherheit und Datenschutz ............................................................ 37 

11. Konzept ................................................................................................................. 38 



11.1 Anwendungsfälle ............................................................................................... 38 

11.2 GUI Entwürfe ..................................................................................................... 46 

11.3 Testkonzept ....................................................................................................... 51 

12. Realisierung ......................................................................................................... 61 

12.1 Systemdesign .................................................................................................... 61 

12.2 GUI .................................................................................................................... 70 

12.3 Screenflow Diagramm ....................................................................................... 73 

12.4 Testprotokoll ...................................................................................................... 74 

12.5 JUnit Test .......................................................................................................... 75 

13. Einführung ............................................................................................................ 76 

14. Quellenverzeichnis .............................................................................................. 77 

14.1 Informationen..................................................................................................... 77 

14.3 Bilder ................................................................................................................. 77 

15. Glossar ................................................................................................................. 78 

16. Unterschriften ...................................................................................................... 79 

17. Anhang ................................................................................................................. 80 

17.1 Quellcode .......................................................................................................... 80 

17.2 Benutzerhandbuch .............................................................................................. 1 


Abbildungsverzeichnis 


Abbildung 1: Projektorganisation........................................................................................................... 11 

Abbildung 2: Hermes Phasen ................................................................................................................ 14 

Abbildung 3:HERMES Phasenmodel für beide Projekttypen ................................................................ 31 

Abbildung 4:UseCase Diagramm .......................................................................................................... 38 

Abbildung 5: Activity Diagramm UseCase 01 ....................................................................................... 40 

Abbildung 6: Activity Diagramm UseCase 02-07 .................................................................................. 45 

Abbildung 7: GUI-Nr. 01 Schnellliste ..................................................................................................... 46 

Abbildung 8: GUI-Nr. 02 Suchmaske/ Erfassungsmaske für die Schnellliste ....................................... 47 

Abbildung 9:GUI-Nr. 03 Detailansicht ................................................................................................... 48 

Abbildung 10:GUI-Nr. 04 Trefferliste ..................................................................................................... 49 

Abbildung 11:GUI-Nr. 04 Trefferliste Resource .................................................................................... 50 

Abbildung 12:Komponenten Diagramm ................................................................................................ 61 

Abbildung 13: MVC ............................................................................................................................... 62 

Abbildung 14:Klassendiagramm Weblayer ........................................................................................... 63 

Abbildung 15:Klassendiagramm Servicelayer ....................................................................................... 64 

Abbildung 16:Klassendiagramm Persistenzlayer .................................................................................. 65 

Abbildung 17:Domain Model ................................................................................................................. 66 

Abbildung 18:ERD ResMan Haupttabellen ........................................................................................... 67 

Abbildung 19: Sequenzdiagramm Filterkriterien abspeichern .............................................................. 68 

Abbildung 20: Sequenzdiagramm Berechnung Auslastungsdaten ....................................................... 69 

Abbildung 21:Screenflow ....................................................................................................................... 73 


Tabellenverzeichnis 


Tabelle 1: Projektleiter/Mitarbeiter......................................................................................................... 11 

Tabelle 2: Fachvorgesetzter .................................................................................................................. 11 

Tabelle 3: Hauptexperte ........................................................................................................................ 11 

Tabelle 4: Zweit-Expert ......................................................................................................................... 11 

Tabelle 5: Vorkenntnisse ....................................................................................................................... 12 

Tabelle 6: Arbeitsjournal erster Tag ...................................................................................................... 18 

Tabelle 7: Arbeitsjournal zweiter Tag .................................................................................................... 19 

Tabelle 8:Arbeitsjournal dritter Tag ....................................................................................................... 20 

Tabelle 9: Arbeitsjournal vierter Tag ..................................................................................................... 21 

Tabelle 10:Arbeitsjournal fünfter Tag .................................................................................................... 22 

Tabelle 11: Arbeitsjournal sechster Tag ................................................................................................ 23 

Tabelle 12: Arbeitsjournal siebter Tag .................................................................................................. 24 

Tabelle 13: Arbeitsjournal achter Tag ................................................................................................... 25 

Tabelle 14: Arbeitsjournal neunter Tag ................................................................................................. 26 

Tabelle 15: Arbeitsjournal zehnter Tag ................................................................................................. 27 

Tabelle 16: Arbeitsjournal elfter Tag ..................................................................................................... 28 

Tabelle 17: Arbeitsjournal Arbeitszeit Total ........................................................................................... 28 

Tabelle 18: Unterschriften ..................................................................................................................... 30 

Tabelle 19: Pflichtenheft Muss Anforderungen .................................................................................... 33 

Tabelle 20: Pflichtenheft Kann Anforderungen ..................................................................................... 33 

Tabelle 21:Nutzwertanalyse .................................................................................................................. 36 

Tabelle 22: UseCase Filterkriterien abspeichern .................................................................................. 39 

Tabelle 23: UseCase Auslastungsdaten abfragen ................................................................................ 41 

Tabelle 24: UseCase Daten sortieren ................................................................................................... 42 

Tabelle 25: UseCase Datenexport CSV ................................................................................................ 42 

Tabelle 26: UseCase Datenexport PDF ................................................................................................ 43 

Tabelle 27: UseCase Datenexport Excel .............................................................................................. 43 

Tabelle 28: UseCase Drill Down / Drill Up Navigation .......................................................................... 44 

Tabelle 29:Testfall 1.0 ........................................................................................................................... 52 











Tabelle 40:Testprotokoll ........................................................................................................................ 74 

Tabelle 41: Gloassar ............................................................................................................................. 78 


Management Summary 

Aufgabenstellung 


Mit der Applikation Ressourcen Manager können die Gruppenleiter des Ressort TCSB die 

Auslastung der einzelnen Mitarbeiter planen und überwachen. Dabei ist es mit der aktuellen 

Version aber nur möglich, die Sicht auf jeweils einen Mitarbeiter gleichzeitig zu schaffen. Um 

auch die Auslastung der einzelnen Mitarbeiter miteinander vergleichen zu können, wird die 

Applikation um das Modul ResMan Reporting erweitert, welches es den Gruppenleitern möglich 

macht eine OE-weite Sicht zu schaffen oder die Auslastungsdaten nach bestimmten Kriterien 

zusammenzustellen. Die Kriterien, nach denen die Gruppenleiter die Daten zusammenstellen 

lassen, sollen ausserdem auch abgespeichert werden können. Zusätzlich soll 

auch ein Export der Auslastungsdaten möglich gemacht werden. (CSV, PDF, Excel) 

Varianten 

Die Applikation ResMan wurde mit der Programmiersprache Java und den Frameworks JSF, 

Spring und JPA umgesetzt. Deshalb gab es im Unterprojekt Reporting von der Technologie 

her grundsätzlich keinen Variantenentscheid. Bei der Export-Funktion gab es aber verschiedene 

Varianten, die zu prüfen waren. Die Varianten, der Variantenentscheid und dessen Resultate 

wurden in der Voranalyse abgehandelt. Alle weiteren Entscheidungen oder Überlegungen 

wurden während der Realisierungsphase durchgeführt und entsprechend dokumentiert. 

Konzept 

Im Rahmen des Konzepts wurden technische Vorgaben und Konzepte für die erfolgreiche 

Durchführung der Realisierung festgehalten. Die Konzepte betreffen zum einen die einzelnen 

UseCases zum anderen die Testabläufe und den Aufbau der GUIs. 

Realisierung 

Das Modul ResMan Reporting wurde in der bereits bestehenden Entwicklungsumgebung 

Eclipse programmiert. Das Modul wurde nach Konzept aufgebaut und implementiert. Es 

wurden neue Klassen erstellt und wo nötig bestehende erweitert. 

Testbericht 

Es wurden zwei unterschiedliche Testmethoden durchgeführt. Der Anwendertest deckt die 

Funktionalitäten der Applikation ab und der Unit-Test stellt die Zuverlässigkeit des Codes 

sicher. Der Unit-Test wurde für die Berechnungslogik angewendet. 

Mittelbedarf 

Für dieses Projekt wurden keine zusätzlichen Mittel benötigt. Alle verwendeten Mittel sind 

bereits auf meiner Workstation installiert. 

Fazit 

Alle MUSS - und gewisse KANN Funktionalitäten konnten während der IPA umgesetzt werden. 

Trotz ein paar technischer Probleme, an welchen ich ein wenig Zeit verloren habe, 

konnte ich das Projekt soweit fertigstellen. 


Teil 1: Ablauf und Umfeld 

IPA Projektname: ResMan Reporting 

Autor: Elisa Schnabel 



1. Aufgabenstellung 

1.1 Ausgangslage 


Im Staatssekretariat für Wirtschaft (SECO) wurde für die Abteilung „Systembetrieb und 

Technik“ (TCSB) ein webbasiertes Ressourcen-Management-Tool – ResMan – entwickelt. 

Die Applikation Ressourcen Manager dient dazu, die Auslastungsplanung der 

Mitarbeitenden in der Abteilung zu vereinfachen, um so die Planung anstehender Projekte 

effizienter durchführen zu können. 

Die aktuelle Version der Applikation erlaubt die Auslastungs-Planung und -Überwachung für 

einzelne Ressourcen und stellt diese mittels Diagrammen grafisch dar. Zwar muss bei einer 

Ressource die entsprechende Organisationseinheit definiert werden, es besteht momentan 

aber keine Möglichkeit, eine Organisationseinheit-weite Sicht zu schaffen oder Daten nach 

bestimmten Kriterien zusammen zu stellen. 

Um die Führungspersonen bei der Team Planung zu unterstützen, ist ResMan um das Modul 

„Reporting“ zu erweitern. 

1.2 Auftragsformulierung 

Funktionalitäten: 

Das neu zu schaffende Modul enthält folgende Funktionalitäten: 

- Abfrage von Auslastungsdaten für einzelne oder mehrere Ressourcen oder für Organisationseinheiten 

mit Hilfe noch zu definierender Filterkriterien. 

- Tabellarische Darstellung der Resultatlisten mit passenden Sortiermöglichkeiten 

(MUSS) und Drill-Down / Drill-Up Navigation (KANN). 

- Datenexport in CSV (MUSS), XLSX und PDF (beide KANN). 

- Abfrage von vordefinierten „Schnelllisten“ (z.B. Auslastung aller Ressourcen einer OE 

im aktuellen Monat). 

Enthaltene Arbeiten: 

- Dokumentiertes Design der Lösung (UML, UI-Mockups, Gedanken zu Usability) 

- Umsetzung auf allen Applikations-Schichten (evtl. kein zusätzliches Repository notwendig) 

- QS & Bugfixing 

- Dokumentation der Lösung (inkl. Schulungsdokumente) 


1.3 Mittel und Methoden 

Im Rahmen dieses Projektes setze ich folgende Software und Frameworks ein: 

Betriebssystem: Windows 7 

Office: Microsoft Office 2010 Professional 


Entwicklungsumgebung: Eclipse Java EE IDE for Web Developers 

Programmiersprache: Java 6 

Browser: Mozilla Firefox 20.0.1, Google Chrome 18 

Internet Explorer 8 

Frameworks: JSF, PrimeFaces, Spring, JPA 

Datenbank: PostgreSQL 

Datenbank- Tool: 

Versionsmanagementsystem: 

Projektmethode: 

GUI Skizzen: 

pgAdmin 1.14.3 

TortoiseSVN 1.7.6 (Subversion 1.7.4) 

HERMES 

Balsamiq Mockups for Desktop 2.2.10 

UML: Visual Paradigm for UML 8.0 

Testing: Quality Center HP 

Alle Programme sind bereits vor meiner IPA auf meiner Workstation installiert. 


1.4 Projektorganisation 

Projektausschuss 

Fachvorgesetzter: Thomas D’Ascoli 

Hauptexperte: Martin Frieden 

Zweit-Expert: Claudio Siegenthaler 

Entwicklerin: 


1.5 Projektrollen 

Auftraggeber: 

Beat Felber 

Projektleitung: 


Abbildung 1: Projektorganisation 

1.5.1 Projektleiterin / Projektmitarbeiterin 

Name Elisa Schnabel 

elisa.schnabel@gmx.ch 

Tester: 

Mitarbeiter 

TCSB-MED 

Firma Staatssekretariat für Wirtschaft SECO 

Finkenhubelweg 12, 3011 Bern 

Tabelle 1: Projektleiter/Mitarbeiter 

1.5.2 Fachvorgesetzter 

Name Thomas D‘Ascoli 

thomas.dascoli@seco.admin.ch 

Firma Staatssekretariat für Wirtschaft SECO 

Finkenhubelweg 12, 3011 Bern 

Tabelle 2: Fachvorgesetzter 

1.5.3 Hauptexperte 

Name Martin Frieden 

martin.frieden@bluewin.ch 

Firma gibb 

Lorrainestrasse 5b 

3000 Bern 25 

Tabelle 3: Hauptexperte 

1.5.1 Zweit-Expert 

Name Claudio Siegenthaler 

cloedu@gmail.com 

Firma Interdiscount Division der Coop Genossenschaft 

Bernstrasse 90 

3303 Jegenstorf 

Tabelle 4: Zweit-Expert 



2. Vorkenntnisse 


Während meiner Ausbildung habe ich verschiedene Programmiersprachen und Frameworks 

kennengelernt. In den letzten anderthalb Jahren habe ich aber hauptsächlich mit den 

Frameworks JSF, Spring, JPA und der Programmiersprache Java gearbeitet. Die nachfolgende 

Tabelle zeigt die während der IPA eingesetzten Frameworks, Programmiersprachen, 

Software und Methoden. 

Technologie / Software Kenntnisse Arbeiten 

Java Gut Mehrere Projektarbeiten in 

der Schule / Lehrbetrieb 

durchgeführt. 

JSF Gut Zwei Projektarbeiten im 

Lehrbetrieb und eine in der 

Schule durchgeführt. 

PrimeFaces Gut Zwei Projektarbeiten im 



Spring Grundlegend Zwei Projektarbeiten im 

Lehrbetrieb durchgeführt. 

JPA Grundlegend Zwei Projektarbeiten im 



HERMES Mittel Mehrere Projekte durchgeführt 

Schule/ Lehrbetrieb; 

Einführungskurs BIT für Lernende 

besucht. 

pgAdmin Grundlegend Für die Erstellung der Datenbank 

des ResMan Projekts 

benutzt. 

Quality Center Keine Mit dem Quality Center wurde 

während der Ausbildung 

noch nicht gearbeitet. 

Tabelle 5: Vorkenntnisse 


3. Vorarbeiten 


Die Entwicklungsumgebung, die Konfiguration des Springframeworks und das Datenbankmodell 

standen bereits im Vorfeld der IPA zur Verfügung. 

Ansonsten wurden keine Vorarbeiten für die IPA geleistet. 


4. Firmenstandards 

HERMES 


In den Weisungen über die Informatik im Eidg. Volkswirtschaftsdepartement (WIT-EVD) wurde 

festgelegt, dass als Projektmethode HERMES verwendet werden soll. So begleitet sie 

auch mich während meiner IPA. 

Abbildung 2: Hermes Phasen 


5. Datensicherung 


Sämtliche IPA-relevanten Dokumente werden im Fabasoft abgelegt. Dies ist die Dokumentenablage 

des SECO. Des weiteren werden alle Dokumente von mir auf www.dropbox.com 

abgelegt. Dies ist ein Webshare für den privaten gebrauch und kann Daten bis zu einem GB 

speichern. 

Für die Programmdateien verwenden wir im SECO tortoiseSVN. Dies ist ein Versionisierungstool, 

welches direkt in das Kontextmenu des Explorers installiert wird. SVN arbeitet 

serverseitig, das heisst, dass alle Programmdateien extern auf einem Server gesichert sind. 


6. Zeitplan 



7. Arbeitsjournal 

Die Festlegungen dieses Dokuments gelten im Projekt ResMan Reporting. 


Gemäss Art. 5 Absatz 2 der Wegleitung über die individuelle praktische Arbeit (IPA) an Lehrabschlussprüfungen 

des BBT vom 27. August 2001 gilt: 

„Die zu prüfende Person führt ein Arbeitsjournal. Sie dokumentiert darin täglich das Vorgehen, 

den Stand der Prüfungsarbeit, sämtliche fremde Hilfestellungen und besondere Vorkommnisse 

wie z.B. Änderungen der Aufgabenstellung, Arbeitsunterbrüche, organisatorische 

Probleme, Abweichungen von der Soll-Planung.“ 

Das Arbeitsjournal zur IPA ist zwingend zu führen und den Experten und Fachvorgesetzten 

vorzulegen. Das Arbeitsjournal ist täglich sinngemäss und korrekt auszufüllen. 

Das Arbeitsjournal dient der Nachvollziehbarkeit der von den Lernenden ausgeführten Arbeiten 

und wird als Teil der IPA in die Bewertung mit einbezogen. 


7.1 Erster Tag: Montag, 29.04.2013 


Tätigkeiten: Aufwand (geplant) h Aufwand (effektiv) h 

Zeitplan erstellen 

Dokumentation eröffnen 

Voranalyse (Soll /Ist, Pflichtenheft, 

Varianten) 

Tabelle 6: Arbeitsjournal erster Tag 

1.5 

2 

4.5 

Total: 8 8 

Probleme: 

Keine 

Hilfestellungen: 

Keine 

Reflexion: 

Heute war der erste Tag meiner IPA. Am Morgen erstellte ich als allererstes meinen Zeitplan. 

Als ich damit fertig war konnte ich schon die Dokumentation eröffnen und den Teil 1: 

Ablauf und Umfeld am Vormittag abschliessen. 

Am Nachmittag konnte ich dann auch mit der Voranalyse beginnen. Ich startete mit der 

SOLL- IST Analyse. Anschliessend erstellte ich das Pflichtenheft (Systemanforderungen). 

Hierzu musste ich mir die Anforderungen aus der Aufgabenstellung herausnehmen. 

Ausserdem konnte ich heute auch schon mit der Variantenanalyse starten. Ich überlegte 

mir hierzu, wie ich die Variantenentscheide am besten nachvollziehbar darstellen könnte. Ich 

entschied mich schlussendlich für eine Nutzwertanalyse. Dazu informierte ich mich im Internet 

ein wenig. 

Insgesamt bin ich mit dem heutigen Tag ganz zufrieden, denn ich konnte alle Tätigkeiten, die 

ich mir laut Zeitplan vorgenommen hatte durchführen. 

Nächste Schritte: 

Morgen möchte ich noch den letzten Teil der Voranalyse abschliessen und mit dem Konzept 

starten. 

Elisa Schnabel 21.05.2013 Seite 18 von 128 

1.5 

2 

4.5

7.2 Zweiter Tag: Dienstag, 30.04.2013 



Voranalyse abschliessen 

Beginnen mit technischem Konzept 

Tabelle 7: Arbeitsjournal zweiter Tag 

1.5 

6.5 

Total: 8 8.5 

Probleme: 

Keine 


Keine 

Reflexion: 

Heute Morgen habe ich noch eine Stunde an der Voranalyse gearbeitet und konnte sie auch 

gemäss Zeitplan rechtzeitig abschliessen. Danach fing ich direkt mit dem Konzeptteil an. Ich 

überlegte kurz, was ich alles in den Konzeptteil reinnehmen könnte und entschied mich für 

das UseCase Diagramm, die UseCase Beschreibungen, ein einfaches Komponentendiagramm, 

welches die drei Schichten-Architektur (Presentation, Business, Persitence) beschreibt 

und die GUI-Skizzen sowie das Testkonzept. 

Zu allererst zeichnete ich das UseCase Diagramm. Hierfür nahm ich die Systemanforderungen, 

welche ich bereits in der Voranalyse evaluiert habe. Anschliessend beschrieb ich noch 

die einzelnen UseCases. Ich entschied mich, diese sehr detailliert zu beschreiben und nahm 

zusätzlich zu den ansonsten üblichen Feldern noch die Validierungsregeln und sonstige 

Regeln hinzu. Die höhere Detaillierung soll mir dann später bei der Formulierung der Testcases 

helfen. 

So gegen Ende vom heutigen Nachmittag konnte ich dann auch schon mit dem Skizzieren 

der GUIs beginnen. Ich verwendete dazu das Tool Balsamique-Mockup, welches die gängigen 

GUI-Komponenten zur Verfügung stellt. Ich überlegte, wie viele verschiedene GUI- 

Ansichten ich benötige und kam schlussendlich auf vier verschiedene. Da ich mir bei der 

Darstellung der Resultatlisten nicht ganz sicher war, nahm ich Rücksprache mit Stefan Heller, 

der mir dann seine ungefähren Vorstellungen schilderte. Der heutige Tag verlief wieder 

ohne Probleme und auch von der Zeit her liege ich noch genau im Zeitplan. 


Morgen möchte ich noch die restlichen GUIS skizzieren und mit dem Testkonzept beginnen. 


1 

7.5


7.3 Dritter Tag: Donnerstag, 02.05.2013 (Halber Tag, Morgens) 


GUI-Skizzen erstellen und beschreiben. 

Testkonzept erstellen. 

Total: 4 5 

Probleme: 

keine 


keine 

Reflexion: 

Tabelle 8:Arbeitsjournal dritter Tag 

2 

2 

Heute Morgen habe ich noch die restlichen GUI-Skizzen Trefferliste und Detailansicht gezeichnet. 

Als ich damit fertig war, fügte ich die Skizzen in die Dokumentation ein und fügte 

jeder Skizze noch eine Beschreibung hinzu. 

Anschliessend erstellte ich das Komponentendiagramm für die drei Schichtenarchitektur, 

welches ich auf unser Projekt anpasste – auf dem Presentationlayer wird ein MVC-Muster 

aus Controller (bei uns Action), Model und View (die xhtml-Seiten) verwendet und für den 

Business- und Persistence-Layer verwenden wir jeweils ein Interface und eine implementierende 

Klasse. 

Später fing ich mit dem Testkonzept an. Hier beschrieb ich wer, wie, was, wo getestet wird. 

Um auch alle Anforderungen mit den Testfällen abzudecken, entschied ich mich heute, zu 

jeder Anforderung im Pflichtenheft einen Testfall zu erstellen. 

Heute stand auch noch der erste Besuchstag der Experten an. Herr Frieden teilte mir mit, 

dass er statische und dynamische Diagramme in der Dokumentation erwartet. Ausserdem 

teilte er mir auch mit, dass ich das Arbeitsjournal etwas ausführlicher schreiben sollte. Ich 

werde jetzt also in den nächsten Tagen darauf achten, dass ich noch etwas mehr Zeit darin 

investiere. 


Da ich heute mit dem Testkonzept bereits fertig geworden bin, werde ich morgen mit dem 

Programmieren anfangen können. 


2 

3

7.4 Vierter Tag: Freitag, 03.05.2013 



GUI programmieren 8 8 

Total: 8 8 

Probleme: 

Probleme tauchten heute hauptsächlich bei dem Platzieren der einzelnen GUI- Elemente 

auf. 


Keine 

Reflexion: 

Da ich gestern bereits mit dem Konzept fertig geworden bin, begann ich ein grobes Klassendiagram 

über die von mir neu zu erstellenden Klassen und Interfaces für alle drei Schichten 

zu zeichnen. Ich entschied mich für einen Reportingservice und ein Reportingrepository, 

welches die CRUD Funktionalitäten der Reportingaufgabe abbildet. Auf dem Presentationlayer 

entschied ich mich für die Reporting Crud-Actions und das zugehörige Model, sowie die 

entsprechende View (xhtml). 

Anschliessend konnte ich heute schon frühzeitig mit dem Programmieren der GUIs beginnen. 

Als allererstes fing ich mit dem GUI Eingabemaske /Suchmaske (GUI-Nr. 2) an. Da ich 

mir in der Voranalyse bereits überlegt habe, welche Komponenten ich für welches Filterkriterium 

verwenden möchte, kam ich recht zügig voran. 

Probleme bereiteten mir aber die Radiobuttons, die ich verwende, um eine Zeitspanne auswählen 

zu können. Die Labels des jeweiligen Radio Buttons wurden nicht korrekt platziert 

und rutschten immer unterhalb des Radiobuttons. Ich analysierte das Problem mit Hilfe des 

Firefox-Plugin Firebug und konnte die relevante Styleklasse identifizieren, bei der ich das 

margin-top verkleinern musste. Ich musste also das Primefaces-custom.css anpassen. 

Mit der Detailansicht (GUI-Nr. 03) wurde ich ziemlich schnell fertig, da dort ja nur Labels angezeigt 

werden. Auch mit der Liste, der abgespeicherten Filterkriterien GUI-Nr. 01, wurde ich 

relativ schnell fertig. 

Für das GUI Resultat Liste (GUI-Nr. 04) reichte mir die Zeit heute nicht mehr, da ich am Morgen 

zu viel Zeit mit dem Platzieren der einzelnen Elemente verbrachte. 

Im Allgemeinen bin ich mit dem heutigen Tag nicht sonderlich zufrieden. Ich habe mich nämlich 

ziemlich verschätzt mit der Zeit, die ich für die GUI-Programmierung aufwenden muss. 


Am Montag werde ich mit der GUI- Programmierung weitermachen. Ausserdem möchte ich 

am Montag auch das Feature: Filterkriterien abspeichern umsetzen. 

Tabelle 9: Arbeitsjournal vierter Tag 


7.5 Fünfter Tag: Montag, 06.05.2013 

Tabelle 10:Arbeitsjournal fünfter Tag 



Feature „Filterkriterien abspeichern“ 

programmieren 

8 9 

Total: 8 9 

Probleme: 

Probleme hatte ich heute vor allem mit dem Valuechangelistener der OE. Diesen brauchte 

ich, um das Dropdown Resource in Abhängigkeit der gewählten OE abfüllen zu können. Leider 

wurde der Listener nicht aufgerufen, und ich fand lange Zeit nicht heraus warum. Nach 

langem erfolglosem rumprobieren entschloss ich mich dann, anstelle des ValueChangeListeners 

von JSF ein AJAX Event zu nehmen. Dies funktionierte dann auch tadellos gleich 

beim ersten Versuch. 


Keine 

Reflexion: 

Heute wollte ich eigentlich noch die GUI- Ansicht Resultatliste programmieren. Da ich aber 

dafür die kalkulierten Daten benötige, entschloss ich mich zuerst einmal das Feature Filterkriterien 

abspeichern umzusetzen. 

Dazu erstellte ich zuerst einmal auf der Datenbank die Tabelle reporting_criteria. 

Danach erstellte ich die dazugehörige Entität, den Persistenzlayer (Repository) und 

den Servicelayer. 

Anschliessend erstellte ich noch die ReportingPersistAction. 

Zuerst wollte ich die Validierung der Eingaben in diese Klasse nehmen, ich überlegte mir 

dann aber dass auch die Suche, also die Berechnung der Auslastungsdaten eine Validierung 

durchführen muss. Deswegen entschloss ich mich eine separate Klasse Validator zu erstellen, 

welche die Eingaben validiert und von beiden Actions aus aufgerufen werden kann. 

Um die Dropdowns auf der xhtml Seite abfüllen zu können erstellte ich einen Listener, der 

die Listen der Dropdown Komponenten abfüllt, bevor die Seite gerendert wird. Ausserdem 

musste ich für alle Dropdowns noch einen Konverter schreiben, der die Objekte in Strings 

konvertiert und umgekehrt. Des Weiteren musste ich zwei Listener programmieren, die aufgerufen 

werden, wenn der Wert in einem Dropdown geändert wird. Diesen Mechanismus 

benötigte ich beim Auswählen einer OE und beim Auswählen eines Projektes. Denn abhängig 

davon werden dann die Resourcen bzw. Projekttasks abgefüllt. 

Da bei uns Cleancode mehr gewichtet wird als javadoc, werde auch ich darauf achten sprechende 

namen zu verwenden, anstatt alles geanu zu kommentieren. 

Mit dem heutigen Tag bin ich eigentlich recht zufrieden, denn ich konnte heute das Feature 

Filterkriterien abspeichern vollständig umsetzen. Ich bin auch froh, dass ich für dieses Feature 

acht Stunden eingeplant habe, denn es kamen einige Klassen dazu wie eben z.B. die 

Listener und Konverter, die ich so vorher nicht eingeplant hatte. 


Morgen werde ich mit dem Feature Berechnung der Auslastungsdaten anfangen. 


7.6 Sechster Tag: Dienstag, 07.05.2013 

Tabelle 11: Arbeitsjournal sechster Tag 



Feature „Auslastungsdaten abfragen“ 

programmieren 

8 8 

Total: 8 8 

Probleme: 

Das grösste Problem, mit dem ich heute konfrontiert wurde, war die Resultat Tabelle auf 

dem GUI-Nr. 04. Da ich für die Darstellung eine Dynamische Tabelle benötige, informierte 

ich mich im Internet, wie ich dies mit PrimeFaces am besten umsetzen könnte. Ich kam dann 

zum Ergebnis, dass ich in der DataTable dynamische Columns definieren kann. 

Leider wurden die dynamischen Columns in der Tabelle nicht angezeigt. Anfangs hatte ich 

den Verdacht, dass die Innere Liste, also die Liste von Arbeitstagen auf der Ressource nicht 

aufgelöst werden kann. Deswegen versuchte ich mal über einen Index auf die innere Liste 

zuzugreifen. Dies funktionierte auch wunderbar. Also konnte ich dies schon mal ausschliessen. 

Als nächstes Versuchte ich mal den Columns eine unabhängige Liste anzugeben. Dies 

funktionierte auch prima. 

Nach längerer Analyse weiterer Möglichkeiten fand ich dann raus, dass die Datatable Variable 

resource immer Null in der JSF Phase 6 (Render Resource) zurückgibt. Hier musste es 

sich um einen Fehler im Framework handeln. Da Primefaces Opensource ist und ich den 

Quellcode zur Verfügung hatte, versuchte ich, durch die Klassen von PrimeFaces zu debuggen, 

um herauszufinden, wo das Problem liegt. Aber auch dies lieferte keine klaren Ergebnisse. 

Später zog ich dann noch Stefan um Rat hinzu. Aber auch er fand nicht heraus, weshalb 

die Columns nicht angezeigt werden. Also entschlossen wir uns, die Aufgabenstellung 

anders zu lösen. 


Stefan Heller probierte mir mit diesem Problem zu helfen. Leider fanden wir das Problem 

auch gemeinsam nicht heraus. Deswegen entschloss ich mich, die Tabelle nicht, wie gewohnt, 

deklarativ auf der XHTML Seite zu erstellen, sondern programmatisch als 

JSF/Primefaces-Komponente in Java. 

Reflexion: 

Heute fing ich an, das Feature „Auslastungsdaten abfragen“, umzusetzen. Als erstes erstellte 

ich die Action ReportingCalculateAction, in diese ich ein Teil der Berechnungslogik 

reinpacken werde. Anschliessend musste ich mir überlegen, wie ich die Berechnung mit Berücksichtigung 

der Filterkriterien umsetzen könnte. 

Ich entschloss mich, zuerst alle Resourcen, mit der angegebenen OE aus der Datenbank zu 

holen, dann über jede einzelne zu iterieren, um die Arbeitsstunden pro Tag zu berechnen. 

So entsteht eine Liste von Arbeitstagen, über die dann iteriert werden kann um nur die Arbeitsstunden 

zu berücksichtigen, die zu den angegebenen Filterkriterien passen. Als ich diese 

Berechnung fertig hatte, fing ich an, die Resultattabelle zu programmieren. Damit hatte 

ich aber Probleme, auf die ich im Abschnitt „Probleme“ bereits eingegangen bin. 

Insgesamt bin ich mit dem heutigen Tag nicht so zufrieden. Das Problem mit den dynamischen 

Columns kostete mich sehr viel Zeit. Ich hoffe, dass ich diese Zeit in den nächsten 

Tagen wieder aufholen kann. 


Am Montag werde ich an diesem Feature weiterarbeiten. 


7.7 Siebter Tag: Montag, 13.05.2013 



Feature „Auslastungsdaten abfragen“ 

programmieren. 

Datenexport 

UML activity Diagramme 

Total: 8 9.5 

Probleme: 

Tabelle 12: Arbeitsjournal siebter Tag 

2 

4 

2 

Heute hatte ich Probleme mit dem Sortieren der Daten in der Resultat Tabelle. Ich nutzte 

für die Sortierung den in der Datenbanktabelle bereits integrierten Sorter von PrimeFaces. 

Dieser sortierte aber die Daten nicht richtig. Denn wenn ich zum Beispiel in einer Spalte eine 

5, eine 23 und eine 8 hatte, sah die Sortierungsfolge nach ausgeführter Sortierung (DESC ) 

folgendermassen aus: 23,5,8. 

Ich schaute mir dann nochmals meine dynamische Liste an, in welcher die Werte für die Tabelle 

stehen. Dabei wurde mir schnell bewusst warum die Sortierung nicht funktionierte. Da 

in der Liste String Werte stehen, sortierte der Sorter logischerweise nach den ASCII Zeichen. 

Und da in der ASCII- Tabelle die Zwei vor der Fünf kommt und die Acht nach der Fünf 

ist es klar, warum die Sortierung nicht wie gewünscht funktionierte. Ich musste den Sorter 

also dazu bringen, nicht nach Strings (ASCII) sondern numerisch zu sortieren – aber nur für 

die Arbeitsstunden und nicht für die Resourcebezeichnungen. 

Als Lösung des Problems, ersetzte ich den Typ der Liste (String) mit dem allgemeinen Typ 

Object und füllte die Resourcebezeichnungen als String und die Arbeitsstunden als Float ein. 

Danach funktionierte die Sortierung einwandfrei. 


Keine 

Reflexion: 

Heute habe ich an dem Feature „Auslastungsdaten abfragen“ weitergearbeitet. Dazu programmierte 

ich vorallem an der Berechnungslogik. Da die Daten anhand der angegebenen 

Granularität (Tag, Woche, Monat) dargestellt werden sollen, musste ich mir überlegen, wie 

ich vorallem die Wochen und die Monatssicht umsetzen kann. Ich entschloss mich dann, die 

Berechnung so durchzuführen, indem ich die Granularität prüfte und anschliessend über die 

bereits berechneten Tage iterierte und aus den Tagen Wochen oder Monatsobjekte machte. 

Diese Berechnungslogik implementierte ich in dem bereits bestehenden ResourcePayloadCalculator 

rein. 

Als ich mit der Berechnung soweit fertig war, machte ich mich an die Sortierung der Daten 

in der Tabelle. Ich nahm hierzu den in der Datentabelle bereits integrierten Sortiermechanismus 

von PrimeFaces. Als ich die Sortierung allerdings testete, fiel mir auf, dass sie nicht 

richtig funktionierte. (Im Abschnitt Probleme genauer erklärt.) Als ich dieses Problem aber 

gelöst hatte, setzte ich die Exportfunktion um. Da ich den Exporter von PrimeFaces nutzte, 

entschied ich mich sowohl den CSV, den PDF wie auch den Excel Export umzusetzen, obwohl 

eigentlich nur der CSV Export eine MUSS Funktionalität wäre. 

Ich entschloss mich heute ausserdem, die Drill-Down Funktionalität (KANN) nicht umzusetzen, 

da ich sonst in Verzug mit der Zeit kommen würde. Da die Dokumentation ein wesentlichen 

Teil der Arbeit ausmacht, werde ich die restliche Zeit hauptsächlich noch darin 

investieren. 


Morgen werde ich mich hauptsächlich der Dokumentation widmen. 


7 

1.5 

1

7.8 Achter Tag: Dienstag, 14.05.2013 



UML Klassendiagramme 

UML Sequenzdiagramme 

Architektur beschreiben 

Testprotokoll 

Activity Diagramme 

Total: 8 8.5 

Probleme: 

Keine 


Tabelle 13: Arbeitsjournal achter Tag 

3 

2 

2 

1 

0 

Stefan Heller stellte mir sein UML Buch zur Verfügung und gab mir Tipps bezüglich des Activity 

Diagramms. 

Reflexion: 

Heute habe ich mich ausschliesslich der Entwicklungsdokumentation gewidmet. Um die 

grobe Architektur zu zeigen, erstellte ich ja bereits schon ein Komponentendiagramm und ein 

grobes KLassendiagramm. Heute ging es noch darum, die UML Klassendiagramme der 

einzelnen Schichten detaillierter zu zeichnen und zu dokumentieren. Da ich viele Klassen 

aus der bestehenden Applikation benutze, entschied ich mich, die Klassendiagramme auf die 

Schichten aufzuteilen, damit sie noch einigermassen übersichtlich dargestellt werden können. 

Das Erstellen der Diagrammer war eigentlich kein grosser Aufwand und ging recht zügig. Da 

ich aber auch erreichen wollte, dass die Diagramme übersichtlich und ansprechend aussehen, 

habe ich ein mehrfaches der Zeit in die Anordnung der Elemente investiert. Dabei 

schaute ich, dass ich so wenige Überschneidungen wie möglich habe und dass die Abstände 

zwischen den Elementen wenn möglich gleich sind. 

Nachdem ich die Klassendiagramme gezeichnet hatte, erstellte ich noch zwei Sequenzdiagramme. 

Dafür überlegte ich mir, welche Szenarien wohl am besten geeignet dafür wären. 

Ich entschied mich beim ersten für das Szenario, wenn ein neues Filterkriterienset abgespeichert 

wird. Bei diesem Ablauf kann man nämlich schön sehen, wie die drei Schichten 

miteinander arbeiten. Als zweites Sequenzdiagramm entschied ich mich für den Ablauf der 

Berechnung. Dies machte für mich am meisten Sinn, da die Berechnung einen wesentlichen 

Teil meines Moduls ausmacht. 

Als ich mit dem Zeichenen der Diagramme fertig war, fügte ich sie in meine Dokumentation 

ein, und verpasste jedem Diagramm noch eine Beschreibung. Am Schluss bereitete ich noch 

das Testprotokoll vor. 

Mit dem heutigen Tag bin ich sehr zufrieden, denn ich bin ziemlich vorwärts gekommen mit 

der Dokumentation und schön sieht sie jetzt auch noch aus. 


Morgen werde ich an der Dokumentation weiterarbeiten. 


4 

2 

1 

0.5 

1


7.9 Neunter Tag: Donnerstag, 16.05.2013 (Halber Tag, Morgens) 


GUI in die Dokumentation 

einfügen 

Benutzerhandbuch erstellen 

Total: 4 4 

Probleme: 

Keine 


Keine 

Reflexion: 

Tabelle 14: Arbeitsjournal neunter Tag 

1 

3 

Heute habe ich wieder hauptsächlich an der Dokumentation gearbeitet. Ich korrigierte noch 

das Klassendiagramm vom Web Layer, da ich dort eine Klasse vergessen hatte. Anschliessend 

fügte ich die Bilder von den verschiedenen GUI- Ansichten und deren Beschreibung in 

die Dokumentation ein. 

Später fing ich an, das bestehende Benutzerhandbuch der Applikation ResMan mit dem 

Modul ResMan Reporting zu erweitern. Ich entschied mich hierzu, die gleiche Struktur zu 

wählen. Mit dem Benutzerhandbuch bin ich heute aber noch nicht ganz fertig geworden. 

Der heutige Tag verlief wieder ohne Probleme. Ich bin fast fertig mit der Dokumentation der 

Realisierungsphase und kann morgen das fertige Modul auf den Testserver deployen, damit 

dann David Giger testen kann. 


Morgen werde ich das Benutzerhandbuch fertigstellen, die Tests im QC erfassen und die 

Applikation testen. 


1 

3

7.11 Zehnter Tag: Freitag, 17.05.2013 



Benutzerhandbuch fertigstellen 

Testfälle im QC erfassen 

Unit Test erstellen 

Testen und Resultate festhalten 

Total: 8 8 

Probleme: 

Tabelle 15: Arbeitsjournal zehnter Tag 

1 

4 

1 

2 

Heute gab es Probleme mit dem Testserver. Und zwar wurden die deployten Änderungen 

nicht übernommen. Die Files waren zwar alle korrekt vorhanden, jedoch übernahm der Testserver 

keinerlei Änderungen. David Giger probierte auch seine Änderungen an der Applikation 

(unabhängig vom Modul ResMan Reporting) zu deployen, aber auch diese wurden nicht 

übernommen. So konnte ich sicher sein, dass es nicht an meinem Modul sondern am Server 

liegt. 

Da heute Niemand da war, der mir mit diesem Problem helfen konnte, entschied ich mich, 

dass die Tests lokal ausgeführt werden sollen. Da auch David Giger (meine Testperson) 

am ResMan entwickelt, hat auch er die aktuelle Entwicklungsumgebung und konnte somit 

die Tests lokal auf seiner Workstation ausführen. 


Keine 

Reflexion: 

Heute habe ich als erstes das Benutzerhandbuch fertiggestellt und in den Anhang meiner 

Dokumentation getan. Anschliessend erfasste ich alle Testfälle im Quality Center. Hierzu 

nahm ich die Testfälle, welche ich bereits in der Konzeptphase detailliert beschrieben hatte. 

Da ich zuvor noch nie mit dem Quality Center gearbeitet hatte, fiel es mir am Anfang etwas 

schwer mich dort zurecht zu finden. Nach dem Erfassen des zweiten Tests, ging es dann 

aber ohne Probleme. 

Als alles soweit zum Testen bereit war, konnte dann David Giger (Lernender 3. Lehrjahr) die 

Tests mittels der erfassten Tests im Quality Center durchführen. Eigentlich war geplant, 

dass die Tests am Testserver durchgeführt werden. Da es aber mit dem Testserver Probleme 

gab führte David Giger sie lokal durch. Ich war bei der Durchführung der Tests dabei, um 

allfällige Fragen zu klären und um die Tests sofort zu protokollieren. Die Tests verliefen 

ohne Probleme, bis auf einen kleinen Schönheitsfehler beim Excel Export, welchen ich heute 

noch beheben konnte. 

Als die Anwendertests abgeschlossen waren, erstellte ich noch einen JUnit Test. Dieser 

testet die Berechnungslogik, welche ich während der IPA implementiert habe. Da ich im 

Rahmen meiner Ausbildung noch keine praktischen Erfahrungen mit dem Unit Testing machen 

konnte, musste ich mich zuerst einmal im Internet informieren, wie diese Tests erstellt 

werden und funktionieren. Als ich dies dann verstanden hatte, erstellte ich den Unit Test und 

führte ihn schlussendlich aus. Auch dieser Test verlief fehlerfrei. 

Der heutige Tag verlief eigentlich bis auf das Problem mit dem Testserver nach Plan. Da 

keine gröberen Bugs beim Testing gefunden wurden, kann ich am Dienstag meine Dokumentation 

frühzeitig abschliessen, hochladen, drucken und binden. 


Am Dienstag werde ich die Dokumentation abschliessen . 


1 

3 

2 

2

7.12 Elfter Tag: Dienstag, 21.05.2013 



Ist soll Vergleich 

Persönliches Fazit 

Management Summary 

SourceCode in Anhang 

Drucken & binden 

Total: 6 6 

Probleme: 

Keine 


Keine 

Reflexion: 

Tabelle 16: Arbeitsjournal elfter Tag 

7.13 Arbeitszeit total 

Tabelle 17: Arbeitsjournal Arbeitszeit Total 

1 

1 

1 

2 

1 

Heute war der letzte Tag meiner IPA. Da während dem Testing keine gröberen Bugs aufgedeckt 

wurden, konnte ich heute auf das Bug Fixen verzichten und frühzeitig mit dem Abschluss 

der Dokumentation beginnen. Hierzu erstellte ich noch den Soll- Ist Vergleich und 

anschliessend noch mein persönliches Fazit. Zum Schluss fing ich dann noch an das Management 

Summary zu erstellen. 

Als ich mit allem fertig war, fügte ich noch den gesamten Sourcecode in meine Dokumentation 

ein. Dies war wohl die mühseligste Arbeit von heute, denn ich hatte einige Probleme mit 

der Formatierung im Dokument. 

Ganz zum Schluss kontrollierte ich dann nochmals das gesamte Dokument. Jetzt werde ich 

das Dokument noch ausdrucken und binden. 

Der heutige Tag verlief ganz ohne Stress. Ich konnte heute noch alle notwendigen Tätigkeiten 

ausführen und die Dokumentation termingerecht abschliessen. 


Präsentation und Websummary 

Totaler Zeitaufwand Person Aufwand 

geplant 

(Std) 

Reflexion 


1 

1 

1 

2 

1 

Aufwand 

effektiv 

(Std) 

Elisa Schnabel 78.5 81 

Da ich meine Tätigkeiten und die dazugehörigen Zeiten im Zeitplan gut geplant hatte, konnte 

ich meine Arbeit innerhalb von 81 Stunden erstellen. Die Abweichung von 2.5 Stunden zu den 

geplanten 78.5 konnte ich fast mit der Reserve verrechnen, die ich ebenfalls eingeplant hatte.

8. Schlussbericht 

8.1 Vergleich Ist/Soll 


Alle MUSS- Kriterien aus dem Pflichtenheft konnten in der vorgegebenen Zeit vollständig 

implementiert werden. Auch zwei von drei KANN- Kriterien konnten implementiert werden. 

Dies betrifft den PDF und den EXCEL Export. Das dritte KANN- Kriterium, nämlich die Drill- 

Down / Drill-Up Navigation wurde aus Zeitgründen nicht umgesetzt. 

Obwohl alle MUSS – und gewisse KANN- Kriterien umgesetzt wurden, gibt es bei dem Modul 

ResMan Reporting noch Verbesserungspotenzial. Dies betrifft vorallem die Darstellung 

der Auslastungsdaten in der Tabelle. 

8.2 Persönliches Fazit 

Insgesamt bin ich mit dem Resultat in der vorgegebenen Arbeitszeit zufrieden. Ich konnte 

das System vollständig entwickeln und bin rechtzeitig mit der Dokumentation fertig geworden. 

Da ich mit dem Konzept schon frühzeitig fertig wurde, konnte ich die dort gewonnene Zeit für 

das Programmieren nutzen. Dadurch konnte ich auch den Mehraufwand, welcher mir beim 

Programmieren des Features „Auslastungsdaten abfragen“ durch das Problem mit den dynamischen 

Collumns entstanden ist, fast ausgleichen. Obwohl mich dieses Problem viel Zeit 

und Nerven gekostet hat, hat es mir auch etwas sehr positives gebracht. Ich habe nämlich 

gelernt, wie man die JSF Komponenten auch programmatisch mit Java implementieren 

kann. Dies wird mir sicher auch in Zukunft bei gewissen Problemen sehr nützlich sein. 

Etwas sehr Wichtiges, was ich auch im Rahmen der IPA kennengelernt habe, sind die Junit 

Tests. Während meiner gesamten Ausbildung konnte ich mich mit dieser Thematik nämlich 

nie richtig auseinandersetzen. Erst im Rahmen meiner IPA konnte ich einen ersten richtigen 

Junit Test erstellen. 

Im Bereich der UML- Modellierung war vorallem das Activity Diagramm ein neuer Lerninhalt 

für mich. Dieses habe ich nämlich weder in der Schule noch im Lehrbetrieb jemals genutzt. 

Für die Formatierung von Diagrammen werde ich künftig mehr Zeit einplanen. 

Sehr grosse Probleme hatte ich während der gesamten IPA glücklicherweise kaum. Die einzigen 

Probleme tauchten während des Programmierens auf. Schade fand ich, dass die Anwendertests 

nicht wie geplant am Testserver durchgeführt werden konnten. 

Um das persönliche Fazit auf den Punkt zu bringen: Ich hatte einiges an Respekt und auch 

etwas Angst vor der IPA, da es sich um eine Fallnote handelt. Als ich jedoch damit begonnen 

habe und mich richtig in die Aufgabenstellung hineinlebte, hat es mir immer mehr Spass gemacht. 

Und das ist vermutlich auch ein Hauptgrund, wieso es mir gelang, die gewünschten 

Punkte abzudecken. Durch Freude an der Arbeit lässt es sich einfacher arbeiten. Das ist 

auch etwas, was ich in Zukunft bestimmt übernehmen werde. Nicht mehr Angst haben vor 

einer Aufgabe, sondern strukturiert mit Hilfe einer guten Planung an die Aufgabe herangehen, 

aber nicht übermütig werden, da ich jetzt auch wieder gesehen habe, wie aus scheinbar 

einfachen Aufgaben schwierige werden können. 


9. Unterschriften 


Die lernende Person bestätigt mit ihrer Unterschrift diese IPA aus Eigenleistung erbracht und 

nach den Vorgaben der Prüfungskommission Informatik Kanton Bern erstellt zu haben. Die 

Angaben im Arbeitsjournal entsprechen dem geleisteten Arbeitsaufwand. 

Datum Name / OE Unterschrift 

Tabelle 18: Unterschriften 

Lernende 

Fachvorgesetzter 


Teil 2: Projektdokumentation 

IPA Projektname: ResMan Reporting 

Autor: Schnabel Elisa 

Abbildung 3:HERMES Phasenmodel für beide Projekttypen 


Da ich als Projektmethode Hermes verwende, wähle ich für dieses Projekt den Projekttyp 

„Systementwicklung“, da ich das Teilsystem Reporting neu für eine bestehende Applikation 

implementiere und nicht editiere bzw. erweitere. 


10. Voranalyse 

10.1 Analyse Ist Zustand / Soll-Zustand 

10.1.1 Ist- Zustand 


Das ResMan Projekt soll die Auslastung der Mitarbeitenden in den Abteilungen des Ressort 

TCSB vereinfachen. Die durch das Tool gewonnene Übersicht der einzelnen Ressourcen 

soll helfen, die Planung anstehender Projekte effizienter durchführen zu können. Die Grundfunktionalitäten 

wurden bereits entwickelt. Es ist also mit dem jetzigen Stand der Applikation 

bereits möglich, die Auslastung einzelner Mitarbeiter zu überwachen und zu planen. Die aktuelle 

Version erlaubt aber nur die Sicht auf eine Ressource gleichzeitig. 

Da die wesentlichen Module der ResMan- Applikation ja schon von uns entwickelt wurden, 

steht mir die fertig konfigurierte Entwicklungsumgebung mit all den von uns verwendeten 

Frameworks wie JSF / PrimeFaces, Spring, JPA und das Framework von Stefan Heller, welches 

die CRUD Funktionalitäten auf dem Web- Service- und Domain-Layer zur Verfügung 

stellt, für die IPA zur Verfügung. Die komplette Datenbank mit den notwendigen Testdaten, 

welche die ResMan Applikation benötigt, steht mir ebenfalls zur Verfügung. 

10.1.2 Soll- Zustand 

Im Rahmen des Moduls ResMan-Reporting soll u.a. die Organisationseinheit-weite Sicht 

über die Auslastung der Mitarbeiter möglich gemacht werden. 

Das Modul soll mit der im ResMan bereits verwendeten Programmiersprache Java und den 

Frameworks JSF, PrimeFaces, Spring und JPA umgesetzt werden. Ausserdem soll die 

bestehende Schichtentrennung der Applikation, die mit einer drei Schichten Architektur 

erreicht wurde, auch im Unterprojekt ResMan- Reporting strikt eingehalten werden. 

Mit Hilfe einer Suchmaske soll es den Führungspersonen möglich gemacht werden, die 

Auslastungsdaten einzelner Mitarbeiter oder auch aus einer ganzen Organisationseinheit 

abfragen zu können oder Daten nach bestimmten Kriterien zusammenzustellen. 

Dazu sollen auf der Suchmaske bestimmte Filterkriterien eingegeben werden können, auf 

Grund derer dann die Auslastungsdaten zusammengestellt werden. Die Kriterien sind die 

Organisationseinheit, die Resource, die Zeitspanne (von Datum / bis Datum), das Projekt, 

die Projektaufgabe, Aufgabe, die Granularität (Wie sollen die Ergebnisse präsentiert werden, 

z.B. Tag, Woche, Monat. In dem Sinne kein eigentliches Filterkriterium) und der 

Auslastungswert in Stunden (von / bis). 

Die OE und die Resource sollen mit Hilfe eines Dropdowns ausgewählt werden können. Die 

Zeitspanne soll mit Hilfe eines „Datepickers“ oder mit Hilfe von Radiobuttons gewählt werden 

können. Das Projekt und die Projektaufgabe sollen mit Hilfe eines Dropdowns und die 

Aufgabe mittels Autocompleter ausgewählt werden können. Der Auslastungswert soll mittels 

Eingabefeldern gesetzt werden können. 

Die somit entstandene Liste der Auslastungsdaten soll anschliessend in einer Tabelle 

dargestellt werden. Die Tabelle soll unter anderem eine Sortierung der abgefragten Daten 

gewährleisten können. Ausserdem soll mittels Drill-Down Funktion die Möglichkeit gegeben 

werden, die Daten detaillierter anschauen zu können. 

Mit Hilfe von “Export Buttons“ unterhalb der Tabelle soll ausserdem die Möglichkeit gegeben 

werden, die Daten in der Tabelle in ein CSV File, XLSX und PDF zu exportieren. 

Die eingegebenen Filterkriterien, nach denen die Daten zusammengestellt werden, sollen 

auf Wunsch auch abgespeichert werden können (Schnellliste), so dass sie wieder abrufbar 

sind. Das bringt den Vorteil, dass häufig verwendete Filterkriterien nicht immer wieder neu 

eingegeben werden müssen. 


10.2 Pflichtenheft / Systemanforderungen 


In den nachfolgenden Tabellen sind die einzelnen Systemanforderungen (MUSS und KANN) 

des Moduls ResMan-Reporting aufgelistet. 

10.2.1 Muss- Kriterien 

Kriterium Bezeichnung Beschreibung 

1.0 Abfrage der Auslastungsdaten 

einzelner Mitarbeiter 

oder aus einer ganzen OE. 

Eine Führungsperson muss mit Hilfe einer 

Suchmaske Filterkriterien eingeben können. Anhand 

derer müssen dann die Auslastungsdaten 

zusammengestellt werden und in Form einer 

Tabelle angezeigt werden. 

2.0 Auslastungsdaten sortieren. Eine Führungsperson muss die Auslastungsdaten 

in der Tabelle sortieren können. 

3.0 Auslastungsdaten in CSV 

Datei exportieren. 

Eine Führungsperson muss auf Wunsch die Daten 

aus der Tabelle in eine CSV- Datei exportieren 

können. 

4.0 Filterkriterien abspeichern Eine Führungsperson muss die eingegebenen 

Filterkriterien abspeichern können, so dass sie 

jederzeit wieder abrufbar sind. 

Tabelle 19: Pflichtenheft Muss Anforderungen 

10.2.2 Kann- Kriterien 

Kriterium Bezeichnung Beschreibung 

5.0 Auslastungsdaten in PDF 


6.0 Auslastungsdaten in Excel 


7.0 Drill-Down / Drill-Up 

Navigation 

Tabelle 20: Pflichtenheft Kann Anforderungen 

Eine Führungsperson kann auf Wunsch die Daten 

aus der Tabelle in ein PDF exportieren. 

Eine Führungsperson kann auf Wunsch die Daten 

aus der Tabelle in ein Excel exportieren. 

Eine Führungsperson kann mittels Drill-Down/ 

Drill-Up Navigation die detaillierte Ansicht der 

Daten anschauen. 


10.3 Varianten 


Da die ResMan Applikation bereits mit der Programmiersprache Java und den Frameworks 

JSF / PrimeFaces, Spring und JPA entwickelt wurde, sind diese auch für das Modul ResMan 

Reporting einzusetzen. Daher gibt es von der Technologie her grundsätzlich keinen Variantenentscheid. 

Jedoch gibt es beim Datenexport verschiedene Varianten, die zu prüfen sind. 

10.3.1 Export in CSV Datei 

10.3.1.1 Variante 1- Exporter von PrimeFaces nutzen 

PrimeFaces bietet eine Komponente DataExporter an, die es ermöglicht, die Daten aus der 

Datentabelle in eine CSV Datei zu exportieren. 

Mit dieser Variante ist der Entwicklungs-und Lernaufwand sehr gering. Ausserdem ist diese 

Komponente in einem von uns verwendeten Framework bereits vorhanden. 

10.3.1.2 Variante 2- Java Bibliothek CSV nutzen 

Es gibt eine Java CSV Open-Source-Java-Bibliothek welche Klassen zum Lesen und 

Schreiben von CSV und einfache Textdateien anbietet. Die Bibliothek unterstützt alle Arten 

von CSV. 

Der Entwicklungs- und Lernaufwand und somit auch der Aufwand für die Wartung, sind bei 

dieser Variante deutlich höher als bei der Variante 1. Ein Minuspunkt ist bei dieser Variante 

auch, dass ich zusätzliche Libraries einbinden müsste. 

10.3.2 Export in PDF Datei 



Datentabelle in eine PDF Datei zu exportieren. 

Mit dieser Variante ist der Entwicklungs-und Lernaufwand sehr gering. Ausserdem ist diese 

Komponente in einem von uns verwendeten Framework bereits vorhanden. 

10.3.2.2 Variante 2- Java und iText Bibliothek nutzen 

iText ist eine frei verfügbare Programmierschnittstelle zur dynamischen Erzeugung und Bearbeitung 

von PDF-Dateien mittels der Programmiersprache Java. 

Auch bei dieser Variante ist der Entwicklungs- und Lernaufwand dementsprechend auch der 

Aufwand für die Wartung deutlich grösser als bei der Variante 1. Ein weiterer Nachteil dieser 

Variante ist auch, dass sie nicht in einem von uns verwendeten Framework vorhanden ist. 


10.3.3 Export in Excel Datei 




Datentabelle in eine Excel Datei zu exportieren. 

Mit dieser Variante ist der Entwicklungs-und Lernaufwand wie auch beim PDF und CSV Export 

sehr gering. Ausserdem ist diese Komponente in einem von uns verwendeten Framework 

bereits vorhanden. 

10.3.3.2 Variante 2- Java Bibliothek nutzen 

POI ist Open-Source-Software, die Java-APIs zum Lesen und Schreiben von Dateien im Dateiformat 

von Microsoft Office wie z. B. Word und Excel bereitstellt. 

Diese Variante wäre deutlich aufwändiger als die Variante 1, da ich mir dazu erst das nötige 

Wissen aneignen müsste und später dann auch die Person, welche die Applikation wartet. 


10.4 Variantenentscheid 


Für die Variantenentscheide wurde eine Nutzwertanalyse erstellt. Die nachfolgende Tabelle zeigt diese. Das V steht für die jeweilige Variante und das 

W steht für den errechneten Wert. Jedes erstellte Kriterium erhält eine Gewichtung. Den Varianten werden pro Kriterium Punkte vergeben 

(min 0, max 3). Die erreichten Punkte werden mit der Gewichtung multipliziert. So erhält man den Endwert. Die Variante mit den meisten 

Punkten setzt sich durch. 

Kriterium Gewichtung 

(1-5) 

Tabelle 21:Nutzwertanalyse 

Wie man der Nutzwertanalyse entnehmen kann, ist die Entscheidung klar: Ich entscheide mich bei dem CSV, PDF sowie bei dem Excel Export für die 

Variante 1. Für die Export Funktion werde ich also den PrimeFaces Exporter einsetzen 

. 

CSV PDF Excel 

V 1 W1 V2 W2 V1 W1 V2 W1 V1 W1 V2 W2 

Abdeckung Anforderungen 5 3 15 3 15 3 15 3 15 3 15 3 15 

Kosten 5 3 15 3 15 3 15 3 15 3 15 3 15 

Entwicklungsaufwand 3 3 9 1 3 3 9 1 3 3 9 1 3 

Bereits in einem von uns eingesetzten 

Framework vorhanden 

(Wartbarkeit) 

Lernaufwand (Wissensbeschaffung, 

Wartbarkeit) 

4 3 12 0 0 3 12 0 0 3 12 0 0 

2 3 6 1 2 3 6 2 4 3 6 1 2 

Total: 57 35 57 37 57 35 


10.5 Informationssicherheit und Datenschutz 


Die Daten, mit denen in der ResMan Applikation gearbeitet wird, sind besonders schützenswert. 

Es handelt sich hierbei um persönliche Daten wie Namen und Passwörter. Durch das 

JPA Framework und durch das Validieren der Eingaben werden die Daten vor SQL- Injektion 

geschützt. Ausserdem sind die Daten nur für Personen mit bestimmten Berechtigungen ersichtlich. 

Dafür sorgt die Benutzeridentifikation der ResMan Anwendung. 


11. Konzept 


Das Konzept beschreibt die Anwendungsfälle, die zusätzlich als Anwendungsfalldiagramm 

dargestellt werden. Die GUI- Skizzen zeigen einen ersten Entwurf des Layouts. Das Testkonzept 

beschreibt, wie wo was getestet wird. Das Klassendiagramm und Komponentendiagramm 

werden in die Realisierungsphase verschoben, da dort die fertige Architektur gezeigt 

wird. 

11.1 Anwendungsfälle 

In diesem Kapitel befinden sich das Anwendungsfalldiagramm, dessen Beschreibungen und 

die einzelnen Aktivitätsdiagramme. 

11.1.2 Anwendungsfall-Diagramm 

Das nachfolgende Anwendungsfall Diagramm zeigt alle Anwendungsfälle des Moduls Resman 

Reporting. Insgesamt gibt es sieben verschiedene Anwendungsfälle. Es gibt jeweils nur 

einen Aktor und dies sind die Gruppenleiter des Ressort TCSB. 

Abbildung 4:UseCase Diagramm 


11.1.3 Beschreibung der Anwendungsfälle 


Nachfolgend werden alle Anwendungsfälle, die bereits im Anwendungsfalldiagramm aufgezeigt 

wurden, detailliert beschrieben. 

11.1.3.1 Anwendungsfall Filterkriterien abspeichern 

Nr.: 01 

Name: Filterkriterien abspeichern 

Aktoren: System (S), Gruppenleiter (A) 

Kurzbeschreibung: Die eingegebenen Filterkriterien werden in der Datenbank abgespeichert. 

Auslösendes Ereignis: A: ruft die Seite reporting.xhtml auf. (GUI-Nr. 02) 

Eingehende Daten: OE, Resource, Datum von, Datum bis, Projekt, Projektaufgabe, 

Aufgabe, Auslastungswert von bis, Granularität. 

Ausgehende Daten: GUI-Nr. 03 

Ergebnis: Die Kriterien befinden sich in der Datenbank. 

Vorbedingungen: Die Tabelle reporting_criteria besteht bereits 

Normalablauf (NA): 1. A: ruft die Seite „reporting.xhtml“ auf.(GUI-Nr 01) 

2. S: initialisiert die Daten 

3. S: baut den Komponentenbaum auf 

4. A: gibt die erforderlichen Filterkriterien ein. 

5. A: drückt auf die Schaltfläche [Speichern]. 

6. S: validiert die Eingaben. 

7. S: legt die Filterkriterien in der Datenbank ab. 

Alternativablauf (AA): Validierungsfehler 

NA 1-6 

7. S: gibt die Validierungsfehler als Meldung aus. 

Validierungsregeln: 1. Die Organisationseinheit ist ein Pflichtfeld. 

2. Datum von, Datum bis sind Pflichtfelder. 

3. Angabe einer Granularität ist Pflicht. 

4. Das Datum von muss kleiner gleich dem Datum bis sein. 

5. Der Auslastungswert von muss kleiner gleich dem Auslastungswert 

bis sein. 

Weitere Regeln: 1. Resource Dropdown wird erst aktiviert, wenn eine Organisationseinheit 

ausgewählt wurde. 

2. Projektaufgabe Dropdown wird erst aktiviert, wenn ein 

Projekt ausgewählt wurde. 

3. Wenn die Radiobuttons angewählt werden(z.B. aktuelle 

Woche), werden automatisch die Datumsfelder mit dem 

entsprechenden Datum abgefüllt. 

Tabelle 22: UseCase Filterkriterien abspeichern 



11.1.3.1.1 Aktivitätsdiagramm UseCase 01 

Das nachfolgende Aktivitätsdiagramm zeigt den Ablauf des Anwendungsfalls 01 (Filterkriterien 

abspeichern). 

Abbildung 5: Activity Diagramm UseCase 01 


11.1.3.2 Anwendungsfall Auslastungsdaten abfragen 

Tabelle 23: UseCase Auslastungsdaten abfragen 


Nr.: 02 

Name: Auslastungsdaten abfragen 


Kurzbeschreibung: Die Auslastungsdaten der Mitarbeiter werden auf Grund der Filterkriterien 

zusammengestellt. 

Auslösendes Ereignis: A: ruft die Seite reporting.xhtml auf. (GUI-Nr. 02) 

Eingehende Daten: OE, Resource, Datum von, Datum bis, Projekt, Projektaufgabe, 

Aufgabe, Auslastungswert, Granularität. 

Ausgehende Daten: Auslastungsdaten der Mitarbeiter (GUI-Nr. 04) 

Ergebnis: Die Mitarbeiter werden in der Resultat Tabelle angezeigt 

Vorbedingungen: Es existieren bereits Daten in der DB. 

Normalablauf (NA): 1. A: ruft die Seite „reporting.xhtml“ auf. 

2. S: initialisiert die Daten 

3. S: baut den Komponentenbaum auf 

4. A: gibt die erforderlichen Filterkriterien ein. 

5. A: betätigt die Schaltfläche [Suchen] 

6. S: validiert die Eingaben 

7. S: liest alle Mitarbeiter mit der entsprechenden OU aus der DB. 

8. S: berechnet die Arbeitstage mit den dazugehörigen Arbeits 

Stunden aufgrund der Zeitspanne und der Filterkriterien. 

9. Je nach Granularität werden die Arbeitsstunden auf den Tagen 

pro Woche oder pro Monat zusammengerechnet. 

10. S: gibt die berechneten Daten in der Resultat Tabelle aus. 

Alternativablauf (AA): Validierungsfehler 

NA 1-6 

7. S: gibt die Validierungsfehler als Meldung aus. 

Validierungsregeln: 1. Die Organisationseinheit ist ein Pflichtfeld 

2. Datum von, Datum bis sind Pflichtfelder 

3. Das Datum von muss kleiner gleich dem Datum bis sein 

4. Angabe einer Granularität ist Pflicht. 

5. Der Auslastungswert von muss kleiner gleich dem Auslastungswert 

bis sein. 

Weitere Regeln: 1. Resource Dropdown wird erst aktiviert, wenn eine Organisationseinheit 

ausgewählt wurde. 

2. Projektaufgabe Dropdown wird erst aktiviert, wenn ein 

Projekt ausgewählt wurde. 

3. Wenn die Radiobuttons angewählt werden(z.B. aktuelle Woche), 

werden automatisch die Datumsfelder mit dem entsprechenden 

Datum abgefüllt. 


11.1.3.3 Anwendungsfall Daten sortieren 


Nr.: 03 

Name: Daten sortieren 


Kurzbeschreibung: Die berechneten Daten in der Resultat Tabelle werden sortiert. 

Auslösendes Ereignis: A: betätigt das „Sortieren“ Icon in der zu sortierenden Spalte. 

Eingehende Daten: Keine 

Ergebnis: Die Daten in der Resultat Tabelle liegen nach dem entsprechenden 

Wert sortiert vor. 

Vorbedingungen: UseCase 02 Auslastungsdaten abfragen. 

(Es wurden Mitarbeiter gefunden) 

Normalablauf (NA): 1. A: drückt auf das „Sortieren“ Icon in der zu sortierenden 

Spalte. 

2. S: sortiert die Daten in der gewünschten Spalte. 

Alternativablauf (AA): - 

Validierungsregeln: - 

Weitere Regeln Bei der Sortierung der Daten müssen die alphanummerischen sowie 

die nummerischen Werte berücksichtigt werden. 

Tabelle 24: UseCase Daten sortieren 

11.1.3.4 Anwendungsfall Datenexport CSV 

Nr.: 04 

Name: Datenexport CSV 


Kurzbeschreibung: Die Daten in der Resultat Tabelle werden in eine CSV Datei exportiert. 

Auslösendes Ereignis: A: betätigt das „CSV Export“ Icon. 

Eingehende Daten: Auslastungsdaten in der Resultat Tabelle 

Ausgehende Daten: CSV Datei 

Ergebnis: Die Daten befinden sich in einer CSV Datei. 

Vorbedingungen: UseCase 02 Auslastungsdaten abfragen 

(Es wurden Mitarbeiter gefunden). 

Normalablauf (NA): 1. A: drückt auf das „CSV Export“ Icon unterhalb der Resultat 

Tabelle. 

2. S: exportiert die Daten in eine CSV Datei. 

3. S: lädt die Datei herunter und speichert sie im Download 

Ordner ab. 



Tabelle 25: UseCase Datenexport CSV 


11.1.3.5 Anwendungsfall Datenexport PDF 


Nr.: 05 

Name: Datenexport PDF 


Kurzbeschreibung: Die Daten in der Resultat Tabelle werden in eine PDF Datei exportiert. 

Auslösendes Ereignis: A: betätigt das „PDF Export“ Icon. 


Ausgehende Daten: PDF Datei 

Ergebnis: Die Daten befinden sich in einer PDF Datei. 



Normalablauf (NA): 1. A: drückt auf das „PDF Export“ Icon unterhalb der Resultat 

Tabelle. 

2. S: exportiert die Daten in eine PDF Datei. 

3. S: lädt die Datei herunter und speichert sie im Download 

Ordner ab. 



Tabelle 26: UseCase Datenexport PDF 

11.1.3.6 Anwendungsfall Datenexport Excel 

Nr.: 06 

Name: Datenexport Excel 


Kurzbeschreibung: Die Daten in der Resultat Tabelle werden in eine Excel Datei exportiert. 

Auslösendes Ereignis: A: betätigt das „Excel Export“ Icon. 


Ausgehende Daten: Excel Datei 

Ergebnis: Die Daten befinden sich in einer Excel Tabelle. 



Ablauf: 1. A: drückt auf das „Excel Export“ Icon unterhalb der Resultat 

Tabelle. 

2. S: exportiert die Daten in eine Excel Datei. 

3. S: lädt die Datei herunter, speichert sie im Download 

Ordner ab. 

Alternativablauf (NA): - 


Weitere Reglen Excel unterstütz nur 255 Spalten. Deshalb wird die Excel Exportfunktion 

deaktiviert, falls die Resultattabelle mehr als 255 Spalten enthält. 

Tabelle 27: UseCase Datenexport Excel 


11.1.3.7 Anwendungsfall Drill Down / Drill Up Navigation 


Nr.: 07 

Name: Drill Down / Drill Up Navigation 


Kurzbeschreibung: Wenn der Aktor auf eine Spalte in der Tabelle klickt, wie z.B. in den 

Monat Juli, soll die Tabelle aktualisert werden und nur noch den Monat 

Juli detailliert anzeigen. 

Auslösendes Ereignis: Klick auf den Header der gewünschten Spalte in der Tabelle. 

Eingehende Daten: - 

Ergebnis: Es erscheint die detaillierte Ansicht auf die Daten in der Tabelle. 



Ablauf: 1. A: klickt auf den Header der gewünschten Spalte in der Tabelle. 

2. S: Zeigt die detaillierte Sicht auf die Daten in der Tabelle. 

Alternativablauf (NA): - 


Tabelle 28: UseCase Drill Down / Drill Up Navigation 



11.1.3.7.1 Aktivitätsdiagramm UseCases 02- 07 

Das nachfolgende Aktivitätsdiagramm beschreibt die Abläufe der Anwendungsfälle 2-7. Die 

Anwendungsfälle wurden aufgrund der Nachvollziehbarkeit in dem gleichen Aktivitätsdiagramm 

zusammengefasst. 

Abbildung 6: Activity Diagramm UseCase 02-07 


11.2 GUI Entwürfe 


Im Modul ResMan Reporting gibt es insgesamt vier verschiedene grafische Benutzeroberflächen. 

1. die Suchmaske / Erfassungsmaske, 

2. die Detailansicht der abgespeicherten Suchparameter, 

3. die Tabelle mit den gespeicherten Suchparametern (Schnellliste) und 

4. die Tabelle mit den Auslastungsdaten. 

11.2.1 Schnellliste Filterkriterien GUI-Nr. 01 

Die nachfolgende GUI- Skizze zeigt die Schnellliste des Moduls ResMan Reporting. In der 

Tabelle sind alle definierten Filterkriteriensets ersichtlich, welche vom aktiven User abgespeichert 

wurden. Mit einem Klick auf das Bearbeiten- Icon in der letzten Spalte erscheint die 

Suchmaske GUI-Nr. 02, in welcher dann die Kriterien bereits abgefüllt wurden. Es besteht 

ausserdem auch die Möglichkeit, die Kriterien zu löschen. 

Abbildung 7: GUI-Nr. 01 Schnellliste 


11.2.2 Suchmaske / Erfassungsmaske GUI- Nr. 02 


Die nachfolgende GUI- Skizze zeigt die Suchmaske bzw. Erfassungsmaske des Moduls 

ResMan Reporting. Auf dieser Maske können die Gruppenleiter ihre gewünschten Filterkriterien 

eingeben, eine Suche starten und / oder die Kriterien abspeichern. 

Abbildung 8: GUI-Nr. 02 Suchmaske/ Erfassungsmaske für die Schnellliste 


11.2.3 Detailansicht Filterkriterien GUI-Nr. 03 


Die nachfolgende GUI-Skizze zeigt die detaillierte Sicht auf die Filterkriterien. Diese Seite 

erscheint nachdem die Kriterien abgespeichert wurden. Betätigt man die Schaltfläche [Zurück 

zur Suche], gelangt man wieder auf das Suchformular (GUI-Nr. 02). 

Abbildung 9:GUI-Nr. 03 Detailansicht 


11.2.4 Trefferliste (Falls keine explizite Resource gewählt wurde) GUI-Nr. 04 


Die nachfolgende GUI-Skizze zeigt die Trefferliste des Moduls ResMan Reporting an. Die 

Tabelle ist dynamisch und zeigt je nach gewählter Zeitspanne und Granularität ein andere 

Anzahl Spalten an. Wenn keine explizite Ressource gewählt wird, wird die Gesamtauslastung 

der OE mitangezeigt. Das nachfolgende Beispiel zeigt die Auslastung einer OE für ein 

ganzes Jahr. Die Granularität ist hierbei der Monat. Jede Spalte in der Tabelle ist sortierbar. 

Unterhalb der Tabelle befinden sich ausserdem die Export Buttons, mittels welcher die Daten 

der Tabelle in das jeweilige Format exportiert werden können. 

Abbildung 10:GUI-Nr. 04 Trefferliste 

Anmerkung: Aufwandshalber wurden nur die ersten drei Spalten der Tabelle mit Werten 

ausgefüllt. 



11.2.6 Trefferliste (Im Falle, dass eine explizite Resource gewählt wurde) GUI-Nr. 04 

Die nachfolgende GUI-Skizze zeigt ebenfalls die Trefferliste des Moduls ResMan Reporting 

an. Der Unterschied zur bereits weiter oben gesehenen Trefferliste ist hierbei, dass eine explizite 

Resource gewählt wurde. In diesem Falle wird nämlich nicht die ganze OE gezeigt 

sondern nur die gewählte Resource. Die gewählte Granularität in diesem Beispiel ist der 

Tag. 

Abbildung 11:GUI-Nr. 04 Trefferliste Resource 


11.3 Testkonzept 


Sogenannte Whitebox-Tests werden während der Entwicklung bereits vom Entwickler 

durchgeführt. Nach jeder grösseren Änderung oder Neuerung wird das gesamte Modul getestet, 

um das korrekte Zusammenspiel der einzelnen Komponenten sicherzustellen. In diesem 

Testkonzept wird beschrieben, wie die Applikation nach der Implementierung getestet 

werden soll. 

11.3.1 Testziele 

Ziel des Testverfahrens ist es, eventuelle, vom Entwickler noch nicht entdeckte Fehler der 

Applikation aufzudecken. Es soll sichergestellt werden, dass die erstellte Applikation den 

Anforderungen entspricht. 

11.3.2 Testverfahren 

Die Applikation wird von einem Mitarbeiter getestet. Die Tests werden anhand der definierten 

Testfälle im QC durchgeführt. Ich werde bei der Durchführung der Tests dabei sein, um sie 

zu protokollieren und bei Bedarf die Testfälle zu erläutern und Unklarheiten zu klären bzw. 

die Testfälle zu verfeinern. 

Gefundene Bugs werden nach den Tests vom Entwickler behoben und anschliessend erneut 

getestet. Dieses Verfahren dauert solange an, bis keine Fehler mehr gefunden wurden. 

Neben den Anwendertests wird zusätzlich ein JUnit- Test erstellt, der die Berechnungslogik 

des Moduls testet. 

11.3.3 Auswertung 

Die Auswertung der Anwendertests wird in einem ausgefüllten Testprotokoll festgehalten. 

Dabei ist zu unterscheiden zwischen bestanden und nicht bestanden. Die Applikation hat 

den Test bestanden, sobald alle der zu testenden Funktionen ohne Probleme durchgeführt 

werden konnten. Ansonsten gilt der Test als nicht bestanden. 

11.3.4 Testumgebung 

Die Tests werden an unserem Testserver durchgeführt (http://resman-test.tcsb.admin.ch), 

auf den ich das fertige Modul deployen werde. Durch die Tests führt das Quality Center. 

11.3.4.1 Test-Benutzeraccount 

Für die Durchführung der Tests wird der Testaccount benutzt. Die Login Daten hierfür sind 

die folgenden: 

Benutzername: seco-tes 

Passwort : 12345678 


11.3.5 Testspezifikation 


Nachfolgend sind die einzelnen Testfälle des Moduls ResMan Reporting aufgelistet. Die hier 

aufgeführten Tests wurden zusätzlich im Quality Center erfasst. 

Filterkriterienset abspeichern 

Nummer T 1.0 

QC Nummer 27 

Beschreibung Ein Benutzer speichert ein neues Filterkriterienset ab. 

Vorbedingungen Keine 

Ablauf Beschreibung Erwartung 

Tabelle 29:Testfall 1.0 

Bei Toplevelnavigation auf 

Schaltfläche [Reporting] klicken. 

Auf das „neue Suche“ Icon 

rechts oberhalb der Tabelle klicken. 

Die Felder: 

-OE 

-Ressource 

-Datum- von / bis 

-Granularität 

-Projekt 

-Projektaufgabe 

-Aufgabe 

-Auslastung von –bis 

können ausgefüllt werden. 

Auf Schaltfläche [Speichern] 

klicken. 

Es erscheint die Maske Schnellliste. 

In der Tabelle befinden sich alle vom 

aktiven User erfassten Filterkriteriensets. 

Es erscheint die Suchmaske / Erfassungsmaske. 

Es erscheint die Maske Detailansicht. 

Sie zeigt alle soeben abgespeicherten 

Filterkriterien an. 


Filterkriterienset abspeichern mit Validierungsfehlern 

Nummer T 1.1 

QC Nummer 27 



Beschreibung Ein Benutzer versucht ein neues Filterkriterienset abzuspeichern und löst 

dabei Validierungsfehler aus. 







Die Felder: 

-OE 

-Ressource 



-Projekt 


-Aufgabe 


Erscheinen. 


klicken, ohne ein Feld auszufüllen. 

Es erscheint die Maske Schnellliste. In der 

Tabelle befinden sich alle vom aktiven User 

erfassten Filterkriteriensets. 


Es werden die folgenden Validierungsmeldungen 

ausgegeben: 

-Bitte erfassen Sie eine OE 

-Bitte erfassen Sie ein Datum von 

-Bitte erfassen Sie ein Datum bis 

-Bitte geben Sie eine Granularität an. 


Filterkriterienset bearbeiten 

Nummer T 2.0 

QC Nummer 27 



Beschreibung Ein Benutzer bearbeitet ein bestehendes Filterkriterienset in der Schnellliste. 

Vorbedingungen Es sind Filterkriteriensets in der Schnellliste vorhanden. 




Auf das Icon „bearbeiten / suchen“ 

in der letzten Spalte des 

gewünschten Eintrages klicken. 

Die Felder: 

-OE 

-Ressource 



-Projekt 


-Aufgabe 


Können mutiert werden. 


klicken. 



erfassten Filterkriteriensets 


Es erscheint die Maske Detailansicht. Sie 

zeigt alle gewählten Filterkriterien an. 


Report zusammenstellen ohne Eintrag aus Schnellliste 

Nummer T 3.0 

QC Nummer 27 



Beschreibung Ein Benutzer stellt einen Report (Auslastungsdaten) ohne Eintrag aus der 

Schnellliste zusammen. 







Die Felder: 

-OE 

-Ressource 



-Projekt 


-Aufgabe 


Können ausgefüllt werden. 

Auf Schaltfläche [Suchen] klicken. 





Es erscheint die Maske Trefferliste. In der 

Tabelle stehen die Auslastungsdaten, die 

anhand der eingegebenen Filterkriterien 

zusammengestellt / berechnet wurden. 

Falls keine explizite Resource gewählt 

wurde, befindet sich in der ersten Zeile der 

Tabelle die Gesamtauslastung aller Mitarbeiter. 


Report zusammenstellen mit Eintrag aus Schnellliste 

Nummer T 3.1 

QC Nummer 27 



Beschreibung Ein Benutzer stellt einen Report (Auslastungsdaten) zusammen mittels eines 

Filterkriteriensets aus der Schnellliste. 

Vorbedingungen Es sind Filterkriteriensets in der Schnellliste vorhanden. 
















Falls keine explizite Resource gewählt 

wurde, befindet sich in der ersten Zeile der 

Tabelle die Gesamtauslastung aller Mitarbeiter. 


Report zusammenstellen mit Validierungsfehlern 

Nummer T 3.2 

QC Nummer 27 



Beschreibung Ein Benutzer versucht einen Report zusammen zu stellen und löst dabei Validierungsfehler 

aus. 





Auf das Icon „neue Suche“ 

rechts oberhalb der Schnellliste 

klicken. 

Die Felder: 

-OE 

-Ressource 



-Projekt 


-Aufgabe 


erscheinen. 

Auf Schaltfläche [Suchen] klicken, 

ohne ein Feld auszufüllen. 





Es werden die folgenden Validierungsmeldungen 

ausgegeben: 

-Bitte erfassen Sie eine OE 

-Bitte erfassen Sie ein Datum von 

-Bitte erfassen Sie ein Datum bis 

-Bitte geben Sie eine Granularität an. 


Auslastungsdaten sortieren 

Nummer T 4.0 

QC Nummer 27 

Beschreibung Ein Benutzer sortiert die Auslastungsdaten in der Trefferliste. 

Vorbedingungen Erfolgreicher Ausgang von Testfall Nr. 3.0 oder 3.1 




Bei Toplevelnavigation auf Schaltfläche 

[Reporting] klicken. 









Auf Schaltfläche [Suchen] klicken. Es erscheint die Maske Trefferliste. In der 




Auf das Icon „sortieren“ (Pfeil) in 

der zu sortierenden Spalte klicken. 

Auslastungsdaten in CSV exportieren 

Nummer T 5.0 

QC Nummer 27 

Die Daten in der Tabelle liegen nach der 

gewünschten Spalte sortiert vor. 

Beschreibung Ein Benutzer exportiert die Daten in der Trefferliste in ein CSV File. 









Auf das Icon „CSV Export“ klicken. 









Es wurde eine CSV Datei erstellt, die alle 

Daten aus der Tabelle beinhaltet. Die Datei 

befindet sich im Download Ordner. 


Auslastungsdaten in PDF exportieren 

Nummer 

QC Nummer 

Beschreibung 

Vorbedingungen 



T 6.0 

27 


Ein Benutzer exportiert die Daten in der Trefferliste in eine PDF Datei. 

Erfolgreicher Ausgang von Testfall Nr. 3.0 oder 3.1 








Auf das Icon „PDF Export“ klicken. 

Auslastungsdaten in Excel exportieren 

Nummer T 7.0 

QC Nummer 27 









Es wurde eine PDF Datei erstellt, die alle 



Beschreibung Ein Benutzer exportiert die Daten in der Trefferliste in ein Excel File. 









Auf das Icon „Excel Export“ klicken. 









Es wurde eine Excel Datei erstellt, die alle 




Filterkriterienset löschen 

Nummer T 8.0 

QC Nummer 27 

Beschreibung Ein Benutzer löscht ein Filterkriterienset aus der Schnellliste. 



Vorbedingungen Es ist mindestens ein Filterkriterienset in der Schnellliste vorhanden. 




Auf das Icon „löschen“ in der 

letzten Spalte des zu löschenden 

Eintrages klicken. 




Es erscheint ein Dialogfenster: „Wollen Sie 

dieses Objekt wirklich löschen?“. 

Auf Schaltfläche [Ja] klicken. Der Eintrag wurde aus der Tabelle entfernt. 


12. Realisierung 


In der Phase Realisierung wurden die in der Voranalyse evaluierten Systemanforderungen 

umgesetzt. 

12.1 Systemdesign 

In diesem Kapitel wird die Architektur des Moduls ResMan Reporting anhand von Klassen-, 

Sequenz- und Komponentendiagrammen erläutert. Übersichtshalber wurde das Klassendiagramm 

in die drei Schichten Web, Service und Persistenz aufgeteilt. Es wurde jedoch in das 

Web und das Service Klassendiagramm jeweils zusätzlich die Interface Klasse der darunterliegenden 

Schicht eingefügt, um die Abhängigkeiten zwischen den drei Schichten zu visualisieren. 

12.1.1 Komponenten Diagramm Architektur 

Das Modul ResMan Reporting wurde in einer „Drei-Schichten-Architektur“ modelliert. Die 

Schichten der Benutzeroberfläche, der Logik und der Datenhaltung wurden durch Interfaces 

voneinander entkoppelt. Da sich die Entitäten in der Persistenzschicht befinden, und die 

Webschicht nicht auf die Persistenzschicht zugreifen darf, werden sogenannte DTOs eingesetzt, 

welche die Daten zwischen der Web- und Serviceschicht transportieren. Da per Definition 

die Web nur Abhängigkeiten auf die Serviceschicht haben darf und nicht umgekehrt, 

werden die DTOs in der Serviceschicht zur Verfügung gestellt. 

Die Referenzen zwischen den einzelnen Klassen wird durch die Dependency Injection (DI) 

gehandhabt, welche vom Spring Framework zur Verfügung gestellt wird. 

Die Webschicht stellt die Benutzeroberfläche dar, sie stellt Formulare für die Dateneingabe 

bereit, präsentiert Daten und ist für die Dialogführung zuständig. In der Serviceschicht werden 

die DTOs auf die Entitäten gemappt, welche dann an die Persistenzschicht weitergereicht 

werden. Die Persistenzschicht ist für die Datenspeicherung zuständig. 

Das nachfolgende Diagramm zeigt den Aufbau der Architektur des Moduls ResMan Reporting 

anhand von Komponenten. 

Abbildung 12:Komponenten Diagramm 


12.1.2 Web Layer 


Der Web Layer wurde nach dem Model View Controller (MVC) Pattern aufgebaut. Der View 

entspricht einer XHTML Seite, der Controller der Action und das Model der Modelklasse. 

Die nachfolgende Grafik veranschaulicht das MVC Prinzip mit dessen Zugriffsrechten am 

Beispiel des Moduls ResMan Reporting. Die Action darf auf das Model zugreifen. Umgekehrt 

ist dies aber nicht möglich. Die XHTML Seite greift jeweils auf das Model und auf die Action 

zu. 

Abbildung 13: MVC 



12.1.2.1 Klassendiagramm Web Layer 

Das nachfolgende Klassendiagramm zeigt die Klassen des Web Layers des Moduls ResMan Reporting. In diesem Diagramm sieht man die Modelklassen, 

die Action Klassen und die XHTML Seite. Alle Action Klassen erhalten eine Referenz auf das Model. Die drei Action Klassen BaseDelete, Base- 

Persist und BaseEdit erhalten zusätzlich eine Referenz auf den ReportingService. Die Actionklassen und die Modellklasse haben unterschiedliche Scopes. 

Der RequestScope wird für die Actionklassen und der längerlebige SessionScope für die Modellklasse verwendet. 

Anmerkung: Die Klassen die im Rahmen des Moduls ResMan Reporting erstellt wurden, sind gelb hinterlegt. Die restlichen Klassen, die nicht im Rahmen dieses Moduls 

erstellt wurden, sind grau hinterlegt. Übersichtshalber wurden die getter / setter Methoden weggelassen. 

Abbildung 14:Klassendiagramm Weblayer 


12.1.3 Klassendiagramm Service Layer 


Das nachfolgende Klassendiagramm zeigt die Klassen des Service Layers des Moduls 

ResMan Reporting. Die Service Klasse wird von der Klasse BasePersistenceService abgeleitet. 

Zusätzlich implementiert die ServiceKlasse noch ein Interface, durch welches der Servicelayer 

vom Weblayer entkoppelt wird. Die Klasse Base Persistence Service erhält eine 

Referenz auf das Repository. 

Anmerkung: Die grau hinterlegten Klassen kennzeichnen die Klassen, die bereits in der bestehenden 

Applikation in Verwendung sind. Die gelb hinterlegten Klassen und Interfaces wurden im Rahmen des 

Moduls ResMan Reporting erstellt. Übersichtshalber wurden die getter / setter Methoden in den Klassen 

ReportingCriteria und ReportingCriteriaDto weggelassen. 

Abbildung 15:Klassendiagramm Servicelayer 


12.1.4 Klassendiagramm Persistence Layer 

Abbildung 16:Klassendiagramm Persistenzlayer 


Das nachfolgende Klassendiagramm zeigt die Klassen des Persistenz Layers des Moduls 

ResMan Reporting. Die Klasse JpaReportingRepository enthält keine eigenen Methoden. 

Die Klasse erbt alle Methoden vom JPAExtendedBaseRepository, in welcher auch die ganze 

Speicher „Logik“ abgehandelt wird. 

Anmerkung: Die gelb hinterlegten Klassen wurden im Rahmen des Moduls Resman Reporting erstellt. 

Die grau hinterlegten Klassen kennzeichnen wiederrum die in der Applikation bereits verwendeten 

Klassen.Übersichtshalber wurden die getter / setter Methoden in den Klassen weggelassen. 


12.1.5 Domain Model 

Abbildung 17:Domain Model 


Das nachfolgende Klassendiagramm zeigt alle Entitäten welche im Modul ResMan Reporting verwendet werden. Die Entitäten befinden sich alle im 

Persistenz Layer. Alle Klassen werden von der Superklasse BaseResmanEntity abgeleitet. Da der Persistenzlayer mit JPA umgesetzt wurde, beinhalten 

die einzelnen Klassen noch entsprechende Annotationen wie z.B. @Entity, die vom EntityManager benötigt werden, um die Klassen als Entitäten zu 

identifizieren. 

Anmerkung: Die grau hinterlegten Klassen kennzeichnen die Klassen die bereits in der bestehenden Applikation in Verwendung sind. Die gelb hinterlegte Klasse wurde 

im Rahmen des Moduls ResMan Reporting erstellt. In den Entitäten befinden sich ausschliesslich die entsprechenden Attribute und deren getter / setter Methoden, 

die aber übersichtshalber im Diagramm weggelassen wurden. 


12.1.6 Entity Relationship Diagramm 


Das nachfolgende Entity Relationship Diagramm (ERD) zeigt die Datenbanktabellen, welche 

im Modul ResMan Reporting benutzt werden. Die orange hinterlegten Tabellen kennzeichnen 

diejenigen Tabellen, die schon bereits von der Applikation verwendet werden. Die gelb 

hinterlegte Tabelle wurde im Rahmen des Moduls ResMan Reporting erstellt. In dieser Tabelle 

werden die Filterkriterien abgelegt. Die Tabellen welche die Stammdaten der Applikation 

beinhalten wurden übersichtshalber weggelassen. 

Abbildung 18:ERD ResMan Haupttabellen 


12.1.7 Sequenzdiagramm Benutzer erfassen 


Das nachfolgende Sequenzdiagramm beschreibt den Ablauf im System, wenn ein neues Filterkriterienset abgespeichert bzw. bearbeitet wird. Dieses 

Szenario durchläuft alle drei Schichten der Applikation. Die ReportingPersistAction wird durch die reporting.xhtml Seite aufgerufen, wenn die Schaltfläche 

[Speichern] betätigt wird. Die Klasse ReportingValidator validiert die Eingaben vom Benutzer und gibt ein Boolean valid zurück. Wenn es keine Validierungsfehler 

gibt, wird der Service aufgerufen, in welchem das DTO auf die entsprechende Entität gemappt wird und an das Repository weitergereicht 

wird. Dort wird dann die Entität vom EM persistiert. Die persistierte Entität wird anschliessend wieder an den Servicelayer zurückgegeben, auf das 

DTO gemappt und an den Weblayer zurückgereicht. 

Abbildung 19: Sequenzdiagramm Filterkriterien abspeichern 



12.1.8 Sequenzdiagramm Report zusammenstellen / berechnen 

Das nachfolgende Sequenzdiagramm beschreibt den Ablauf im System, wenn die Auslastungsdaten berechnet bzw. zusammengestellt werden. Die 

ReportingCalculateAction wird von der reporting.xhtml aufgerufen, wenn die Schaltfläche [Suchen] betätigt wird. Die Klasse ReportingValidator validiert 

die Eingaben vom Benutzer und gibt ein Boolean valid zurück. Wenn es keine Validierungsfehler gibt, wird die Berechnung anhand der Filterkriterien 

durchgeführt. Die Berechnung findet auf dem ResourcePayloadCalculator und in der ReportingCalculateAction statt. Nachdem die eigentliche Berechnung 

durchgeführt wurde, werden die Daten für das Model aufbereitet und auf die Modelklasse gesetzt. 

Abbildung 20: SequenzdiagrammBerechnungAuslastungsdaten 


12.2 GUI 


Nachfolgend werden die GUIs aufgezeigt, die im Rahmen des Moduls ResMan Reporting 

entwickelt wurden. Die GUIs wurden anhand der GUI- Skizzen, welche bereits in der Konzeptphase 

erstellt wurden, aufgebaut. 

12.2.1 GUI-Nr. 01 Schnellliste 

Das nachfolgende GUI zeigt die Schnellliste des Moduls ResMan Reporting. In dieser Tabelle 

befinden sich alle Filterkriteriensets, die vom aktiven Benutzer abgespeichert wurden. Betätigt 

man das Icon „bearbeiten /suchen“ in der letzten Spalte der Tabelle, so erscheint die 

Suchmaske / Erfassungsmaske. Auf dieser Maske ist es ausserdem auch möglich, ein Filterkriterienset 

zu löschen. 


12.2.2 GUI-Nr.02 Suchmaske/ Erfassungsmaske 


Das nachfolgende GUI zeigt die Erfassungsmaske/Suchmaske der Filterkriteriensets. Wie 

der Name schon sagt, wird dieses GUI für das Abspeichern eines Filterkriteriensets und für 

die Suche verwendet. Die Eingabefelder, welche mit einem Stern gekennzeichnet sind, sind 

Pflichtfelder. 

12.2.3 GUI- Nr.03 Detailansicht 

Das nachfolgende GUI zeigt die Detailansicht auf ein Filterkriterienset. Dieses GUI wird nur 

dann angezeigt, wenn das Filterkriterienset erfolgreich abgespeichert wurde. 


12.2.4 GUI-Nr. 04 Trefferliste (Wenn keine Ressource gewählt) 


Dieses GUI zeigt die Trefferliste in Form einer dynamischen Tabelle. In der ersten Spalte 

befindet sich die Ressource und in den nachfolgenden Spalten befinden sich die Auslastungswerte. 

Die Anzahl Spalten und die Beschriftung sind abhängig von der gewählten Granularität. 

In der ersten Zeile befindet sich ausserdem die totale Auslastung der gewählten 

OE. Wird eine spezifische Ressource gewählt, wird diese weggelassen. 

12.2.5 GUI-Nr.04 Trefferliste(Wenn eine Ressource gewählt) 

Dieses GUI zeigt ebenfalls die Trefferliste. Dieses GUI ist bis auf eine Ausnahme Identisch 

mit der bereits weiter oben gesehenen Trefferliste. Der einzige Unterschied ist, dass die Gesamtauslastung 

hier weggelassen wird, da in diesem Beispiel eine spezifische Ressource 

gewählt wurde. 


12.3 Screenflow Diagramm 

Das nachfolgende Screenflow Diagramm zeigt die Navigationsmöglichkeiten innerhalb des Moduls ResMan Reporting. 

Abbildung 21:Screenflow 



12.4 Testprotokoll 


Testfall Nr. Testbeschreibung Erwartung Ergebnis OK? Visum 

1.0 Ein Benutzer speichert ein neues Filterkriterienset 

ab. 

1.1 Ein Benutzer versucht ein neues Filterkriterienset 

abzuspeichern und löst dabei Validierungsfehler 

aus. 

2.0 Ein Benutzer bearbeitet ein bestehendes Filterkrite- 

rienset in der Schnellliste. 

3.0 Ein Benutzer stellt einen Report (Auslastungsdaten) 

ohne Eintrag aus Schnellliste zusammen. 

3.1 Ein Benutzer stellt einen Report (Auslastungsdaten) 

zusammen mittels eines Filterkriteriensets aus 

der Schnellliste. 

3.2 Ein Benutzer versucht einen Report zusammen zu 

stellen und löst dabei Validierungsfehler aus. 

4.0 Ein Benutzer sortiert die Auslastungsdaten in der 

Trefferliste. 

5.0 Ein Benutzer exportiert die Daten in der Trefferliste 

in ein CSV File. 


in ein PDF File. 


in ein Excel File. 

8.0 Ein Benutzer löscht ein Filterkriterienset aus der 

Schnellliste. 

Tabelle 40:Testprotokoll 

Das Filterkriterienset befindet sich in der Datenbanktabelle 

reporting_criteria. 

Die entsprechenden Validierungsmeldungen werden 

ausgegeben. 

Die mutierten Felder liegen bearbeitet in der Tabelle 

reporting_criteria vor. 

Auf der Maske Trefferliste erscheint eine Tabelle, 

in der die berechneten Auslastungsdaten stehen. 

Auf der Maske Trefferliste erscheint eine Tabelle, 

in der die berechneten Auslastungsdaten stehen. 

Die entsprechenden Validierungsmeldungen werden 

ausgegeben. 

Die Daten liegen nach der gewünschten Spalte 

sortiert vor. 

Die Daten aus der Trefferliste wurden in ein CSV 

File exportiert, welches sich im Download Ordner 

befindet. 

Die Daten aus der Trefferliste wurden in ein PDF 


befindet. 

Die Daten aus der Trefferliste wurden in ein Excel 


befindet 

Das Filterkriterienset wurde aus der Datenbank 

und somit aus der Schnellliste entfernt. 

Wie erwartet. 


OK 

gid 

Wie erwartet. OK gid 


Wie erwartet. 

OK 

gid 


Wie erwartet. 

OK 

gid 


Wie erwartet. OK 

gid 


Wie erwartet OK gid 

Wie erwartet. OK gid

12.4.1 Testprotokoll aus Quality Center 


Nachfolgend noch das Testprotokoll, welches im Quality Center nach der Durchführung der 

Anwender Tests generiert wurde. 

12.5 JUnit Test 

Neben den Anwendertests wurden zusätzlich acht JUnit Testmethoden erstellt, welche die 

verschiedenen Berechnungen des Moduls ResMan Reporting auf Korrektheit testen. Dabei 

werden auch Dinge getestet, die bei einem normalen Anwendertest nicht so beachtet würden. 

- Die erste Testmethode testet die Anzahl WorkDays, welche für die übergebene Zeitspanne 

erstellt werden. 

- Die zweite testet die Anzahl WorkWeeks, die anhand der übergebenen WorkDay Liste 

erstellt werden. 

- Die dritte Testmethode testet die Anzahl WorkWeeks, die erstellt werden, wenn die 

Zeitspanne über ein Jahr hinaus geht. 

- Die vierte Testmethode testet die Anzahl WorkMonthes, welche anhand der übergebenen 

WorkDay Liste erstellt werden. 

- Die fünfte Testmethode testet die Anzahl WorkMonthes, welche erstellt werden, wenn 

die Zeitspanne über ein Jahr hinaus geht. 

- Die Testmethoden sechs, sieben und acht testen die Arbeitsstunden, welche für das 

übergebene Projekt bzw. Projekttask und Task berechneten werden. 


13. Einführung 


Im Zusammenhang mit der IPA wird für die Phase Einführung ausschliesslich das erweiterte 

Benutzerhandbuch ausgeliefert und am 31. Mai 2013 eine Präsentation mit anschliessender 

Demo durchgeführt. 

Der Go-Live Termin und der Abnahmetermin durch den Kunden, wurden bisher noch nicht 

festgelegt. 


14. Quellenverzeichnis 

14.1 Informationen 

Datenexport 

http://www.primefaces.org/showcase/ui/exporter.jsf 

http://www.opencsv.sourceforge.net 

http://itextpdf.com/ 

http://poi.apache.org/ 

PrimeFaces Dynamische Tabelle 

14.3 Bilder 

http://www.primefaces.org/showcase/ui/datatableDynamicColumns.jsf 

http://balusc.blogspot.ch/2006/06/using-datatables.html#PopulateDynamicDatatable 

Bild Quelle 

Abbildung 1: Projektorganisation Selbst erstellt 

Abbildung 2: Hermes Phasen 


http://old.code.zhdk.ch/projects/madek/attachment/wiki/Ablaufs 

konzept/image1.jpeg 

Abbildung 3:HERMES Phasenmodel http://www.pmaktuell.org/PMAktuell-200902/034-Wissen- 

Mourgue1-GPM 

Abbildung 4:UseCase Diagramm Selbst erstellt 

Abbildung 5: GUI-Nr. 01 Schnellliste Selbst erstellt 

Abbildung 6: GUI-Nr. 02 Suchmaske Selbst erstellt 

Abbildung 7:GUI-Nr. 03 Detailansicht Selbst erstellt 

Abbildung 8:GUI-Nr. 04 Trefferliste Selbst erstellt 

Abbildung 9:GUI-Nr. 04 Trefferliste 2 Selbst erstellt 

Abbildung 10:ERD Selbst erstellt 

Abbildung 11:Komponenten Diagramm Selbst erstellt 

Abbildung 12:Klassendiagramm Web Selbst erstellt 

Abbildung 13:Klassendiagramm Service Selbst erstellt 

Abbildung 14:Klassendiagramm Persistenz 

Selbst erstellt 

Abbildung 15:Domain Model Selbst erstellt 

Abbildung 16: Sequenzdiagramm Filterkriterien 

abspeichern 

Abbildung 17: Sequenzdiagramm Berechnung 

Auslastungsdaten 




15. Glossar 

Begriff Bedeutung 

Tabelle 41: Gloassar 


DI Dependency Injection oder kurz DI ist ein Entwurfsmuster und dient 

in einem objektorientierten System dazu, die Abhängigkeiten zwischen 

Komponenten oder Objekten zu minimieren. 

DTO Ein Data Transfer Object ist ein Entwurfsmuster aus der Softwareentwicklung, 

welches gebraucht wird um Daten zwischen Sybsystemen 

einer Applikation zu transportieren. 

JSF Java Server Faces, oder kurz JSF ist ein Komponentenbasiertes 

Präsentationsframework für Java Webanwendungen. Mit Hilfe von 

JSF kann der Entwickler auf einfache Art und Weise Komponenten 

für Benutzerschnittstellen in Webseiten einbinden und die Navigation 

definieren. 

JPA Die Java Persistence API oder kurz JPA bietet den Java Entwicklern 

die Möglichkeit eines objektorientierten /relationalen Mappings. 

Mit Hilfe dieses Mappings ist es möglich relationale Daten in Java- 

Anwendungen zu verwalten. 

Die Java Persistence API besteht aus drei Bereichen: 

- Die Java Persistence API 

- Die Abfragesprache 

- Object / Relationales Mapping-Metadaten 

MVC Model View Controller (MVC) ist ein Muster zur Strukturierung von 

Software-Entwicklung in die drei Einheiten Datenmodell, Präsentation 

und Programmsteuerung. Ziel des Musters ist ein flexibler Programmentwurf, 

der eine spätere Änderung oder Erweiterung erleichtert 

und eine Wiederverwendbarkeit der einzelnen Komponenten 

ermöglicht. 

PrimeFaces PrimeFaces ist eine JSF-Komponentenbibliothek. 

Spring Das Spring Framework (kurz Spring) ist ein quelloffenes Framework 

für die Java-Plattform. Ziel des Frameworks ist es, die Entwicklung 

mit Java/Java EE zu vereinfachen. Spring bietet mit einem breiten 

Spektrum an Funktionalität eine ganzheitliche Lösung zur Entwicklung 

von Anwendungen und deren Geschäftslogiken. Primäre Features 

für Spring sind die Dependency Injection und das Aspekt orientierte 

Programmieren. 


16. Unterschriften 

Datum Name / OE Unterschrift 



17. Anhang 

17.1 Quellcode 

17.1.1 Klassen Web Layer 

ReportingModel.java 


/** 

* The class ReportingModel contains the data, which are used from the 

* reporting.xhtml site. 

* 

* @author seco-sbi, SECO 

* @since 1.0.0 

* 

*/ 

@Model(scope = Scope.SESSION) 

public class ReportingModel extends BaseWebEntityModel implements Serializable 

{ 

private static final long serialVersionUID = 1L; 

private static final double EMPTY_WORK_HOUR = 0.0; 

private List reportingCriterias; 

private List resources; 

private List projects; 

private List projectTasks; 

private List tasks; 

private boolean ouSelected = false; 

private boolean projectSelected = false; 

private List headers; 

private List dynamicList; 

private HtmlPanelGroup tablePanel; 

/** 

* Constructor 

*/ 

public ReportingModel() { 

setMode(MODE_DETAIL_EDIT); 

} 

@Override 

public ReportingCriteriaDto createNewEntity() { 

return new ReportingCriteriaDto(); 

} 

public List getResources() { 

if (resources == null) { 

return new ArrayList(); 

} 

return resources; 

} 

public void setResources(List resources) { 

this.resources = resources; 

} 

public boolean isOuSelected() { 

return ouSelected; 

} 

public void setOuSelected(boolean ouSelected) { 

this.ouSelected = ouSelected; 

} 


public List getProjects() {

public boolean isOuSelected() { 

return ouSelected; 

} 

public void setOuSelected(boolean ouSelected) { 

this.ouSelected = ouSelected; 

} 

public List getProjects() { 

return projects; 

} 

public void setProjects(List projects) { 

this.projects = projects; 

} 

public List getReportingCriterias() { 

return reportingCriterias; 

} 

public void setReportingCriterias(ListreportingC){ 

this.reportingCriterias = reportingC; 

} 

public List getProjectTasks() { 

if (projectTasks == null) { 


} else { 

return projectTasks; 

} 

} 

public void setProjectTasks(List projectTasks) { 

this.projectTasks = projectTasks; 

} 

public boolean isProjectSelected() { 

return projectSelected; 

} 

public void setProjectSelected(boolean projectSelected) { 

this.projectSelected = projectSelected; 

} 

public List getTasks() { 

if (tasks == null) { 


} else { 

return tasks; 

} 

} 

public void setTasks(List tasks) { 

this.tasks = tasks; 

} 


public boolean isValueInWorkHourRange(float totalWorkHours) { 

if ((double) totalWorkHours >= currentEntity.getWorkHoursFrom() && (double) 

totalWorkHours

} 


public boolean isValueInWorkHourRange(float totalWorkHours) { 

if ((double) totalWorkHours>=currentEntity.getWorkHoursFrom()&&(double) 

totalWorkHours

ReportingPersistAction.java 


/** 

* Action for persisting ReportingCriteria entities 

* 


* @since 1.0.0 

* 

*/ 

@Controller 

public class ReportingPersistAction extends BasePersistAction 

{ 

private final UserService userService; 

private final ReportingValidator validator; 

private static final int FIRST=0; 

/** 

* Constructor 

* 

* @param model 

* @param service 

* @param validator 

*@param userService 

*/ 

@Inject 

public ReportingPersistAction(ReportingModel model, ReportingService service, 

UserService userService, ReportingValidator validator) { 

super(model, service); 

this.userService = userService; 

this.validator = validator; 

} 

@Override 

protected boolean validateCurrentEntity() { 

return validator.validateCurrentEntity(); 

} 

@Override 

protected void onPrePersist() { 

model.getCurrentEntity().setUser(getActiveUser()); 

} 

@Override 

protected String getTargetUrl() { 

return Page.REPORTING.getRedirectUrl(); 

} 

private UserDto getActiveUser() { 

String activeUserName = SecurityContextHolder.getContext().getAuthentication().getName(); 

QueryCriteria criteria = new QueryCriteria(); 

criteria.where("username", activeUserName); 

List authUser = userService.find(criteria); 

if (authUser == null) { 

return null; 

} 

return authUser.get(FIRST); 

} 

} 


ReportingEditAction.java 

/** 

* Action to show or edit an existing ReportingCriteriaDto 

* 


* @since 1.0.0 

*/ 

@Controller 

public class ReportingEditAction extends BaseEditAction { 

} 

private final ReportingModel model; 

private final ProjectTaskService projectTaskService; 

private final ResourceService resourceService; 

/** 

* Constructor 

* @param model, projectTaskService, resourceService 

*/ 

@Inject 

public ReportingEditAction(ReportingModel model, ProjectTaskService 

projectTaskService, ResourceService resourceService) { 

super(model); 

this.model = model; 

this.projectTaskService = projectTaskService; 

this.resourceService = resourceService; 

} 

@Override 

protected void executeInternal(ReportingCriteriaDto entity) { 

model.setCurrentEntity(entity); 

model.setOuSelected(true); 

fillResources(); 

if (model.getCurrentEntity().getProject() != null) { 

model.setProjectSelected(true); 

fillProjectTasks(); 

} 

model.setMode(ReportingModel.MODE_SEARCH); 

} 

public void fillResources() { 

model.getResources().clear(); 

List resources = new ArrayList(); 


criteria.where("ou", model.getCurrentEntity().getOu()); 

resources = resourceService.find(criteria); 

model.setResources(resources); 

} 


public void fillProjectTasks() { 

model.getProjectTasks().clear(); 

List projectTasks = new ArrayList(); 


criteria.where("project", model.getCurrentEntity().getProject()); 

projectTasks = projectTaskService.find(criteria); 

model.setProjectTasks(projectTasks); 

} 

@Override 



} 


ReportingDeleteAction.java 

/** 

* Action to delete a ReportingCriteria entity 

* 

* @author seco-sbi, seco 

* @since 1.0.0 

* 

*/ 


@Controller 

public class ReportingDeleteAction extends BaseDeleteAction { 

} 


/** 

* Constructor 

* 



*/ 

@Inject 

public ReportingDeleteAction(ReportingModel model, ReportingService service) { 

super(model, service); 


} 

@Override 

protected void updateModel(ReportingCriteriaDto entity) { 

model.getReportingCriterias().remove(entity); 

model.setMode(WebEntityModel.MODE_DETAIL_CREATE); 

} 

@Override 



} 


ReportingClearAction.java 


/** 

* Action to reset the datas in the inputfields of the view.This Action is used to create 

new Search. 

* 

* @author seco-sbi, seco 

* @since 1.0.0 

* 

*/ @Controller 

public class ReportingClearAction { 

} 


/** 

* Constructor 

* 


* 

*/ 

@Inject 

public ReportingClearAction(ReportingModel model) { 


} 

public void execute() { 

model.setMode(ReportingModel.MODE_SEARCH); 

model.setCurrentEntity(new ReportingCriteriaDto()); 

model.setOuSelected(false); 

model.setProjectSelected(false); 

} 


ReportingCalculateAction.java 

/** 

* Action to calculate WorkHours for Resources based on the given Filter 

* Criterias 

* 


* @since 1.0.0 

* 

*/ 

@Controller 

public class ReportingCalculateAction { 


private final ReportingModel reportingModel; 

private final ResourcePayloadCalculator calculator; 

private final ResourceModel resourceModel; 

private final ReportingValidator validator; 

private static final int WEEK = 2; 

private static final int MONTH = 3; 

private static final int FIRST_ELEMENT = 0; 

private static final float INITIAL_VALUE = 0; 

/** 

* Constructor 

* 

* @param model, resourceModel 

* @param service, resourceService 

* @param calculator, validator 

*/ 


@Inject 

public ReportingCalculateAction(ReportingModel model, ReportingService service, 

ResourceService resourceService, ResourcePayloadCalculator calculator, ResourceModel 

resourceModel, ReportingValidator validator) { 

} 


this.reportingModel = model; 

this.calculator = calculator; 

this.resourceModel = resourceModel; 

this.validator = validator; 

/** 

* main method of this Action, which is called from the reporting.xhtml 

* site. This method is the only one which can be accessed from an other 

* class.(public) 

* 

* @return the url of the reporting.xhtml page 

*/ 

public String execute() { 

if (!validateCurrentEntity()) { 

return null; 

} 

QueryCriteria criteria = createCriteria(reportingModel); 

calculateWorkDaysForResource(criteria); 

reportingModel.setMode(ReportingModel.MODE_DETAIL_RESULT); 


} 

private QueryCriteria createCriteria(ReportingModel model) { 


criteria.where("ou", reportingModel.getCurrentEntity().getOu()); 

if (reportingModel.getCurrentEntity().getResource() != null) { 

criteria.where("id", reportingMod- 


el.getCurrentEntity().getResource().getId()); 

return criteria;


private QueryCriteria createCriteria(ReportingModel model) { 


criteria.where("ou", reportingModel.getCurrentEntity().getOu()); 

if (reportingModel.getCurrentEntity().getResource() != null) { 

criteria.where("id", reportingModel.getCurrentEntity().getResource().getId()); 

return criteria; 

} 

return criteria; 

} 

/** 

* calculates the WorkDays or WorkWeeks or WorkMonths for each resource based on the 

* given DateRange and FilterCriterias 

* 

* @param criteria 

*/ 

private void calculateWorkDaysForResource(QueryCriteria criteria) { 

ReportingCriteriaDto currentEntity = reportingModel.getCurrentEntity(); 


List resourceReports = new ArrayList(); 


if (!resources.isEmpty()) { 

for (ResourceDto rDto : resources) { 

ResourceReport report = new ResourceReport(); 

resourceModel.setCurrentEntity(rDto); 

calculator.calculateDaysInRange(resourceModel, 

currentEntity.getStartDate(), currentEntity.getEndDate()); 

List workDays = new ArrayList(); 

switch (currentEntity.getMode()) { 

case RESOURCE: 

workDays = resourceModel.getWorkDays(); 

case PROJECT: 

workDays = calculator.calculateDaysForSpecificProject 

(currentEntity.getProject(), resourceModel); 

break; 

case PROJECT_TASK: 

workDays = calculator.calculateDaysForSpecificProjectTask 

(currentEntity.getProjectTask(),resourceModel); 

break; 

case TASK: 

workDays = calculator.calculateDaysForSpecificTask 

(currentEntity.getTask(), resourceModel); 

} 

report.setResource(rDto); 

} 

switch (reportingModel.getCurrentEntity().getGranularity()) { 

case WEEK: 

report.setWeeks(calculator.calculateHoursForWorkWeeks(workDays)); 

break; 

case MONTH: 

report.setMonths(calculator.calculateHoursForWorkMonths(workDays)); 

break; 

default: 

report.setDays(workDays); 

} 

resourceReports.add(report); 

if (resourceReports.size() > 1) { 


case WEEK: 

resourceReports = calculateTotalWorkHoursFor- 

Weeks(resourceReports); 

break; 


case MONTH: 

resourceReports = calculateTotalWorkHoursFor-

} 

} 


if (resourceReports.size() > 1) { 


case WEEK: 

resourceReports = calculateTotalWorkHoursForWeeks(resourceReports); 

break; 

case MONTH: 

resourceReports = calculateTotalWorkHoursForMonths(resourceReports); 

break; 

default: 

resourceReports = calculateTotalWorkHoursForDays(resourceReports); 

} 

} 

} 

populateDynamicDataTable(resourceReports); 

private boolean isResourceAddable(float totalWorkHours) { 

boolean isAddable = false; 

if (!reportingModel.isWorkHourRangeEmpty()) { 

if (reportingModel.isValueInWorkHourRange(totalWorkHours)) { 

isAddable = true; 

} else { 

isAddable = false; 

} 

} else { 

isAddable = true; 

} 

return isAddable; 

} 

private boolean isNotNullWorkhours(float totalWorkHours) { 

if (totalWorkHours == 0.0) { 

return false; 

} else { 

return true; 

} 

} 

private float calculateTotalWorkHours(List days) { 

float totalWorkHours = INITIAL_VALUE; 

for (WorkDay day : days) { 

totalWorkHours += day.getWorkHours(); 

} 

return totalWorkHours; 

} 

private boolean validateCurrentEntity() { 

return validator.validateCurrentEntity 

} 

* @param reports 

* @return 

*/ 

private List loadDynamicList(List reports) { 

List dynamicList = new ArrayList(); 

for (ResourceReport report : reports) { 

List reportList = new ArrayList(); 

if (report.getResource() != null) { 

reportList.add(report.getResource().getFirstName() + " " + report.getResource().getLastName()); 

} else { 

reportList.add(report.getOu().getName()); 

Elisa Schnabel } 

21.05.2013 Seite 89 von 128 

reportList = report.createListOfWorkhours(reportList);

** 

* method to create the Dynamic Result Table 


*/ 

private void populateDynamicDataTable(List reports) { 

List dynamicList = loadDynamicList(reports); 

List headers = loadHeaders(reports); 

HtmlPanelGroup group = reportingModel.getTablePanel(); 

group.getChildren().clear(); 

DataTable table = new DataTable(); 

table.setValueExpression("value", 

createValueExpression("#{reportingModel.dynamicList}", List.class)); 

table.setVar("dynamicItem"); 

table.setId("resultTbl"); 

table.setPaginator(true); 

table.setRows(10); 

table.setStyleClass("dataTable"); 

table.setPaginatorPosition("bottom"); 


// Iterate over columns. 

for (int i = 0; i < dynamicList.get(FIRST_ELEMENT).size(); i++) { 

// new Column 

Column column = new Column(); 

column.setValueExpression("sortBy", createValueExpression("#{dynamicItem[" 

+ i + "]}", Object.class)); 

table.getChildren().add(column); 

// set Header 

HtmlOutputText headerText = new HtmlOutputText(); 

headerText.setValue(headers.get(i)); 

column.setHeader(headerText); 

// setContent 

HtmlOutputText output = new HtmlOutputText(); 

output.setValueExpression("value", createValueExpression("#{dynamicItem[" + 

i + "]}", Object.class)); 

column.getChildren().add(output); 

} 

reportingModel.setColumnHeaders(headers); 

reportingModel.setDynamicList(dynamicList); 

group.getChildren().add(table); 

} 

/** 

* method to load the values for the columns of the dynamic DataTable 


* @return 

*/ 

private List loadDynamicList(List reports) { 

List dynamicList = new ArrayList(); 


List reportList = new ArrayList(); 

if (report.getResource() != null) { 

reportList.add(report.getResource().getFirstName() + " " + 

report.getResource().getLastName()); 

} else { 

reportList.add(report.getOu().getName()); 

} 

reportList = report.createListOfWorkhours(reportList); 

dynamicList.add(reportList); 

} 

return dynamicList; } 


/** 


* method to load the headers for the columns of the dynamic Datatable


/** 

* method to load the headers for the columns of the dynamic Datatable 

* 


* @return headers 

*/ 

private List loadHeaders(List reports) { 

List headers = new ArrayList(); 

DateFormat formatter = new SimpleDateFormat("dd.MMM.yy"); 

String cW = "KW"; 

headers.add("Resource / OE"); 

if (reports.get(FIRST_ELEMENT).getDays() != null) { 

for (WorkDay day : reports.get(FIRST_ELEMENT).getDays()) { 

headers.add(formatter.format(day.getDate())); 

} 

} else if (reports.get(FIRST_ELEMENT).getWeeks() != null) { 

for (WorkWeek week : reports.get(FIRST_ELEMENT).getWeeks()) { 

headers.add(cW + " " + String.valueOf(week.getCalendarWeek())); 

} 

} else { 

List monthHeaders = getMonthHeaders(); 

for (WorkMonth month : reports.get(FIRST_ELEMENT).getMonths()) { 

headers.add(monthHeaders.get(month.getMonthNumber() - 1)); 

} 

} 

return headers; 

} 

private ValueExpression createValueExpression(String valueExpression, Class valueType) { 

FacesContext facesContext = FacesContext.getCurrentInstance(); 

return facesContext.getApplication().getExpressionFactory() 

.createValueExpression(facesContext.getELContext(), valueExpression, valueType); 

} 

/** 

* method to calculate the total of each column.This method is called when 

* the Granularity is day 


* @return 

*/ 

private List calculateTotalWorkHoursForDays(List reports) { 

float currentWorkHours = INITIAL_VALUE; 

ResourceReport totalResource = new ResourceReport(); 

List days = new ArrayList(); 

} 

for (WorkDay day : reports.get(FIRST_ELEMENT).getDays()) { 

WorkDay workDay = new WorkDay(); 

workDay.setDate(day.getDate()); 

days.add(workDay); 

totalResource.setDays(days); 

} 

int i = 0; 

for (WorkDay day : totalResource.getDays()) { 


currentWorkHours += report.getDays().get(i).getWorkHours(); 

} 

day.setWorkHours(currentWorkHours); 

currentWorkHours = INITIAL_VALUE; 

i++; 

} 

totalResource.setOu(reports.get(FIRST_ELEMENT).getResource().getOu()); 

reports.add(totalResource); 

return reports; 

/** Elisa Schnabel 21.05.2013 Seite 91 von 128 

* method to calculate the total of each column. This method is called when


/** 

* method to calculate the total of each column. This method is called when 

* the Granularity is week 


* @return 

*/ 

private List calculateTotalWorkHoursForWeeks(List reports) { 



List workWeeks = new ArrayList(); 

for (WorkWeek week : reports.get(FIRST_ELEMENT).getWeeks()) { 

WorkWeek workWeek = new WorkWeek(); 

workWeek.setCalendarWeek(week.getCalendarWeek()); 

workWeeks.add(workWeek); 

totalResource.setWeeks(workWeeks); 

} 

int i = 0; 

for (WorkWeek week : totalResource.getWeeks()) { 


currentWorkHours += report.getWeeks().get(i).getWorkHours(); 

} 

week.setWorkHours(currentWorkHours); 


i++; 

} 


reports.add(0, totalResource); 


} 

/** 

* method to calculate the total of each column. This method is called when 

* the Granularity is month 


* @return 

*/ 

private List calculateTotalWorkHoursForMonths(List reports) { 



List workMonths = new ArrayList(); 

} 

} 

for (WorkMonth month : reports.get(FIRST_ELEMENT).getMonths()) { 

WorkMonth workMonth = new WorkMonth(); 

workMonth.setMonthNumber(month.getMonthNumber()); 

workMonths.add(workMonth); 

totalResource.setMonths(workMonths); 

} 

int i = 0; 

for (WorkMonth month : totalResource.getMonths()) { 


currentWorkHours += report.getMonths().get(i).getWorkHours(); 

} 

month.setWorkHours(currentWorkHours); 


i++; 

} 


reports.add(0, totalResource); 



ReportingValidator.java 

/** 

* validates the ReportingCriteriaDto fields 

* 


* @since 1.0.0 

* 

*/ 

@Controller 

public class ReportingValidator { 


/** 

* Constructor 

* 


*/ 

@Inject 

public ReportingValidator(ReportingModel model) { 


} 

public boolean validateCurrentEntity() { 

boolean valid = true; 

ReportingCriteriaDto currentEntity = model.getCurrentEntity(); 

valid &= validateCurrentEntityNotNull(currentEntity); 

valid &= validateStartTime(currentEntity); 

valid &= validateEndTime(currentEntity); 

valid &= validateOu(currentEntity); 

valid &= validateGranularity(currentEntity); 

valid &= validateWorkHours(currentEntity); 

return valid; 

} 


/** 

* @param currentEntity 

* @return true if the currentEntity is not null 

*/ 

private boolean validateCurrentEntityNotNull(ReportingCriteriaDto currentEntity) { 

if (currentEntity == null) { 

MessageHelper.putErrorMsg("system.error.msg.general"); 

return false; 

} 

return true; 

} 

/** 

* 


* @return true if the startDate is not null 

*/ 

private boolean validateStartTime(ReportingCriteriaDto currentEntity) { 

if (currentEntity.getStartDate() == null) { 

MessageHelper.putErrorMsg("reporting.validation.msg.missingStartTime"); 

return false; 

} 

return true; 

} 

/** 

* 


* @return true if the endDate is not null and not before the startDate 

Elisa */ Schnabel 21.05.2013 Seite 93 von 128 

private boolean validateEndTime(ReportingCriteriaDto currentEntity) {

} 


/** 

* 


* @return true if the endDate is not null and not before the startDate 

*/ 

private boolean validateEndTime(ReportingCriteriaDto currentEntity) { 

if (currentEntity.getEndDate() == null) { 

MessageHelper.putErrorMsg("reporting.validation.msg.missingEndTime"); 

return false; 

} 

if (currentEntity.getStartDate() != null) { 

int result = currentEntity.getStartDate().compareTo(currentEntity.getEndDate()); 

if (result workHoursFrom 

*/ 

private boolean validateWorkHours(ReportingCriteriaDto currentEntity) { 

if (currentEntity.getWorkHoursFrom() == 0.0 && currentEntity.getWorkHoursTo() != 0.0) { 

MessageHelper.putErrorMsg("reporting.validation.msg.workHoursFrom"); 

return false; 

} 

if (currentEntity.getWorkHoursTo() < currentEntity.getWorkHoursFrom()) { 

MessageHelper.putErrorMsg("reporting.validation.msg.workHoursTo"); 

return false; 

} 

return true; 

} 

/** 

* 


* @return true if the granularity is not null 

*/ 

private boolean validateGranularity(ReportingCriteriaDto currentEntity) { 

if (currentEntity.getGranularity() == 0) { 

MessageHelper.putErrorMsg("reporting.validation.msg.granularity"); 

return false; 

} 

return true; 

} 

private void calculateWorkDaysForResource(QueryCriteria criteria) { 

Elisa Schnabel ReportingCriteriaDto currentEntity 21.05.2013 = reportingModel.getCurrentEntity(); Seite 94 von 128 


List resourceReports = new ArrayList();

ReportingPreRenderViewListener.java 

/** 

* Listener to be called before the reporting.xhtml view is rendered.Fills the 

* DataTabele with the ReportingCriteria Sets from the active user and fills the 

* dropdowns ou an project. 

* 

* @author seco-sbi 

* @since 1.0.0 

*/ 

@Controller 

public class ReportingPreRenderViewListener { 


private final CommonCodesModel codesModel; 

private final OrganizationalUnitService ouService; 


private final ProjectService projectService; 

private final ReportingService reportingService; 

private final UserService userService; 

/** 

* Constructor 

* 

* @param codesModel, reportingModel 

* @param ouService, projectService, reportingService 

*/ 

@Inject 

public ReportingPreRenderViewListener(CommonCodesModel codesModel, 

OrganizationalUnitService ouService,ReportingModel reportingModel, ProjectService 

projectService, ReportingService reportingService, UserService userService) { 

this.codesModel = codesModel; 

this.ouService = ouService; 

this.reportingModel = reportingModel; 

this.projectService = projectService; 

this.reportingService = reportingService; 

this.userService = userService; 

} 


if (!FacesContext.getCurrentInstance().isPostback()) { 

loadOrganizationalUnits(); 

loadProjects(); 

loadReportingCriterias(); 

} 

} 

private void loadOrganizationalUnits() { 

if (codesModel.getOus().isEmpty()) { 

Map map = new HashMap(); 

for (OrganizationalUnitDto ou : ouService.getAll()) { 

map.put(ou.getId(), ou); 

} 

codesModel.setOus(map); 

} 

} 

private void loadProjects() { 

List projects = new ArrayList(); 

for (ProjectDto project : projectService.getAll()) { 

projects.add(project); 

} 

reportingModel.setProjects(projects); 

} 

private void loadReportingCriterias() { 

Elisa Schnabel List criterias 21.05.2013 = new ArrayList(); 

Seite 95 von 128 

QueryCriteria criteria = new QueryCriteria();

} 

private void loadProjects() { 

List projects = new ArrayList(); 

for (ProjectDto project : projectService.getAll()) { 

projects.add(project); 

} 

reportingModel.setProjects(projects); 

} 


private void loadReportingCriterias() { 

List criterias = new ArrayList(); 


criteria.where("user", getActiveUser()); 

criterias = reportingService.find(criteria); 

reportingModel.setReportingCriterias(criterias); 

} 

/** 

* @return the active user. 

*/ 

private UserDto getActiveUser() { 

String name = SecurityContextHolder.getContext().getAuthentication().getName(); 

QueryCriteria userCriteria = new QueryCriteria(); 

userCriteria.where("username", name); 

List user = userService.find(userCriteria); 

return user.get(FIRST); 

} 


ReportingValueChangeListenerOu.java 

/** 

* Listener to be called when a new ou is selected. Fills the resource dropdown 

* depending on the selected ou. 

* 


* @since 1.0.0 

* 

*/ 

@Controller 

public class ReportingValueChangelistenerOu { 

} 




@Inject 

public ReportingValueChangelistenerOu(ReportingModel reportingModel, ResourceService 

resourceService) { 

this.reportingModel = reportingModel; 


} 


OrganizationalUnitDto selectedOu = reportingModel.getCurrentEntity().getOu(); 

if (selectedOu != null) { 

reportingModel.setOuSelected(true); 

reportingModel.getResources().clear(); 

reportingModel.setResources(loadResources(selectedOu)); 

} else { 

reportingModel.setOuSelected(false); 

} 

} 

private List loadResources(OrganizationalUnitDto selectedOu) { 



criteria.where("ou", selectedOu); 


return resources; 

} 


ReportingValueChangeListenerProject.java 

/** 

* Listener to be called when a new project is selected. Fills the ProjectTask 

* dropdown depending on the selected project. 

* 


* @since 1.0.0 

* 

*/ 

@Controller 

public class ReportingValueChangelistenerProject { 

} 

private final ReportingModel repModel; 

private final ProjectTaskService taskService; 


@Inject 

public ReportingValueChangelistenerProject(ReportingModel repModel, ProjectTaskService 

taskService) { 

this.repModel = repModel; 

this.taskService = taskService; 

} 

public void execute(){ 

ProjectDto selected = repModel.getCurrentEntity().getProject(); 

if (selected != null) { 

repModel.setProjectSelected(true); 

if (!repModel.getProjectTasks().isEmpty()) { 

repModel.getProjectTasks().clear(); 

} 

repModel.setProjectTasks(loadProjectTasks(selected)); 

} else { 

repModel.setProjectSelected(false); 

} 

} 

private List loadProjectTasks(ProjectDto selected) { 

List projectTasks = new ArrayList(); 


criteria.where("project", selected); 

projectTasks = taskService.find(criteria); 

return projectTasks; 

} 


ReportingValueChangeListenerDate.java 

/** 

* Listener to be called when a radio button Date is selected. Fills the fields 

* startDate, endDate depending on the selected radio button. 

* 


* @since 1.0.0 

* 

*/@Controller 

public class ReportingValueChangelistenerDate { 

} 


public static final int CURRENT_DAY = 1; 

public static final int CURRENT_WEEK = 2; 

public static final int CURRENT_MONTH = 3; 

public static final int CURRENT_YEAR = 4; 

public static final int NO_SELECTION = 0; 


@Inject 

public ReportingValueChangelistenerDate(ReportingModel repModel) { 

this.reportingModel = repModel; 

} 

public void execute(AjaxBehaviorEvent e) { 

ReportingCriteriaDto currentEntity = reportingModel.getCurrentEntity(); 

int value = currentEntity.getRadioDate(); 

DateRange dateRange=null; 

switch (value) { 

case CURRENT_DAY: 

dateRange = DateHelper.getCurrentDayRange(); 

break; 

case CURRENT_WEEK: 

dateRange = DateHelper.getCurrentWeek(); 

break; 

case CURRENT_MONTH: 

dateRange = DateHelper.getCurrentMonth(); 

break; 

case CURRENT_YEAR: 

dateRange = DateHelper.getCurrentYear(); 

break; 

default: { 

throw new IllegalArgumentException(String.format("Undefined range: %d", value)); 

} 

} 

currentEntity.setStartDate(dateRange.getStartDate()); 

currentEntity.setEndDate(dateRange.getEndDate()); 



ResourcePayloadCalculator.java 

(Die nachfolgende Klasse wurde nicht im Rahmen des Moduls ResMan Reporting erstellt, 

aber um ein paar Methoden erweitert. Entsprechende Codeabschnitte wurden gekennzeichnet.) 

/** 

* Utility class for resource calculation matters. 

* 

* @author seco-gid, SECO 

* @since 1.0.0 

* 

*/ 

@Controller 

public class ResourcePayloadCalculator { 

private final HolidayService holidayService; 

@Inject 

public ResourcePayloadCalculator(HolidayService holidayService) { 

this.holidayService = holidayService; 

} 

/** 

* 


* @param start 

* @param end 

*/ 

public void calculateDaysInRange(ResourceModel model) { 

calculateDaysInRange(model, model.getRange().getStartDate(), model.getRange().getEndDate()); 

} 

/** 

* 


* @param start 

* @param end 

*/ 

public void calculateDaysInRange(ResourceModel model, Date start, Date end) { 

List workDays = model.getWorkDays(); 

workDays.clear(); 

Date currentDate = start; 

Calendar cal = Calendar.getInstance(); 

cal.setTime(currentDate); 

if (end == null) { 

end = start; 

} 

while (!currentDate.after(end)) { 

if ((cal.get(Calendar.DAY_OF_WEEK) != 1 && cal.get(Calendar.DAY_OF_WEEK) != 7) || model.isDisplayWeekends()) 

{ 

workDays.add(calculateDay(model, currentDate)); 

} 

cal.setTime(currentDate); 

cal.add(Calendar.DAY_OF_YEAR, 1); 

currentDate = cal.getTime(); 

} 

} 

/** 

* 


* @param date 

* @return WorkDay 

*/ 


public WorkDay calculateDay(ResourceModel model, Date date) { 

ResourceDto currentEntity = model.getCurrentEntity();


/** 

* 


* @param date 

* @return WorkDay 

*/ 

public WorkDay calculateDay(ResourceModel model, Date date) { 

ResourceDto currentEntity = model.getCurrentEntity(); 

List payloads = new ArrayList(); 

List absences = new ArrayList(); 

float totalWorkHours = 0; 

WorkDay day = new WorkDay(); 

day.setCapacity(calculateMaxDailyCapacity(model.getCurrentEntity())); 

checkForPartTimeAbsences(date, currentEntity, totalWorkHours, day); 

day.setDate(date); 

totalWorkHours = checkForTasks(date, currentEntity, payloads, totalWorkHours); 

totalWorkHours = checkForProjectTasks(date, currentEntity, payloads, totalWorkHours); 

day.setWorkHours(totalWorkHours); 

checkForAbsences(date, currentEntity, absences, day); 

checkForWeekendOrHoliday(date, day); 

day.setPayloads(payloads); 

day.setAbsences(absences); 

return day; 

} 

/** 

* 

* @param date 


* @param payloads 

* @param totalWorkHours 

* @return 

*/ 

private float checkForTasks(Date date, ResourceDto currentEntity, List payloads, 

float totalWorkHours) { 

if (CollectionUtils.isNotEmpty(currentEntity.getTasks())) { 

for (TaskDto task : currentEntity.getTasks()) { 

if (DateHelper.isDateInRange(date, task.getStartDate(), task.getEndDate())) { 

if (!DateHelper.isWeekend(date) || task.isWeekendRelevant()) { 

ExceptionalDateRangeDto exception = null; 

if (CollectionUtils.isNotEmpty(task.getExceptions())) { 

exception = DateHelper.getExceptionOn(task.getExceptions(), date); 

} 

if (exception == null) { 

totalWorkHours += task.getWorkHours(); 

} 

else { 

totalWorkHours += exception.getWorkHours(); 

} 

payloads.add(task); 

} 

} 

} 

} 


} 

/** 

* 

* @param date 




* @return 

*/ 

private float checkForProjectTasks(Date date, ResourceDto currentEntity, List 


payloads, 

float totalWorkHours) {


/** 

* 

* @param date 




* @return 

*/ 

private float checkForProjectTasks(Date date, ResourceDto currentEntity, List 

payloads, 

float totalWorkHours) { 

if (CollectionUtils.isNotEmpty(currentEntity.getProjectTasks())) { 

for (ProjectTaskDto projectTask : currentEntity.getProjectTasks()) { 

if (DateHelper.isDateInRange(date, projectTask.getStartDate(), 

projectTask.getEndDate())) { 

if (!DateHelper.isWeekend(date) || projectTask.isWeekendRelevant()) { 

ExceptionalDateRangeDto exception = null; 

if (CollectionUtils.isNotEmpty(projectTask.getExceptions())) { 

exception = DateHelper.getExceptionOn(projectTask.getExceptions(), date); 

} 

if (exception != null) { 

totalWorkHours += exception.getWorkHours(); 

} 

else { 

totalWorkHours += projectTask.getWorkHours(); 

} 

payloads.add(projectTask); 

} 

} 

} 

} 


} 

/** 

* 

*@param date 

*@param currentEntity 

*@param day 

*/ 

private void checkForAbsences(Date date, ResourceDto currentEntity, List absences, 

WorkDay day) { 

if (CollectionUtils.isNotEmpty(currentEntity.getAbsences())) { 

for (AbsenceDto absence : currentEntity.getAbsences()) { 

if (DateHelper.isDateInRange(date, absence.getStartDate(), absence.getEndDate())) { 

day.setCapacity(day.getCapacity() - absence.getWorkHours()); 

absences.add(absence); 

} 

} 

} 

if (day.getCapacity() < 0F) { 

day.setCapacity(0F); 

} 

} 

/** 

* 

*@param date 

*@param currentEntity 

*@param totalWorkHours 

*@param day 

*/ 

private void checkForPartTimeAbsences(Date date, ResourceDto currentEntity, float totalWork- 

Hours, WorkDay day) { 

if (currentEntity.getPartTimeAbsence() Elisa Schnabel == null) 21.05.2013 { 


return; 

}


private void checkForWeekendOrHoliday(Date date, WorkDay day) { 

if (DateHelper.isWeekend(date)) { 

day.setCapacity(0F); 

} 

else { 

HolidayDto holidayDay = holidayService.findHoliday(date); 

if (holidayDay != null) { 

day.setCapacity((day.getCapacity() * (100 - holidayDay.getPercentage())) / 100); 

} 

} 

} 

/** 

* 

* @param resource 

* @param workDays 

* @return a list containing workdays that exceeds the capacity 

*/ 

public List calculateOverloadedWorkDays(ResourceDto resource, List workDays) { 

List list = new ArrayList(); 

if (resource != null 

&& resource.getLevelOfEmployment() != null) { 

for (WorkDay workDay : workDays) { 

if (workDay.getWorkHours() > resource.getLevelOfEmployment()) { 

list.add(workDay); 

} 

} 

} 

return list; 

} 

/** 

* 

* @param resource 

* @return the maxDailyCapacity 

*/ 

public float calculateMaxDailyCapacity(ResourceDto resource) { 

int hoursPerWeek = resource.getWorkingPattern().getHoursPerWeek(); 

int numberOfWorkDays = 5; 

} 

if (resource.getPartTimeAbsence().isMonday()) { 

numberOfWorkDays--; 

} 

if (resource.getPartTimeAbsence().isTuesday()) { 


} 

if (resource.getPartTimeAbsence().isWednesday()) { 


} 

if (resource.getPartTimeAbsence().isThursday()) { 


} 

if (resource.getPartTimeAbsence().isFriday()) { 


} 

if (numberOfWorkDays == 0) { 

return 0; 

} 

return (hoursPerWeek * (float) resource.getLevelOfEmployment()) / (numberOfWorkDays * 100F); 

public List calculateHoursForWorkWeeks(List workDays) { 

List weeks = new ArrayList(); 

float workHours = 0; 

int currentWeek = 0, nextWeek = 0; 


for (WorkDay day : workDays) { 

nextWeek = DateHelper.getWeekOfYear(day.getDate());


--------------Codeabschnitt Elisa Schnabel -------------- 

/** 

* calculates the total workhours for workweeks based on the given list of workdays 


* @return the list of calculated workweeks 

*/ 

public List calculateHoursForWorkWeeks(List workDays) { 

List weeks = new ArrayList(); 


int currentWeek = 0, nextWeek = 0; 


nextWeek = DateHelper.getWeekOfYear(day.getDate()); 

if (currentWeek < nextWeek && currentWeek != 0 || day.isLast(workDays) || 

nextWeek < currentWeek) { 

WorkWeek week = new WorkWeek(); 

week.setCalendarWeek(currentWeek); 

weeks.add(week); 

if (day.isLast(workDays)) { 

workHours += day.getWorkHours(); 

} 

week.setWorkHours(workHours); 

workHours = 0; 

} 

currentWeek = DateHelper.getWeekOfYear(day.getDate()); 


} 

return weeks; } 

/** 

* calculates the total of workhours for workmonths based on the given list of workdays 


* @return the list of calculated workmonths 

*/ 

public List calculateHoursForWorkMonths(List workDays) { 

List months = new ArrayList(); 


int currentMonth = 0, nextMonth = 0; 


nextMonth = DateHelper.getMonthOfYear(day.getDate()); 

if (currentMonth < nextMonth && currentMonth != 0 || day.isLast(workDays) || 

nextMonth < currentMonth){ 

WorkMonth month = new WorkMonth(); 

month.setMonthNumber(currentMonth); 

if (day.isLast(workDays)) { 


} 

month.setWorkHours(workHours); 

workHours = 0; 

months.add(month); 

} 

currentMonth = DateHelper.getMonthOfYear(day.getDate()); 


} 

return months; } 



/** 

* calculates the workHours for each workday based on the given project 

* @param project 


* @return the list of calculated workdays for the given project 

*/ 

public List calculateDaysForSpecificProject(ProjectDto project, ResourceModel model){ 


float totalWorkHours=0; 

boolean containsProjectTask =false; 

for (WorkDay day : model.getWorkDays()) { 

for(PayLoadDto payload : day.getPayloads()){ 

if(payload instanceof ProjectTaskDto && 

((ProjectTaskDto)payload).getProject().equals(project)){ 

containsProjectTask=true; 

totalWorkHours += payload.getWorkHours(); 

}else{ 

continue; 

} 

} 

if(containsProjectTask == true){ 


totalWorkHours=0; 

containsProjectTask=false; 

}else{ 

day.setWorkHours(0); 

} 

workDays.add(day); 

} 

return workDays; 

} 

/** 

* calculates the workHours for each workday based on the given projecttask 

* @param projectTask 


* @return the list of calculated workdays for the given projecttaks 

*/ 

public List calculateDaysForSpecificProjectTask(ProjectTaskDto projectTask, Resource 

Model model){ 


boolean containsProjectTask =false; 

float totalWorkHours=0; 


for(PayLoadDto payload : day.getPayloads()){ 

if(payload instanceof ProjectTaskDto && 

((ProjectTaskDto)payload).equals(projectTask)){ 


containsProjectTask=true; 

}else{ 

continue; 

} 

} 

if(containsProjectTask == true){ 


totalWorkHours=0; 

containsProjectTask=false; 

}else{ 


} 


} 

return workDays; } 


** 


* calculates the workHours for each workday based on the given task 

* @param task 


* @return the list of calculated workdays for the given task 

*/ 

public List calculateDaysForSpecificTask(TaskDto task, ResourceModel model) { 


boolean containsTask = false; 

float totalWorkHours = 0; 


for (PayLoadDto payload : day.getPayloads()) { 

if (payload instanceof TaskDto && ((TaskDto) payload).equals(task)) { 


containsTask = true; 

} else { 

continue; 

} 

} 

if (containsTask == true) { 


totalWorkHours = 0; 

containsTask = false; 

} else { 


} 


} 

return workDays; 

} 

} 

--------------Codeabschnitt Elisa Schnabel -------------- 


TaskAutocomplete.java 

/** 

* Backing bean for Primefaces Autocompleter Task 

* 

* @author seco-sbi, 

* @since 1.0.0 

* 

*/ 

@Controller 

public class TaskAutocomplete { 

} 

private final TaskService service; 

/** 

* Constructor 

* 


*/ 

@Inject 

public TaskAutocomplete(TaskService service) { 

this.service = service; 

} 

/** 

* 

* @param query 

* @return a list of matching (title) task 

*/ 

public List complete(String query) { 

query = query.trim(); 

List hits = null; 

hits = service.findByTitle(query); 

if (hits != null) { 

return hits; 

}else{ 

return null; 

} 

} 



Reporting.xhtml 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 


 

 

 

 

 

 

 

 

 

 

 

 

Elisa Schnabel 

21.05.2013 Seite 108 von 128

/> 

/> 

/> 

/> 


 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 


 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 




 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

- 

 

Elisa Schnabel 112 von 128 

 


 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 


17.1.2 Klassen Service Layer 

ReportingService.java 


/** 

* service Interface for Reporting 

* 


* @since 1.0.0 

* 

*/ 

public interface ReportingService extends PersistenceService { 

} 

DefaultReportingService.java 

/** 

* Service for Reporting 


* @since 1.0.0 

*/ 

@Service 

public class DefaultReportingService extends BasePersistenceService implements 

ReportingService { 

/** 

* Constructor 

* 

* @param repository 

* @param mapper 

*/ 

@Inject 

public DefaultReportingService(ReportingRepository repository, Mapper mapper) { 

super(mapper, repository, ReportingCriteriaDto.class, ReportingCriteria.class); 

} 

@Override 

public ReportingCriteriaDto save(ReportingCriteriaDto dto) { 

return saveInternal(dto); 

} 

@Override 

public ReportingCriteriaDto getById(Integer id) { 

return getByIdInternal(id); 

} 

@Override 

public List find(QueryCriteria criteria) { 

List dtos = new ArrayList(); 

if (criteria == null) { 

return dtos; 

} 

Object userDto = criteria.getCriterionValue("user"); 

if(userDto !=null){ 

criteria.replaceCriterionValue("user", mapper.mapObject(userDto, User.class)); 

} 

List criterias = repository.find(criteria); 

if (criterias != null && !criterias.isEmpty()) { 

dtos = mapper.mapCollection(criterias, ReportingCriteriaDto.class); 

} 

return dtos; } 

@Override 

public void remove(ReportingCriteriaDto dto) { 

removeInternal(dto); 

} 

} 


ReportingCriteriaDto.java 

/** 

* Data transfer Object for ReportingCriteria 


* @since 1.0.0 

* 

*/ 

public class ReportingCriteriaDto extends BaseResmanDto { 

private Integer id; 

private Date startDate; 

private Date endDate; 

private OrganizationalUnitDto ou; 

private ResourceDto resource; 

private ProjectDto project; 

private UserDto user; 

private ProjectTaskDto projectTask; 

private TaskDto task; 

private double workHoursFrom; 

private double workHoursTo; 

private int granularity; 

private float totalWorkHours; 

public enum Mode { 

RESOURCE, PROJECT_TASK, PROJECT, TASK 

} 

@Override 

public Integer getId() { 

return id; 

} 

@Override 

public void setId(Integer id) { 

this.id = id; 

} 

public Date getStartDate() { 

return startDate; 

} 

public void setStartDate(Date startDate) { 

this.startDate = startDate; 

} 

public Date getEndDate() { 

return endDate; 

} 

public void setEndDate(Date endDate) { 

this.endDate = endDate; 

} 

public OrganizationalUnitDto getOu() { 

return ou; 

} 

public void setOu(OrganizationalUnitDto ou) { 

this.ou = ou; 

} 

public ResourceDto getResource() { 

return resource; 

} 

public void setResource(ResourceDto resource) { 

this.resource = resource; 

} 

public ProjectDto getProject() { 

return project; 

} 


public Elisa Schnabel void setProject(ProjectDto project) 21.05.2013 { 


this.project = project;

} 

public ProjectDto getProject() { 


} 

public void setProject(ProjectDto project) { 

this.project = project; 

} 

public UserDto getUser() { 

return user; 

} 

public void setUser(UserDto user) { 

this.user = user; 

} 

public TaskDto getTask() { 

return task; 

} 

public void setTask(TaskDto task) { 

this.task = task; 

} 

public double getWorkHoursFrom() { 

return workHoursFrom; 

} 

public void setWorkHoursFrom(double workHoursFrom) { 

this.workHoursFrom = workHoursFrom; 

} 

public double getWorkHoursTo() { 

return workHoursTo; 

} 

public void setWorkHoursTo(double workHoursTo) { 

this.workHoursTo = workHoursTo; 

} 

public int getGranularity() { 

return granularity; 

} 

public void setGranularity(int granularity) { 

this.granularity = granularity; 

} 

public ProjectTaskDto getProjectTask() { 

return projectTask; 

} 

public void setProjectTask(ProjectTaskDto projectTask) { 

this.projectTask = projectTask; 

} 

public float getTotalWorkHours() { 


} 

public void setTotalWorkHours(float totalWorkHours) { 

this.totalWorkHours = totalWorkHours; 

} 

public Mode getMode() { 

Mode mode = Mode.RESOURCE; 

if (project == null && projectTask == null && task ==null ) { 

mode = Mode.RESOURCE; 

}else if(project != null && projectTask != null){ 

mode=Mode.PROJECT_TASK; 

}else if(project!= null && projectTask == null){ 

mode=Mode.PROJECT; 

} 

return mode; 

} 



WorkDay.java (Nicht selbsterstellte Klasse, nur für das Verständnis) 

public class WorkDay { 

private Date date; 

private float capacity; 

private float workHours; 

private List absences = new ArrayList(); 

private List payloads = new ArrayList(); 

private boolean absenceContained = false; 

private boolean fullAbsence = false; 

private boolean partTimeAbsence = false; 

private boolean overloaded = false; 

private int week; 

public Date getDate() { 

return date; 

} 

public void setDate(Date date) { 

this.date = date; 

} 

public float getWorkHours() { 

return workHours; 

} 

public void setWorkHours(float workHours) { 

this.workHours = workHours; 

} 

public float getCapacity() { 

return capacity; 

} 

public void setCapacity(float capacity) { 

this.capacity = capacity; 

} 

public List getPayloads() { 

return payloads; 

} 

public void setPayloads(List payloads) { 

this.payloads = payloads; 

} 

public List getTasks() { 


for (PayLoadDto item : getPayloads()) { 

if (item instanceof TaskDto) { 

list.add((TaskDto) item); 

} 

} 

return list; 

} 

public List getProjectTasks() { 


for (PayLoadDto item : getPayloads()) { 

if (item instanceof ProjectTaskDto) { 

list.add((ProjectTaskDto) item); 

} 

} 

return list; 

} 

public boolean isAbsenceContained() { 

return absenceContained; 

} 


/** 

* @param absenceContained 

* the absenceContained to set 

*/ Elisa Schnabel 21.05.2013 Seite 117 von 128 

public void setAbsenceContained(boolean absenceContained) {

} 

public void setAbsenceContained(boolean absenceContained) { 

this.absenceContained = absenceContained; 

} 

public List getAbsences() { 

return absences; 

} 

public void setAbsences(List absences) { 

this.absences = absences; 

} 

public boolean isFullAbsence() { 

return fullAbsence; 

} 

public void setFullAbsence(boolean fullAbsence) { 

this.fullAbsence = fullAbsence; 

} 

public boolean isPartTimeAbsence() { 

return partTimeAbsence; 

} 

public void setPartTimeAbsence(boolean partTimeAbsence) { 

this.partTimeAbsence = partTimeAbsence; 

} 

public boolean isOverloaded() { 

return overloaded; 

} 

public void setOverloaded(boolean value) { 

this.overloaded = value; 

} 

public int getWeek() { 

return week; 

} 

public void setWeek(int week) { 

this.week = week; 

public boolean isLast(List workDays) { 

final int LAST_INDEX_OF_LIST = (workDays.size() - 1); 

return workDays.lastIndexOf(this) == LAST_INDEX_OF_LIST; 

} } 



WorkWeek.java 

public class WorkWeek { 

private DateRange daterange; 

private int calendarWeek; 


public WorkWeek.java int getCalendarWeek() { 

return calendarWeek; 

} 

public void setCalendarWeek(int calendarWeek) { 

this.calendarWeek = calendarWeek; 

} 



} 



WorkMonth.java 

} 

public DateRange getDaterange() { 

public class WorkMonth { 

return daterange; 

} 

private DateRange range; 

private 

public void 

int monthNumber; 

setDaterange(DateRange daterange) { 

this.daterange = daterange; 


} 

} 

public DateRange getRange() { 

return range; 

} 

public void setRange(DateRange range) { 

this.range = range; 

} 

public int getMonthNumber() { 

return monthNumber; 

} 

} 

public void setMonthNumber(int monthNumber) { 

this.monthNumber = monthNumber; 

} 



} 



} 



ResourceReport.java 

/** 

* This class contains a resource and its calculated WorkDays, WorkWeeks and 

* WorkMonths. This class is used by the ReportingCalculateAction. 

* 


* @since 1.0.0 

* WorkWeek.java 

*/ 

public class ResourceReport { 

} 

private OrganizationalUnitDto ou; 

private ResourceDto resource; 

private List days; 

private List weeks; 

private List months; 

public ResourceDto getResource() { 


} 

public void setResource(ResourceDto resource) { 


} 

public List getDays() { 

return days; 

} 

public void setDays(List days) { 

this.days = days; 

} 

public List getWeeks() { 

return weeks; 

} 

public void setWeeks(List weeks) { 

this.weeks = weeks; 

} 

public List getMonths() { 

return months; 

} 

public void setMonths(List months) { 

this.months = months; 

} 

public OrganizationalUnitDto getOu() { 

return ou; 

} 

public void setOu(OrganizationalUnitDto ou) { 

this.ou = ou; 

} 

public List createListOfWorkhours(List reportList) { 

if (this.getDays() != null) { 

for (WorkDay day : this.getDays()) { 

reportList.add(Float.valueOf(day.getWorkHours())); 

} 

} else if (this.getWeeks() != null) { 

for (WorkWeek week : this.getWeeks()) { 

reportList.add(Float.valueOf(week.getWorkHours())); 

} 

} else { 

for (WorkMonth month : this.getMonths()) { 

reportList.add(Float.valueOf(month.getWorkHours())); 

} 

} 

return reportList;+ 

} 




/** 

* repository interface for the ReportingCriteria- Entity 

* 


* @since 1.0.0 

* 

*/ 

public interface ReportingRepository extends ExtendedBaseRepository { 

} 

17.1.3 Klassen Persistez Layer 

ReportingRepository.java 

JpaReportingRepository.java 

/** 

* repository for ReportingCriteria 

* 


* @since 1.0.0 

* 

*/ 

@Repository 

public class JpaReportingRepository extends JpaExtendedBaseRepository 

implements ReportingRepository { 

} 


ReportingCriteria.java 

/** 

* Reporting Entity for Table rm_reporting_criteria 

* 


* @since 1.0.0 

* 

*/ 

@Entity 

@Table(name = "rm_reporting_criteria") 

public class ReportingCriteria extends BaseResmanEntity { 

@Id 

@SequenceGenerator(name = "RM_REPORTINGCRITERIA_ID_GENERATOR", sequenceName = 

"rm_reporting_criteria_id_seq", allocationSize = 1) 

@GeneratedValue(strategy = GenerationType.SEQUENCE, generator = 

"RM_REPORTINGCRITERIA_ID_GENERATOR") 

@Column(name = "id", unique = true, nullable = false) 

private Integer id; 

@Temporal(TemporalType.DATE) 

@Column(name = "start_date", nullable = false) 


@Temporal(TemporalType.DATE) 

@Column(name = "end_date", nullable = false) 


@ManyToOne 

@JoinColumn(name = "ou_id") 

private OrganizationalUnit ou; 

@ManyToOne 

@JoinColumn(name = "resource_id") 

private Resource resource; 

@ManyToOne 

@JoinColumn(name = "project_id") 

private Project project; 

@ManyToOne 

@JoinColumn(name = "user_id") 

private User user; 

@ManyToOne 

@JoinColumn(name = "projectTask_id") 

private ProjectTask projectTask; 

@ManyToOne 

@JoinColumn(name = "task_id") 

private Task task; 

@Column(name = "work_hours_from", nullable = true) 

private double workHoursFrom; 

@Column(name = "work_hours_to", nullable = true) 

private double workHoursTo; 

@Column(name = "granularity", nullable = true) 

private int granularity; 


@Column(name = "radio_date", nullable = true) 


private int radioDate;

@Override 

public Integer getId() { 

return id; 

} 

@Override 

public void setId(Integer id) { 

this.id = id; 

} 

public Date getStartDate() { 

return startDate; 

} 

public void setStartDate(Date startDate) { 

this.startDate = startDate; 

} 

public Date getEndDate() { 

return endDate; 

} 

public void setEndDate(Date endDate) { 

this.endDate = endDate; 

} 

public OrganizationalUnit getOu() { 

return ou; 

} 

public void setOu(OrganizationalUnit ou) { 

this.ou = ou; 

} 

public Resource getResource() { 


} 

public void setResource(Resource resource) { 


} 

public Project getProject() { 


} 

public void setProject(Project project) { 

this.project = project; 

} 

public User getUser() { 

return user; 

} 

public void setUser(User user) { 

this.user = user; 

} 

public Task getTask() { 

return task; 

} 

public void setTask(Task task) { 

this.task = task; 

} 

public double getWorkHoursFrom() { 

return workHoursFrom; 

} 

public void setWorkHoursFrom(double workHoursFrom) { 

this.workHoursFrom = workHoursFrom; 

} 



} 



this.workHoursTo Elisa Schnabel = workHoursTo; 


}



} 


this.workHoursTo = workHoursTo; 

} 

public int getGranularity() { 

return granularity; 

} 

public void setGranularity(int granularity) { 

this.granularity = granularity; 

} 

public ProjectTask getProjectTask() { 

return projectTask; 

} 

public void setProjectTask(ProjectTask projectTask) { 

this.projectTask = projectTask; 

} 

} 



ResourcePayloadCalculatorTest.java 

public class ResourcePayloadCalculatorTest { 

private HolidayService holidayService = new MockedHolidayService(); 

private ResourcePayloadCalculator calculator = new ResourcePayloadCalculator(holidayService); 

private ResourceModel model; 



@Before 

public void setup() { 

initDates(DateHelper.getCurrentWeek()); 

model = initResourceModel(startDate, endDate, calculator); 

} 

@Test 

public void calculateDaysInRange() { 

calculator.calculateDaysInRange(model, startDate, endDate); 

Assert.assertEquals(5, model.getWorkDays().size()); 

} 


@Test 

public void calculateHoursForWorkWeeks(){ 


List weeks = calculator.calculateHoursForWorkWeeks(model.getWorkDays()); 

Assert.assertEquals(1, weeks.size()); 

} 

@Test 

public void calculateHoursForWorkWeeksWithYearOverflow(){ 

initDates("01.12.2013", "31.01.2014"); 


List weeks = calculator.calculateHoursForWorkWeeks(model.getWorkDays()); 

Assert.assertEquals(9, weeks.size()); 

} 

@Test 

public void calculateHoursForWorkMonths(){ 


List months = calculator.calculateHoursForWorkMonths(model.getWorkDays()); 

Assert.assertEquals(1, months.size()); 

} 

@Test 

public void calculateHoursForWorkMonthsWithYearOverflow(){ 

initDates("01.12.2013", "31.01.2014"); 


List months = calculator.calculateHoursForWorkMonths(model.getWorkDays()); 

Assert.assertEquals(2, months.size()); 

} 

@Test 

public void calculateDaysForSpecificProjectTask(){ 


List days= 

calculator.calculateDaysForSpecificProjectTask(initProjectTask(startDate, endDate), model); 

Assert.assertEquals(5, days.size()); 

for(WorkDay day :days){ 

Assert.assertEquals(8F, day.getWorkHours()); 

} 

} 

@Test 

public void calculateDaysForSpecificTask(){ 



List days= calculator.calculateDaysForSpecificTask(initTask(startDate, endDate), 

model);


@Test 

public void calculateDaysForSpecificTask(){ 


List days= calculator.calculateDaysForSpecificTask(initTask(startDate, endDate), model); 




} 

} 

@Test 

public void calculateDaysForSpecificProject(){ 

calculator.calculateDaysInRange(model, startDate, endDate); List days= calculator.calculateDaysForSpecificProject(initProject(startDate, 

endDate), model); 




} 

} 

private ResourceModel initResourceModel(Date startDate, Date endDate, 

ResourcePayloadCalculator calculator){ 

ResourceModel model = new ResourceModel(calculator); 

ResourceDto resource = initResource(); 

TaskDto task = initTask(startDate, endDate); 

ProjectTaskDto projectTask = initProjectTask(startDate, endDate); 

List tasks = new ArrayList(); 

List ptasks = new ArrayList(); 

ptasks.add(projectTask); 

tasks.add(task); 

resource.setTasks(tasks); 

resource.setProjectTasks(ptasks); 

model.setCurrentEntity(resource); 

return model; 

} 

private TaskDto initTask(Date startDate, Date endDate){ 

TaskDto task = new TaskDto(); 

task.setStartDate(startDate); 

task.setEndDate(endDate); 

task.setWorkHours(8F); 

task.setTitle("test"); 

task.setId(1); 

return task; 

} 

private ProjectTaskDto initProjectTask(Date startDate, Date endDate){ 

ProjectTaskDto task = new ProjectTaskDto(); 

ProjectDto project = initProject(startDate, endDate); 

task.setStartDate(startDate); 

task.setEndDate(endDate); 

task.setWorkHours(8F); 

task.setTitle("test"); 

task.setId(1); 

task.setProject(project); 

return task; 

} 

private ProjectDto initProject(Date startDate, Date endDate){ 

ProjectDto project= new ProjectDto(); 

project.setStartDate(startDate); 

project.setEndDate(endDate); 

project.setName("Test"); 

project.setId(1); 



}

} 

private ProjectDto initProject(Date startDate, Date endDate){ 

ProjectDto project= new ProjectDto(); 

project.setStartDate(startDate); 

project.setEndDate(endDate); 

project.setName("Test"); 

project.setId(1); 


} 

private ResourceDto initResource(){ 

WorkingPatternDto wp = new WorkingPatternDto(); 

wp.setHoursPerWeek(42); 

ResourceDto resource = new ResourceDto(); 

resource.setWorkingPattern(wp); 

resource.setLevelOfEmployment(100); 


} 

private void initDates(DateRange range){ 

startDate = DateHelper.generalizeDate(range.getStartDate()); 

endDate = DateHelper.generalizeDate(range.getEndDate()); 

} 

private void initDates(String start, String end){ 

SimpleDateFormat formatter = new SimpleDateFormat("dd.MM.yyyy"); 

try { 

startDate = DateHelper.generalizeDate(formatter.parse(start)); 

endDate = DateHelper.generalizeDate(formatter.parse(end)); 

} catch (ParseException e) { 

e.printStackTrace(); 

} 

} 

private static class MockedHolidayService implements HolidayService { 

} 

@Override 

public HolidayDto save(HolidayDto dto) { 

return null; 

@Override 

public List find(QueryCriteria criteria) { 


} 

@Override 

public void remove(HolidayDto dto) { 

} 

@Override 

public List getAll() { 

return null; 

} 

@Override 

public HolidayDto findHoliday(Date date) { 

return null; 

} 



17.2 Benutzerhandbuch 


Das nachfolgende Benutzerhandbuch wurde während der IPA um das Modul ResMan Reporting 

erweitert. 

Elisa Schnabel 21.05.2013 Seite 1

IPA-Dokumentation 2013 ResMan Reporting

Sie wollen auch ein ePaper? Erhöhen Sie die Reichweite Ihrer Titel.

Template löschen?

Als Template speichern?