Geavanceerde applicatie voor patiëntopvolging en trendanalyse
Jonas Casteur en Kim Schrooten
Promotoren: prof. dr. ir. Filip De Turck, prof. dr. Koenraad Smets Begeleiders: dr. ir. Marc De Leenheer, Kristof Steurbaut Masterproef ingediend tot het behalen van de academische graad van Master in de toegepaste informatica Vakgroep Informatietechnologie Voorzitter: prof. dr. ir. Daniël De Zutter Vakgroep Pediatrie en genetica Voorzitter: prof. dr. Dirk Matthys Faculteit Ingenieurswetenschappen Academiejaar 2009-2010
Voorwoord
Graag willen we een aantal mensen bedanken die dit eindwerk mede tot stand hebben gebracht.
Vooreerst gaat onze dank naar Prof. Dr. Ir. Filip de Turck en prof. dr. Koenraad Smets, onze promotoren, voor hun positieve aanmoediging en begeleiding. Daarnaast willen we onze begeleiders dr. ir. Marc De Leenheer en Kristof Steurbaut bedanken voor hun raadgeving en betrokkenheid. Een speciaal woord van dank gaat uit naar Femke De Backere voor het bijstaan in moeilijke tijden. Ten slotte willen we ook onze familie en vrienden voor de interesse en steun.
Jonas Casteur en Kim Schrooten Gent, 28 mei 2010
ii
Verklaring van bruikleen
De auteurs geven de toelating deze masterproef voor consultatie beschikbaar te stellen en delen van de masterproef te kopiëren voor persoonlijk gebruik. Elk ander gebruik valt onder de beperkingen van het auteursrecht, in het bijzonder met betrekking tot de verplichting de bron uitdrukkelijk te vermelden bij het aanhalen van resultaten uit deze masterproef.
Gent, 28 mei 2010
Jonas Casteur
Kim Schrooten
iii
Inhoudstabel Voorwoord ........................................................................................................................................... ii
Verklaring
van
bruikleen ............................................................................................................... iii
Lijst
van
figuren..................................................................................................................................vi
Lijst
van
tabellen .............................................................................................................................viii
Gebruikte
afkortingen
en
termen ................................................................................................ix
1
Inleiding ..........................................................................................................................................1
1.1
Probleemstelling .................................................................................................................................1
1.2
Doelstelling............................................................................................................................................2
2
Analyse
van
de
functionele
vereisten ...................................................................................3
2.1
Vereisten ................................................................................................................................................3
2.2
Draaiboek
op
basis
van
documentatie
UZ
Gent ........................................................................4
2.3
Use
case
diagram .................................................................................................................................8
3
Architectuur...................................................................................................................................9
3.1
Highlevel
architectuur .....................................................................................................................9
3.1.1
Theorie................................................................................................................................................................. 9
3.1.2
Toepassing ...................................................................................................................................................... 11
3.2
Database .............................................................................................................................................. 13
3.2.1
Theorie.............................................................................................................................................................. 13
3.2.2
Toepassing ...................................................................................................................................................... 14
3.2.3
Databasemap.................................................................................................................................................. 18
3.3
Java
Enterprise
Edition................................................................................................................... 24
3.3.1
Persistence
tier ............................................................................................................................................. 24
3.3.2
Business
logic
tier ........................................................................................................................................ 28
3.3.3
Web
tier............................................................................................................................................................ 32
3.4
Invoer:
PDF ......................................................................................................................................... 37
3.4.1
iText ................................................................................................................................................................... 37
3.4.2
OpenOffice.org............................................................................................................................................... 38
3.5
Uitvoer:
notificaties
en
rapportering ........................................................................................ 39
3.5.1
Herinnerings
E‐mail.................................................................................................................................... 39
3.5.2
Exporteren
en
gegevensanalyse ............................................................................................................ 40
iv
4
Uitgewerkte
case ....................................................................................................................... 42
4.1
Opeenvolging
taken......................................................................................................................... 42
4.2
Gebruikershandleiding .................................................................................................................. 46
4.2.1
Registreren
als
nieuwe
gebruiker......................................................................................................... 46
4.2.2
PDF‐formulieren
downloaden
en
uploaden ..................................................................................... 51
4.2.3
Het
admin
menu ........................................................................................................................................... 55
5
Conclusie
en
mogelijke
uitbreidingen ............................................................................... 58
Bijlagen................................................................................................................................................ 59
Bibliografie......................................................................................................................................... 61
v
Lijst van figuren Figuur 1 Cytomegalovirus .........................................................................................1
Figuur 2 Usecase diagram van de functionele vereisten .................................................8
Figuur 3 Java EE architectuur ....................................................................................9
Figuur 4 Gedetailleerde Java EE architectuur ............................................................. 10
Figuur 5 Java EE voor de CMV applicatie ................................................................... 11
Figuur 6 One-to-one mapping.................................................................................. 13
Figuur 7 One-to-many, many-to-one mapping ........................................................... 13
Figuur 8 Many-to-many mapping ............................................................................. 14
Figuur 9 Algemeen overzicht van de database ........................................................... 19
Figuur 10 Database Patient - Mother relatie............................................................... 20
Figuur 11 Database Patient - Doctor relatie ............................................................... 20
Figuur 12 Database Diagnostic ................................................................................ 21
Figuur 13 Database AudioFollowup ........................................................................... 21
Figuur 14 Database AudioIntake .............................................................................. 22
Figuur 15 Database Treatment ................................................................................ 22
Figuur 16 Database Additional Screening .................................................................. 23
Figuur 17 Relatie tussen Patient en Mother................................................................ 26
Figuur 18 Legende Java Server Pages ....................................................................... 34
Figuur 19 Java Server Pages - Inlog- en registratieproces ........................................... 35
Figuur 20 Java Server Pages - Menukeuze................................................................. 35
Figuur 21 Java Server Pages - Administratormenu...................................................... 36
Figuur 22 CSV bestand ........................................................................................... 41
vi
Figuur 23 legende stroomdiagram ............................................................................ 42
Figuur 24 Stroomdiagram registratieproces ............................................................... 43
Figuur 25 Stroomdiagram Invullen patiëntgegevens ................................................... 44
Figuur 26 Stroomdiagram gebruikersbeheer .............................................................. 45
Figuur 27 Startpagina website ................................................................................. 46
Figuur 28 Registratie pagina.................................................................................... 47
Figuur 29 Mededeling nieuwe gebruiker aan admin..................................................... 47
Figuur 30 E-mail bevestiging registratie .................................................................... 48
Figuur 31 Welkomstpagina admin ............................................................................ 48
Figuur 32 Admin menu ........................................................................................... 49
Figuur 33 Pagina met lijst nieuwe registraties ............................................................ 50
Figuur 34 E-mail bevestiging toegang ....................................................................... 50
Figuur 35 E-mail account verwijderd......................................................................... 51
Figuur 36 Welkomstpagina gewone gebruiker ............................................................ 51
Figuur 37 Lijst patiënten van de gebruiker ................................................................ 52
Figuur 38 Download pagina ..................................................................................... 52
Figuur 39 PDF-formulier registratie patiënt ................................................................ 53
Figuur 40 PDF-Formulier Behandeling patiënt ............................................................ 54
Figuur 41 Upload pagina ......................................................................................... 55
Figuur 42 User management ................................................................................... 56
Figuur 43 E-mail toekennen admin rechten ............................................................... 56
Figuur 44 Bestanden exporteren naar csv ................................................................. 57
vii
Lijst van tabellen Tabel 1 Draaiboek op basis van documentatie van het UZ Gent ......................................7
Tabel 2 Datatypes in Java ....................................................................................... 24
Tabel 3 Entiteiten in Java EE ................................................................................... 27
Tabel 4 Facades..................................................................................................... 28
Tabel 5 Session beans ............................................................................................ 32
Tabel 6 Java Server Pages ...................................................................................... 34
Tabel 7 CSV invoer in Excel ..................................................................................... 41
viii
Gebruikte afkortingen en termen CMV ejb war Java EE PDF html csv UML SMTP
Cytomegalovirusinfectie Enterprise JavaBeans Web Application Archive Java Enterprise Edition Portable Document Format HyperText Markup Language Comma-separated values Unified Modelling Language Simple Mail Transfer Protocol
De term gebruiker staat voor een arts die van het systeem gebruik maakt. Indien deze gebruiker een administrator is, zal hij admin worden genoemd.
ix
1
Inleiding
1.1
Probleemstelling
Cytomegalovirus(CMV)-infectie is een veelvoorkomende perinatale besmetting. Deze besmetting wordt aangetroffen bij 0,6 tot 1% van de levendgeborenen in Vlaanderen per jaar. Dit vertaalt zich naar 400 tot 600 patiënten per jaar. Bij de patiënten worden er op lange termijn vooral neurosensoriële doofheid en psychomotorische vertraging in de ontwikkeling gevreesd als gevolg van de congentiale infectie (Goossens, Temmerman, & Vanhaesebrouck, 2003). Door het beschikbaar worden van het geneesmiddel Ganciclovir (Cymevene®), dat mogelijk een belangrijke rol kan spelen bij de preventie van ernstige gehoorstoornissen bij het opgroeiend kind, komt deze infectieziekte opnieuw in het centrum van de belangstelling.
Figuur 1 Cytomegalovirus (Abbott Diagnostics, 2006)
Een elektronische database is van belang voor een langdurige opvolging van alle kinderen met
congenitale
CMV-infectie
in
Vlaanderen.
Op
dit
moment
is
hiervoor
geen
databankgedreven applicatie aanwezig op de afdeling Neonatalogie van het Universitair Ziekenhuis Gent. Hierdoor zijn de artsen genoodzaakt alle data op papieren documenten te bewaren. Indien men deze data wil analyseren of exporteren moet dit handmatig in een Excelbestand ingevoerd worden. Dit maakt opvolging, analyse en opzoekingen uiterst moeilijk en omslachtig. In nauwe samenwerking met het Universitair Ziekenhuis Gent werd
1
daarom besloten een databankgedreven applicatie te ontwikkelen ter ondersteuning van de dataregistratie en opvolging.
1.2
Doelstelling
De doelstelling is het ontwikkelen van een systeem waarmee geregistreerd kan worden hoe de diagnostiek tot stand kwam, welke afwijkingen aanwezig waren bij de geboorte en het verloop van de verdere behandeling. Dit heeft als doel de patiënten op lange termijn (6 jaar) op te volgen op het gebied van neuromotoriek, gehoor en visus. Visus is een maat voor gezichtsscherpte als onderdeel van het gezichtsvermogen. Het systeem maakt het daarnaast mogelijk om de verzamelde gegevens te onderwerpen aan data-analyse om belangrijke tendensen weer te geven.
2
2
Analyse van de functionele vereisten
In dit hoofdstuk wordt eerst een overzicht gegeven van de functionele eisen die aan de applicatie worden gesteld. Daarna geeft een use case diagram de mogelijkheden per gebruiker weer.
2.1 •
Vereisten Gebruikersregistratie: Elke arts kan zich online registreren als een potentiële gebruiker van de applicatie. Een nieuwe gebruiker moet door een administrator toegang verleend worden tot de website. Zolang een administrator een nieuwe gebruiker niet aanvaard heeft, kan de gebruiker niet inloggen.
•
Patiëntregistratie: Elke gebruiker kan gegevens van zijn patiënten invullen. Elke gebruiker moet toegang kunnen krijgen tot de gegevens van zijn patiënten. Om de gegevens van patiënten van andere artsen te bekijken is echter eerst goedkeuring nodig door een administrator. Bij patiënten die door een andere arts behandeld worden kan men enkel het ID nummer, geslacht en geboortedatum bekijken, zodat de persoonlijke gegevens van de patiënt vertrouwelijk blijven.
•
Formulieren: De verschillende formulieren om de patiëntinformatie in te vullen kunnen als PDF-formulier van de website gedownload worden. Dit biedt de mogelijkheid aan de artsen om de gegevens op een later tijdstip, al dan niet verbonden met het internet, in te vullen. Zodra de formulieren zijn ingevuld, kan de gebruiker de formulieren uploaden op de website, zodat ze in een centrale database bewaard worden.
•
Follow-up:
Elke
6
maanden
na
de
geboorte
van
de
patiënt,
dient
zijn
behandelende arts een follow-up formulier in te vullen. Wanneer zo een deadline nadert, moet de applicatie automatisch een e-mail ter herinnering naar de arts sturen.
•
Excel: De gebruiker heeft de mogelijkheid om de verschillende patiëntgegevens uit de database te exporteren naar Excel (bv. door middel van een csv-bestand). Hierdoor kan men verdere analyses uitvoeren op de gegevens uit de database.
•
Administrator: Beheerders moeten in staat zijn om de lay-out van de PDFformulieren aan te passen, zoals bv. toevoegen of weglaten van items. Verder kan
3
een administrator een gewone gebruiker administrator rechten gegeven en gebruikers verwijderen.
•
Rapportering: Jaarlijks moet op eenvoudige wijze een verslag gegenereerd worden, waarin belangrijke tendensen worden weergegeven op numerieke en grafische wijze.
2.2
Draaiboek op basis van documentatie UZ Gent
1
User
2
Administrator
3
Beide
4
Applicatie zelf Actie
1 1
Surfen naar de website Aanvraag login
•
Toont loginscherm: login of aanvraag login
•
Aanvrager vult gegevens in in het formulier op de website: o
Naam en Voornaam
o
E-mail adres
o
Telefoonnummer
o
Vakgebied
o
Eventueel soort arts
o
Ziekenhuis
of
praktijk
(eventueel
adres) o
Eventueel
commentaar
waarom
hij
een login wilt •
Wanneer
de
aanvrager
op
‘Send’
drukt,
worden deze gegevens doorgestuurd naar de administrator. De admin krijgt via e-mail een notificatie
en
hij
kan
deze
aanvraag
terugvinden op de website onder een speciale pagina ‘Aanvragen’
2
Goedkeuren aanvragen en paswoorden
•
De administrator behandelt de aanvraag en beslist of deze aanvaard wordt. Hij kan op een venster waartoe
enkel hij toegang tot heeft
een lijst van aanvragen zien. •
Bij aanvaarding wordt er automatisch een registratie van de user
in de database
gemaakt en een e-mail gestuurd naar de user met daarin:
4
Login-naam: (in optie) een combinatie
o
van de eerste letter van de voornaam en de
achternaam
en
afkorting
van
het
vakgebied Paswoord: (in optie) automatisch random
o
gegenereerd
door
de
applicatie.
Mogelijkheid tot wijzigen via de website later •
Bij weigering wordt er een e-mail gestuurd naar de aanvrager met een e-mailadres of telefoonnummer waarmee hij de admin zal kunnen contacteren voor verdere vragen
3
Keuzemogelijkheden website
Gebruikers •
Ingeven nieuwe patiënt
•
Invullen/(wijzigen: in optie) gegevens
•
Raadplegen gegevens patiënten (in optie)
•
Userprofiel
(in
optie,
voor
aanpassen
gegevens, o.a. paswoorden) •
Tabel met de namen van de patiënten van de arts en hun IDNummers
Administrator: o
Aanvragen login
o
Aanvragen leesrechten (in optie)
o
Patiënten
Alle informatie over patiënt opzoeken
In
optie:
Verschillende
views
(alle
patiënten per arts, vakgebied, leeftijd, enz) o
Formulieren
(in
optie:
mogelijkheid
tot
aanpassen)
1
Ingeven nieuwe patiënt
•
•
Ingeven persoonsgegevens: o
Naam en voornaam
o
Geboortedatum
o
Geslacht
o
Geen adres
o
(Naam ziekenhuis/praktijk)
o
(Vakgebied)
Wanneer de arts op ‘ok’ drukt, wordt de patiënt toegevoegd aan de database met het IDNummer
dat
automatisch
wordt
wordt
ander
aangemaakt. •
Voor
elk
vakgebied
er
een
5
IDNummer aangemaakt per patiënt. In de database moet dan wel een koppeling komen voor
de
patiënt
met
de
verschillende
IDNummers. •
In optie: een pdf-bestand wordt aangemaakt met deze informatie + het IDNummer voor de patiënt
1
Invullen gegevens patiënt
•
De arts kan op basis van het IDNummer waarden ingeven van een patiënt. o
Ingave IDNummer van de patiënt
o
In optie: het tijdstip van waarneming moet telkens vermeld worden
o
Tekstvelden
o
Keuzelijsten waar slechts 1 item kan geselecteerd worden Keuzelijsten
o
waar
meerdere
items
in
geselecteerd worden In optie: na ingave kan de arts deze waarden exporteren naar een pdf-bestand •
De arts kan enkel waarden ingeven voor IDNummers waar hij toegangsrechten (leesen schrijfrechten) voor heeft
•
Bij het bevestigen worden de gegevens in de database gekoppeld aan het IDNummer
•
Optie: Mogelijkheid om vorige ingaven te wijzigen
3
Raadplegen gegevens patiënten
•
Gegevens
van
de
patiënten
van
de
arts
moeten kunnen worden weergegeven o
IDNummer
o
Leeftijd
o
Geslacht
o
Waarden
o
Tijdstip (vanaf geboorte blokken van 6 maanden)
Deze moeten geëxporteerd kunnen worden naar een excelbestand. •
Mogelijkheid gegevens andere artsen in te kijken, mits goedkeuring admin. De arts geeft aan welke gegevens hij wilt bezichtingen: o
Dezelfde patiënt, ander vakgebied
o
Hetzelfde vakgebied, alle patiënten
o
Alle vakgebieden, alle patiënten
6
In optie: de admin ontvangt deze aanvraag en beslist of hij (lees)rechten geeft aan de arts. o
Dit kan beperkt worden in de tijd
o
Het is nooit toegelaten om persoonlijke informatie (de naam van de patiënt) mee te geven. Er wordt altijd gewerkt op basis van IDNummers.
•
Gegevens
(of
een
deel
daarvan)
moeten
kunnen geëxporteerd worden naar een excelbestand.
2
Aanpassen
keuzemogelijkheden
bij
•
invoer van waarden
De admin moet de mogelijkheid hebben om op vraag van de arts de keuzemogelijkheden voor invoer van de gegevens te wijzigen (extra mogelijkheden toevoegen).
•
Hierdoor wordt er een nieuw veld aangemaakt in de database, oudere records kunnen hier best ‘null’ krijgen
•
Artsen van het vakgebied krijgen hierover een mail zodat ze op de hoogte zijn van de wijziging
4
Reminders
•
De database houdt bij wanneer de deadlines voor
ingave
zijn
(elke
6
maanden
na
geboortedatum) •
De applicatie kijkt elke nacht na of er een deadline nadert
•
Bij het naderen van de deadline wordt er een reminder gestuurd naar de arts om gegevens aan te vullen.
•
Als gegevens al ingevuld zijn, vervalt de deadline
4
Rapporteringmodule
•
Jaarlijks
aanmaak
van
een
rapport,
progressief in de tijd •
Eventueel samen met exportering van de gegevens in excel. Voor de analyse kan men een macro in Excel schrijven.
•
Een vast aantal items komen jaarlijks terug in het verslag
Tabel 1 Draaiboek op basis van documentatie van het UZ Gent
7
2.3
Use case diagram
Het use case diagram geeft een schematisch overzicht welke de functies zijn waarvan de verschillende gebruikers, zijnde een gewone gebruiker en administratoren, gebruik kunnen maken.
Figuur 2 Usecase diagram van de functionele vereisten
8
3
Architectuur
3.1
High-level architectuur
3.1.1
Theorie
Voor
de
ontwikkeling
van
deze
applicatie
hebben
we
gekozen
voor
de
programmeeromgeving Java EE. Deze omgeving laat toe om meerdere lagen in de applicatie
te
programmeren.
Op
de
Java
EE
server
kan
men
meerdere
lagen
onderscheiden:
Web
tier
Business
logic
tier
Persistence
tier
Figuur 3 Java EE architectuur
De web tier is de presentatielaag van de applicatie. Hier wordt de architectuur voor de gebruikerszijde geprogrammeerd, bijvoorbeeld een website. Deze architectuur wordt geprogrammeerd in jsp-files, Java Server Pages. Dit zijn tekstgebaseerde documenten waarin men in een combinatie van HTML code en Java code gaat programmeren die de client (gebruiker) te zien krijgt. De business logic tier maakt deel uit van de business tier op de Java EE server (zie Figuur 4). Hier wordt door middel van session beans geprogrammeerd wat de verschillende stappen zijn voor het uitvoeren van opdrachten. Session beans zijn kleine programma’s die uittekenen hoe men de opdrachten van de gebruiker zal uitvoeren (bijvoorbeeld het ingeven van data in een formulier, het opvragen van een lijst van gebruikers, enz…). Daarnaast behandelt de logische laag met behulp van facades de verschillende opdrachten voor de database. Deze laag kan bijvoorbeeld een nieuwe entity Persoon aanmaken met de door de gebruiker ingevoerde gegevens, door middel van een query (zoekopdracht) de personen met achternaam Janssen opzoeken, enz...
9
De persistence tier maakt deel uit van de business tier op de Java EE server en is een schakel in de communicatie tussen de logische laag (meer bepaald de facades) en de database. In deze laag worden de tabellen van de database gegenereerd. Men gaat entiteiten programmeren waarin men definieert welke waarden in de tabellen komen (bijvoorbeeld een entity Persoon met daarin de variabelen Voornaam, Achternaam, Geboortedatum en Geslacht). Deze entiteiten kan men in de Java EE programmeertaal beschouwen als een op zichzelf staand object dat verbonden kan worden met andere entiteiten (bijvoorbeeld Persoon kan verbonden worden met Woonplaats). Op die manier kan de volledige wereld gemodelleerd worden.
Figuur 4 Gedetailleerde Java EE architectuur (Sun, 2008)
Een van de grote voordelen van een gelaagde architectuur is dat men zeer gemakkelijk een laag kan aanpassen zonder de overige lagen te moeten herprogrammeren. Dit komt de uitbreidbaarheid van de applicatie ten goede. Daarnaast zorgen de lagen voor meer plaatsen waar het systeem beveiligd kan worden. Door de gelaagdheid kan de gebruiker bijvoorbeeld nooit rechtstreeks de data in de database wijzigen omdat zijn opdrachten worden behandeld door de logische laag. De architectuur maakt het ook mogelijk dat de lagen draaien op verschillende servers, waardoor men het functioneren van de applicatie kan distribueren (Cade, Humphrey, & Sheil, 2010). Een gedistribueerde uitvoering is, mits een goede planning, efficiënter omdat de delen van de applicatie op servers kunnen draaien die het meest geschikt zijn voor de specifieke functionaliteit. Java EE is daarnaast
10
ook platformafhankelijk, wat betekent dat het probleemloos op elke computer kan draaien, onafhankelijk van bijvoorbeeld het besturingssysteem.
3.1.2
Toepassing
De componenten van onze applicatie voor patiëntopvolging en trendanalyse hebben we op volgende wijze geprogrammeerd:
Figuur 5 Java EE voor de CMV applicatie
Aan de web tier kant hebben we onder meer een login pagina en een upload pagina voor de PDF-formulieren geprogrammeerd (een gedetailleerde uitwerking volgt verder in deel 0). Daarnaast hebben we een mogelijkheid voorzien om een administrator te benoemen die meer rechten heeft dan een gewone gebruiker en de verschillende registratieaanvragen behandelt. De business logic tier heeft session beans (facades) die het onder meer mogelijk maken entiteiten aan te maken (create), deze op te slaan in de database (persist) en om zoekopdrachten uit te voeren (find). De session bean logic behandelt onder meer het inlezen van de gegevens van de PDF-formulieren en de registratie van een nieuwe gebruiker (een gedetailleerde uitwerking volgt verder in deel 0). Een mailcomponent is geprogrammeerd om de verschillende bevestigingen en reminders (die bijgehouden worden door de timer) te sturen. Als laatste hebben we de mogelijkheid voorzien om de data van de database te exporteren naar een csv bestand, wat de mogelijkheid biedt deze data verder te analyseren in Excel.
11
De persistence tier bevat entiteiten zoals Patient, Doctor, Treatment, enzovoort. Elk PDFformulier (treatment, additional screening, …) is een entity omdat deze gegevens als een aparte tabel in de database worden opgeslagen.
12
3.2
Database
3.2.1
Theorie
In een database kan men 4 soorten relaties definiëren: •
One-to-one
•
One-to-many
•
Many-to-one
•
Many-to-many
One-to-one Elke entity-instantie is gerelateerd aan een enkele instantie van een andere entity. De annotatie javax.persistence.OneToOne wordt geïmporteerd in de entiteiten die deel uitmaken van deze relatie.
Figuur 6 One-to-one mapping
One-to-many, Many-to-one Een entity-instantie kan gerelateerd zijn aan verschillende instanties van andere entiteiten. Iemand woont bijvoorbeeld in één stad, maar deze stad heeft meer dan één inwoner. De annotatie javax.persistence.OneToMany wordt geïmporteerd in de entiteiten die deel uitmaken van deze relatie.
Figuur 7 One-to-many, many-to-one mapping
13
Many-to-many De entity-instanties kunnen gerelateerd zijn aan verschillende instanties van andere entiteiten. Een student volgt bijvoorbeeld veel vakken en deze vakken hebben meerdere studenten. De annotatie javax.persistence.ManyToMany
wordt geïmporteerd in de
entiteiten die deel uitmaken van deze relatie (Sun, 2008).
Figuur 8 Many-to-many mapping
3.2.2
Toepassing
In dit hoofdstuk wordt onze databasestructuur uitgelegd aan de hand van Java EE entiteiten. Voor een gedetailleerde uiteenzetting van deze entiteiten, gelieve paragraaf 3.3.1.2 te raadplegen of Tabel 3. One-to-one Tussen de entiteiten Patient en Mother bestaat er een one-to-one relatie. Een moeder kan meerdere kinderen (patients) hebben maar een kind heeft maar één moeder. Deze verhouding doet een one-to-many relatie vermoeden maar dit wordt onmogelijk gemaakt doordat de gegevens van de moeder telkens vernieuwd worden bij ingave. Waarden zoals het aantal weken zwangerschap, de plaats van tewerkstelling, enz. kunnen bij elke geboorte gewijzigd zijn. Deze relatie wordt geprogrammeerd in de entity Patient op volgende wijze: @OneToOne
private
Mother
patient_mother;
public
Mother
getPatient_mother()
{
return
patient_mother;
}
public
void
setPatient_mother(Mother
patient_mother)
{
this.patient_mother
=
patient_mother;
}
14
In de entity Mother wordt deze relatie op volgende wijze geprogrammeerd: @OneToOne(mappedBy
=
"patient_mother")
private
Patient
patient;
MappedBy geeft de “owning side” van de relatie aan. In een bidirectionele one-to-one relatie bevindt deze notatie zich in de entity die de foreign key bevat, in dit geval Mother. In een Patient record zal de ID van Mother in een kolom ingevuld worden. Op deze manier kan men Patient met Mother linken. One-to-many, many-to-one Patients kunnen verschillende Doctors hebben en Doctors hebben verschillende Patients. Wanneer een Patient entity wordt ingegeven in de database krijgt deze automatisch een ID. Opdat de gegevens van bijvoorbeeld behandelingen en onderzoeken gescheiden kunnen blijven voor andere gebruikers, hebben we geopteerd voor een mapping tussen Patient en Doctor, zijnde de entity Patient_Doctor. Deze mapping is een entity (in plaats van een automatisch
gegenereerde
mapping)
omdat
we
dit
kunnen
zien
als
een
soort
patiëntdossier. De behandelende arts zal de mapping ID, niet de Patient ID, gebruiken om in te vullen in de forms. Mapping ID
Patient ID
Doctor ID
ID1
Patient1
Doctor1
ID2
Patient1
Doctor2
ID3
Patient2
Doctor1
Voor Patient1 zal ID1 gebruikt worden door Doctor1 en ID2 door Doctor2. Deze relatie wordt geprogrammeerd in Patient op volgende wijze: @OneToMany(mappedBy
=
"ID_Patient")
private
List<Patient_Doctor>
patient_Doctors;
In de entity Doctor wordt dit op soortgelijke wijze geprogrammeerd: @OneToMany(mappedBy
=
"ID_Doctor")
private
List<Patient_Doctor>
patient_Doctors;
Dit zijn One-to-many relaties omdat een Patient of Doctor meerdere mapping ID’s kan hebben. Het omgekeerde geldt niet, een mapping ID kan niet gedeeld worden door meerdere Patients of Doctors.
15
In Patient en Doctor wordt er een List opgegeven van de verschillende mapping ID’s die bij deze entiteiten horen. In de entity Patient_Doctor wordt deze relatie als volgt geprogrammeerd:
@ManyToOne
private
Patient
ID_Patient;
public
Patient_Doctor()
{
}
public
Patient
getID_Patient()
{
return
ID_Patient;
}
public
void
setID_Patient(Patient
ID_Patient)
{
this.ID_Patient
=
ID_Patient;
}
@ManyToOne
private
Doctor
ID_Doctor;
public
Doctor
getID_Doctor()
{
return
ID_Doctor;
}
public
void
setID_Doctor(Doctor
ID_Doctor)
{
this.ID_Doctor
=
ID_Doctor;
}
Deze relaties zijn Many-to-one omdat verschillende mapping ID’s gelinkt zijn aan één Patient en één Doctor. Voor de relatie tussen de verschillende forms en de mapping ID hebben we gekozen voor volgende relatie: In bijvoorbeeld de entity (en tevens form) Treatment: @ManyToOne
private
Patient_Doctor
ID_Mapping;
public
Patient_Doctor
getID_Mapping()
{
return
ID_Mapping;
}
16
public
void
setID_Mapping(Patient_Doctor
ID_Mapping)
{
this.ID_Mapping
=
ID_Mapping;
}
In de mapping entity Patient_Doctor: @OneToMany(mappedBy
=
"ID_Mapping")
private
List
treatments;
Dit is een Many-to-one relatie in treatment omdat de verschillende treatment-entiteiten telkens verbonden zijn aan één mapping ID. Wanneer een arts een formulier invult met de gegevens over de behandeling, zal dit altijd over één patient gaan, nooit meerdere. In Patient_Doctor is dit een One-to-many relatie omdat één mapping ID verbonden kan zijn aan verschillende Treatments, bijvoorbeeld gespreid over de tijd. Daarom wordt aan de mapping entity een lijst opgegeven van alle verbonden Treatments. Many-to-many De verschillende forms (Patient, Treatment, Additional screening, …) bevatten velden waar meerdere antwoordmogelijkheden mogelijk zijn. Voor elke checkbox-vraag hebben we een many-to-many relatie geprogrammeerd. Een voorbeeld is bijvoorbeeld Occupational_hazards en Mother. Wanneer men de entity Mother aanmaakt, moet men meegeven of deze behoort tot een aantal risicoberoepen. Het is bijvoorbeeld mogelijk dat een moeder zowel een kleuterleidster als een verpleegster is. Daarnaast is het mogelijk dat meerdere moeders tot de risicogroep kleuterleidster horen. Deze relatie is met andere woorden many-to-many. Bij many-to-many relaties wordt er, om het overzicht te behouden, automatisch een mapping-tabel gemaakt in de database. Deze tabel zal een oplijsting geven van bijvoorbeeld welke Occupational_hazards bij welke Mothers horen. Database Mother
Mapping
Database O_H
Mother1
Mother1
OH1
OH1
Mother2
Mother1
OH3
OH2
Mother3
Mother2
OH1
OH3
In de entity Mother wordt deze relatie als volgt geprogrammeerd: @ManyToMany
private
Collection
occupational_hazards;
17
public
Collection
getOccupational_hazards()
{
return
occupational_hazards;
}
public
void
setOccupational_hazards(Collection
occupational_hazards)
{
this.occupational_hazards
=
occupational_hazards;
}
In de entity Occupational_hazards wordt de relatie als volgt geprogrammeerd:
@ManyToMany(mappedBy
=
"occupational_hazards")
private
List<Mother>
mothers;
In de entity Mother zal een collectie Occupational_hazards opgegeven worden, in de entity Occupational_hazards wordt er per hazard een lijst bijgehouden welke Mothers verbonden zijn aan het risicoberoep.
3.2.3
Databasemap
In de volgende figuur is de databasemap in zijn geheel afgebeeld. De rood gekleurde delen stellen de PDF-formulieren voor die de gebruiker invult. De automatische mappings voor de meerkeuzevragen worden voorgesteld als een veld met de notatie _has_. Dit geldt ook voor de automatische mapping tussen Patient en Mother. Voor een gedetailleerd overzicht van de entiteiten, gelieve Tabel 3 te raadplegen. De relaties tussen de delen worden aangeduid door middel van de UML (Unified Modelling Language) notatie. Het cijfer ‘1’ staat voor de eerder besproken betekenis van ‘One’, de notatie ‘1…*’ staat voor ‘Many’. In de volgende figuur is het duidelijk dat de mapping ID van Patient_Doctor gebruikt wordt als patient ID tijdens het invullen van de PDF-formulieren. In de figuren die de relaties in meer detail bespreken zal deze waarde telkens terug te vinden zijn.
18
Figuur 9 Algemeen overzicht van de database
19
Figuur 10 Database Patient - Mother relatie
Figuur 11 Database Patient - Doctor relatie
20
Figuur 12 Database Diagnostic
Door het groot aantal variabelen in AudioFollowup en AudioIntake worden er in de volgende twee figuren niet alle variabelen in afgebeeld.
Figuur 13 Database AudioFollowup
21
Figuur 14 Database AudioIntake
Figuur 15 Database Treatment
22
Figuur 16 Database Additional Screening
23
3.3
Java Enterprise Edition
Dit hoofdstuk geeft een gedetailleerde uiteenzetting van de architectuur weergegeven in Figuur 5.
3.3.1
Persistence tier
3.3.1.1 Definiëren van tabelwaarden De persistence tier bestaat uit entiteiten. Persistence staat voor het permanent opslaan van gegevens, bijvoorbeeld in een database. De entiteiten staan in het ejb-gedeelte (Enterprise JavaBeans) van de Java EE applicatie. De entiteiten stellen de verschillende tabellen voor die in de database zullen komen (met uitzondering van de automatische mapping-tabellen). Voor elke entity zal een facade gemaakt worden op een hoger niveau (zie paragraaf 3.3.2.1 voor een gedetailleerde uiteenzetting van facades). In de entiteiten wordt er bepaald welke waarden en datatypes in de tabel zullen komen. De datatypes zijn voorgeprogrammeerd door Java, maar het is mogelijk om nieuwe types te definiëren (bijvoorbeeld de entity Patient maakt een object Patient aan dat gebruikt kan worden in andere delen van de applicatie). Volgende tabel geeft een uiteenzetting van de meest gebruikte datatypes in de CMV applicatie: Naam
Programmacode
Domein
Bits
Integer
int
Gehele getallen
32
Long
long
Grote gehele getallen
64
Double
double
Reële getallen
64
String
String
Tekst
Boolean
boolean
True/False
1
Tabel 2 Datatypes in Java
Men bepaalt de datatypes telkens expliciet omdat het van belang is om zo efficiënt mogelijk geheugenruimte vrij te maken. Het datatype long geeft gehele getallen weer, maar heeft dubbel zoveel geheugenruimte nodig. Indien de ingevoerde waarden niet zo groot zijn, is het efficiënter om te opteren voor het datatype integer. Hetzelfde geldt voor het datatype double: als het ingevoerde getal geen cijfers achter de komma moet opslaan is het efficiënter om een integer te gebruiken.
24
Een voorbeeld van de waardedefinitie voor de entity Patient is:
@Id
@GeneratedValue(strategy
=
GenerationType.AUTO)
private
Long
id_Patient;
protected
String
name;
protected
String
firstName;
protected
String
birthDate;
protected
int
gestation;
protected
int
birthWeight;
protected
int
birthLength;
protected
int
headCircumference;
protected
String
refCenter;
@OneToOne
protected
Mother
mother;
...
De ID die de Patient automatisch toegewezen krijgt heet id_Patient. @Id geeft aan dat deze variabele als ID zal dienen en @GeneratedValue geeft aan dat deze automatisch wordt ingevuld. Private en Protected geven aan welke delen van de applicatie toegang hebben tot deze variabelen. Voor de toegang tot deze variabelen worden kleine methodes in de entity geschreven, namelijk getters (die de waarde van de variabele teruggeven) en setters (die een waarde aan de variabele toekennen). Daarnaast wordt er een constructor aangemaakt die een object van de entity zal aanmaken. Zoals vermeld kunnen entiteiten ook dienen als een variabele. Omdat Patient en Mother verbonden zijn door middel van een one-to-one relatie, is het object mother één van de variabelen.
25
.irstName
birthDate
mother
Patient
Figuur 17 Relatie tussen Patient en Mother
3.3.1.2 Entiteiten en meerkeuzevragen Zoals zal blijken in paragraaf 3.2.2 bevatten de PDF-formulieren soms vragen waarbij meerdere antwoordmogelijkheden aangevinkt kunnen worden. De antwoorden op dit soort vragen worden bijgehouden in een aparte tabel waarna een link wordt gelegd door middel van een mapping tussen de entiteiten (bijvoorbeeld Mother en Occupational_Hazard). Deze tabel geeft een opsomming van alle entiteiten en, indien van toepassing, de entiteiten van de
meerkeuzevragen die daarmee samenhangen. De entity Patient heeft
uitzonderlijk een one-to-one mapping met de entity Mother om de tabelgrootte te beperken.
De
Patient_Doctor.
meeste Dit
entiteiten
geldt
niet
hebben
voor
de
een entity
verbinding
met
Mother
de
en
de
mappingtabel
entiteiten
van
de
meerkeuzevragen, omdat deze entiteiten verbonden zijn met Patient_Doctor via hun gelinkte entiteiten. Voor een gedetailleerde uiteenzetting van de mappings, gelieve paragraaf 3.2.2 te raadplegen. Entity
Omschrijving
Patient.java
Deze
entiteiten
Mother.java
gegevens
over
Meerkeuzevragen
verzamelen de
patiënt
en
de
Occupational_Hazard.java
de
moeder Doctor.java
Deze entity verzamelt de gegevens van de arts.
Patient_Doctor.java
Dit is de mappingtabel tussen Patient en Doctor. De automatische ID die in deze mapping gemaakt wordt, wordt gebruikt als PatientID die de arts zal
26
invoeren in de PDF-formulieren. Treatment.java
AddScreening.java
Deze entity zal de gegevens over de
B2B_Reason_interruption.java
behandeling verzamelen.
B3C_Reason_stop.java
Deze entity zal de gegevens over de
A6B_Ultrasound.java
bijkomende screening verzamelen.
A7B_CT.java A8B_MRI.java A9B_Ofthalmology.java
AudioIntake.java
Deze
entity
gegevens
zal van
de
audiologische
de
diagnose
verzamelen. AudioFollowup.java
Deze
entity
gegevens
zal van
de
audiologische
de
follow-up
documenten verzamelen. Diagnostic.java
Deze entity zal de gegevens van de
FetalUltrasound.java
algemene diagnose verzamelen.
PresentationBirth.java ReasonScreening.java
Tabel 3 Entiteiten in Java EE
3.3.1.3 NamedQueries In de entiteiten voegen we basisinstructies toe om opzoekingen uit te voeren in de database. De eigenlijke methodes staan in de facades maar de zoekopdrachten (queries) staan in de entiteiten. Zie paragraaf 3.3.2 voor de verdere uitwerking van de facades. De
zoekopdrachten
heten
NamedQueries.
Hiervoor
is
het
nodig
om
javax.persistence.NamedQueries en javax.persistence.NamedQuery in de Javacode te importeren. Een voorbeeld van een NamedQuery voor de entiy Patient is: @NamedQueries({
@NamedQuery(name
=
"getPatFromID",
query
=
"SELECT
p
FROM
Patient
p
WHERE
p.id_Patient
=
:idvalue")
})
De query heeft als naam getPatFromID. De facade Patientfacade zal hier in de bijhorende methode naar verwijzen. Deze zoekopdracht zal alle Patient entiteiten (p) ophalen waarvoor geldt dat de id (id_Patient) gelijk is aan een door de gebruiker opgegeven waarde (idvalue).
27
3.3.2
Business logic tier
De business logic tier bestaat uit facades en session beans. Deze horen bij het ejb-gedeelte van de Java EE applicatie. Deze laag zorgt onder meer voor methodes die data in de database schrijven, data uit de database opvragen en complexe bewerkingen uitvoeren die de logische kant van de applicatie uitmaken. 3.3.2.1 Facades Elke entity heeft een facade. Deze facade heeft twee delen: de facade met de uitgewerkte methodes en een local of remote deel met daarin een verwijzing naar deze methodes. Men kiest voor een local interface wanneer het niet noodzakelijk is dat de facade toegankelijk is voor een andere laag, zoals bijvoorbeeld de web tier. Wanneer dit wel noodzakelijk is, zoals voor de timerfunctie, krijgt deze facade een remote karakter (Sriganesh, Brose, & Silverman, 2006). Zie paragraaf 3.4 voor een verdere uitwerking van de timerfunctie. Volgende tabel geeft een opsomming van alle facades: Facade
Interface
PatientFacade.java
PatientFacadeLocal.java
MotherFacade.java
MotherFacadeLocal.java
OccupationalHazardFacade.java
OccupationalHazardFacadeLocal.java
DoctorFacade.java
DoctorFacadeLocal.java
Patient_DoctorFacade.java
Patient_DoctorFacadeLocal.java
TreatmentFacade.java
TreatmentFacadeLocal.java
B2B_Reason_interruptionFacade.java
B2B_Reason_interruptionFacadeLocal.java
B3C_Reason_stopFacade.java
B3C_Reason_stopFacadeLocal.java
AddScreeningFacade.java
AddScreeningFacadeLocal.java
A6B_UltrasoundFacade.java
A6B_UltrasoundFacadeLocal.java
A7B_CTFacade.java
A7B_CTFacadeLocal.java
A8B_MRIFacade.java
A8B_MRIFacadeLocal.java
A9B_OfthalmologyFacade.java
A9B_OfthalmologyFacadeLocal.java
AudioIntakeFacade.java
AudioIntakeFacadeLocal.java
AudioFollowupFacade.java
AudioFollowupFacadeLocal.java
DiagnosticFacade.java
DiagnosticFacadeLocal.java
FetalUltrasoundFacade.java
FetalUltrasoundFacadeLocal.java
PresentationBirthFacade.java
PresentationBirthFacadeLocal.java
ReasonScreeningFacade.java
ReasonScreeningFacadeLocal.java
TimerFacade.java
TimerFacadeRemote.java
Tabel 4 Facades
28
In de facades worden verschillende methodes standaard geprogrammeerd, waaronder (voor Patient): @PersistenceContext
private
EntityManager
em;
public
void
create(Patient
patient)
{
em.persist(patient);
}
public
void
edit(Patient
patient)
{
em.merge(patient);
}
public
void
remove(Patient
patient)
{
em.remove(em.merge(patient));
}
public
Patient
find(Object
id)
{
return
em.find(Patient.class,
id);
}
public
List<Patient>
findAll()
{
CriteriaQuery
cq
=
em.getCriteriaBuilder().createQuery();
cq.select(cq.from(Patient.class));
return
em.createQuery(cq).getResultList();
}
public
List<Patient>
findRange(int[]
range)
{
CriteriaQuery
cq
=
em.getCriteriaBuilder().createQuery();
cq.select(cq.from(Patient.class));
Query
q
=
em.createQuery(cq);
q.setMaxResults(range[1]
‐
range[0]);
q.setFirstResult(range[0]);
return
q.getResultList();
}
public
int
count()
{
CriteriaQuery
cq
=
em.getCriteriaBuilder().createQuery();
Root<Patient>
rt
=
cq.from(Patient.class);
29
cq.select(em.getCriteriaBuilder().count(rt));
Query
q
=
em.createQuery(cq);
return
((Long)
q.getSingleResult()).intValue();
}
Daarnaast is het ook mogelijk om zelf methodes te definiëren. Volgende methode behoort tot de PatientFacade en geeft de entity Patient terug wanneer men de NamedQuery getPatFromID uitvoert. In een session bean wordt deze methode via de locale facade opgeroepen, die de entity Patient aan de session bean zal doorgeven. Zie paragraaf 3.3.2.2 voor een gedetailleerde uitwerking van session beans.
public
Patient
getPatFromID(long
patid){
try
{
Patient
pat
=
(Patient)
em.createNamedQuery("getPatFromID").setParameter("idvalue",
patid).getSingleResult();
return
pat;
}
catch
(Exception
e)
{
return
null;
}}
De methodes van de facade worden via de local of remote facade opgeroepen. Deze facade geeft de lijst weer van de gedefinieerde methodes. Session beans maken een (lokaal of remote) facadeobject aan, bijvoorbeeld facade, en roepen via dit object de methode aan, bijvoorbeeld facade.create(Patient aangemaaktePatient). Voor Patient is de lokale facade: @Local
public
interface
PatientFacadeLocal
{
public
void
create(Patient
patient);
void
edit(Patient
patient);
void
remove(Patient
patient);
Patient
find(Object
id);
List<Patient>
findAll();
List<Patient>
findRange(int[]
range);
int
count();
public
entity.Patient
getPatFromID(long
patid);
}
30
3.3.2.2 Session beans In de session beans wordt de logica van de applicatie ontwikkeld. Elke session bean hangt samen met een remote session bean. Een remote session bean biedt, zoals de local of remote facades, de mogelijkheid om de methodes in een ander deel van de applicatie op te roepen zoals bijvoorbeeld in de web tier. Voor een gedetailleerde uitwerking van de web tier en Java Server Pages in het bijzonder, zie paragraaf 3.3.3. Volgende tabel geeft een overzicht van de ontwikkelde session beans: Naam
Functie
createPediatrician.java
Zorgt bij de registratie van een nieuwe Doctor voor het
createPediatricianRemote.java
aanmaken van de entity en het versturen van de data naar de database. Voor het versturen van de data zal deze session bean de methode create van de DoctorFacade aanroepen.
InlezenBean.java
Deze session bean leest de waarden in die ingevuld zijn in
InlezenBeanRemote.java
de
PDF-formulieren.
Het
zal
de
gepaste
entiteiten
aanmaken en via de create methode van de facades deze data in de database invullen. OpvragenLijstPatientsBean.java
Deze session bean zorgt voor het opzoeken van de
OpvragenLijstPatientsBeanRemote.java
Patients en de bijhorende ID’s wanneer de gebruiker via de website de opdracht geeft om deze lijst op te roepen. Dit wordt mogelijk gemaakt door NamedQueries in de entiteiten
Patient_Doctor
en
Doctor
en
bijhorende
methodes in de facades. export.java
Deze session bean maakt het mogelijk om tabellen uit de
exportRemote.java
database om te zetten naar csv-bestand. Dit bestand kan later ingelezen worden door Excel. Deze mogelijkheid is enkel beschikbaar voor de administrator.
getPassword.java
Deze session bean ondersteunt het login gedeelte van de
getPasswordRemote.java
website en de admin functies. Wanneer een gebruiker inlogt zal deze session bean aan de hand van de doctorFacade paswoord
controleren
heeft
ingevuld,
of
de
gebruiker
admin
rechten
het
juiste
heeft
en
geactiveerd is. Verder bevat de session bean methodes om aan de admin te tonen wie zich als nieuwe gebruiker heeft geregistreerd, alsook methodes om een gebruiker te activeren, admin te maken of te verwijderen uit de database. Ten slotte is er nog een methode die alle gebruikers
of
een
gebruiker
met
een
opgegeven
familienaam toont aan de admin.
31
MailSender.java
Deze session bean is verantwoordelijk voor het verzenden
MailSenderRemote.java
van de mails naar de gebruikers.
Tabel 5 Session beans
3.3.3
Web tier
In de web tier worden jsp-files (Java Server Pages) gemaakt die als basis dienen voor de website. Dit hoort bij het war-gedeelte (Web Application Archive) van de Java EE applicatie. Jsp files bestaan uit een combinatie van HTML (HyperText Markup Language) en java code. Volgende tabel geeft een overzicht van de verschillende jsp files en hun functie: Naam Index.jsp
Functie Dit is de startpagina. Hier worden enkele sessievariabelen op default waarden gezet zodat het niet mogelijk is dat een gebruiker de sessievariabelen van de vorige ingelogde gebruiker overneemt. De gebruiker wordt vervolgens doorverwezen naar de Homepage.jsp.
Homepage.jsp
Hier kan een gebruiker zich registreren of inloggen. Vervolgens wordt hij doorverwezen naar controlpass.jsp of registration.jsp.
Registration.jsp
Hier wordt het registratieformulier voor de arts weergeven. De optie ‘back’ verwijst naar index.jsp, de optie ‘registreren’ verwijst naar savepediatrician.jsp.
Savepediatrician.jsp
Deze pagina zorgt ervoor dat de methodes opgeroepen worden om de arts in de database op te slaan. De sessievariabelen worden aangemaakt van de ingevulde gegevens. De sessievariabele bewaart de waarde tijdens het bezoek aan de website. Daarnaast worden de nodige e-mails verstuurd. Indien de registratie gelukt is wordt de gebruiker terug doorverwezen naar index.jsp. Indien de registratie mislukt is zal hij teruggeleid worden naar registration.jsp. De waarden zullen nog ingevuld staan (behalve het paswoord) door het instellen van de sessievariabelen.
Controlpass.jsp
Als de gebruiker wilt inloggen, wordt hier het ingegeven paswoord gecontroleerd.
Een sessievariabele wordt aangemaakt van het e-
mailadres en indien de gebruiker een administrator is, van de admin. Indien de login gelukt is, wordt de gebruiker doorverwezen naar menu.jsp, indien het niet gelukt is zal hij worden doorverwezen naar homepage.jsp. Menu.jsp
Dit is een simpel menu met de volgende opties: •
Menu: link naar menu.jsp
•
Download PDF-formulier: link naar download.jsp
•
Upload PDF-formulier: link naar upload.jsp
•
Zoek patiënten: link naar patientLijstOpvragen.jsp
32
•
Admin menu (indien de gebruiker een administrator is): link naar adminmenu.jsp
• Loguit.jsp
Log uit: link naar loguit.jsp
Dit zal alle bestaande sessievariabelen vernietigen. De gebruiker wordt terug doorverwezen naar index.jsp.
upload.jsp
Hier kunnen de gebruikers de ingevulde PDF-formulieren uploaden naar de server. Deze jsp file zal achter de schermen doorverwezen worden naar fileupload.jsp.
fileupload.jsp
Deze voor de gebruiker onzichtbare pagina zal het PDF-bestand verwerken door het oproepen van de inleesmethode van de session bean InlezenBean. Na de verwerking zal de gebruiker automatisch worden doorverwezen naar upload.jsp die de boodschap zal geven dat het uploaden gelukt of mislukt is.
download.jsp
Deze pagina bevat de links om de PDF-formulieren te downloaden.
patientLijstOpvragen.jsp
Deze pagina geeft een lijst weer van de patiënten van de ingelogde gebruiker en de bijhorende patientID’s. Deze pagina maakt gebruik van de session bean OpvragenLijstPatientsBean. De sessievariabele die het e-mailadres bijhoudt zorgt ervoor dat de gebruiker deze lijst automatisch te zien krijgt, zonder ingave van ID’s.
adminmenu.jsp
Deze pagina biedt de administrator 3 opties: •
Het menu voor de nieuwe gebruikers administratie: link naar newregistrations.jsp
newregistrations.jsp
•
Gebruikersbeheer: link naar newadmin.jsp
•
Het exporteren van tabellen naar csv: link naar csv.jsp
Deze pagina toont de lijst van de artsen die een aanvraag tot registratie hebben doorgestuurd. De administrator heeft 2 opties:
accept.jsp
•
De arts accepteren: link naar accept.jsp
•
De arts weigeren en de aanvraag wissen: link naar deny.jsp
De arts wordt geactiveerd in database. Er zal een e-mail gestuurd worden
naar
de
arts
ter
bevestiging.
De
administrator
wordt
doorverwezen naar adminMenu.jsp. deny
De arts wordt verwijderd in de database en krijgt een e-mail met de medeling. De administrator wordt doorverwezen naar adminMenu.jsp.
newadmin.jsp
Hier heeft de administrator de mogelijkheid om een gebruiker op basis van de achternaam te zoeken (link naar searchuser.jsp) of alle gebruikers weer te geven in een lijst (link naar showall.jsp). Als door een van de vorige twee acties een lijst wordt getoond, zijn er in die lijst twee opties: •
De gebruiker een administrator maken: link naar makeAdmin.jsp
• searchuser.jsp
De gebruiker verwijderen: link naar deny.jsp
Deze pagina is onzichtbaar voor de gebruiker. Hier wordt een
33
zoekopdracht gedaan op basis van de ingevulde naam. Daarna wordt de gebruiker terug doorverwezen naar newadmin.jsp. showall.jsp
Deze pagina is onzichtbaar voor de gebruiker. De sessievariabele showall wordt aangezet en de gebruiker wordt doorverwezen naar newadmin.jsp.
makeAdmin.jsp
Deze pagina is onzichtbaar voor de gebruiker. De gebruiker wordt in de database veranderd naar admin en wordt terug doorverwezen naar adminMenu.jsp.
csv.jsp
Deze pagina geeft een lijst met mogelijke downloads. De verschillende mogelijkheden hebben telkens een link naar csvdownload.jsp en geven via de post methode door welk bestand is aangeklikt.
csvdownload.jsp
Deze pagina roept de bijhorende methode op om de data uit de tabellen te exporteren naar .csv. De gebruiker wordt doorverwezen naar csv.jsp
Tabel 6 Java Server Pages
Volgende figuren geven de processen visueel weer.
Figuur 18 Legende Java Server Pages
34
Figuur 19 Java Server Pages - Inlog- en registratieproces
Figuur 20 Java Server Pages - Menukeuze
35
Figuur 21 Java Server Pages - Administratormenu
36
3.4
Invoer: PDF
In dit gedeelte wordt dieper ingegaan op twee componenten die gebruikt werden voor het maken en inlezen van de PDF-formulieren (dit zijn PDF-documenten die velden bevatten die
de
gebruiker
elektronisch
kan
invullen
of
selecteren),
met
name
iText
en
OpenOffice.org. 3.4.1
iText
iText is een gratis (open source) softwarepakket waarmee PDF-documenten kunnen aangemaakt
en
aangepast
worden
(Lowagie,
2006).
Het
is
geen
alleenstaand
softwarepakket, maar een Java bibliotheek die ingeladen kan worden in andere software. Dit betekent in ons geval dat we de iText bibliotheek moeten toevoegen aan de gebruikte bibliotheken van het project, zodat gebruik kan gemaakt worden van de methoden van iText. Als eerste hebben we de mogelijkheid om met iText PDF-furmulieren te creëren onderzocht. iText biedt het voordeel dat de PDF-documenten dynamisch opgebouwd kunnen worden: Wanneer in een van de meerkeuzevragen uit een formulier de optie ‘Other’ aangeduid zou worden, zou deze nieuwe optie de volgende keer dat het PDFformulier wordt gedownload standaard in het formulier kunnen staan. De praktijk leerde ons echter dat dit niet zo eenvoudig is. iText bleek vrij goed in staat om een formulier te creëren dat niet groter is dan 1 pagina. Wanneer een PDF-formulier echter groter is dan 1 pagina, moet steeds aangegeven worden wanneer een nieuwe pagina begint. Indien dit niet gebeurt, is enkel de laatste pagina invulbaar, wat niet wenselijk is. Dit is vooral een probleem wanneer we dynamisch opgebouwde PDF-formulieren wensen. Doordat de lengte van de meerkeuzevragen kan groeien, is onmogelijk op voorhand te bepalen waar een nieuwe pagina zal moeten beginnen. Aangezien deze automatische opbouw van PDFformulieren via iText moeilijk te realiseren is, hebben we er voor gekozen om de formulieren aan te maken met een ander software pakket, met name Open Office (zie verder). Naast het aanmaken van PDF-documenten kan iText ook gebruikt worden voor het inlezen en verwerken van PDF-documenten. iText is in staat om de inhoud van ingevulde velden in te lezen uit een document dat aan de methode doorgegeven wordt als een bytestroom. Dit wordt geïllustreerd door onderstaand voorbeeld: public
void
readPDF(byte
file[]){
PdfReader
reader
=
new
PdfReader(file);
AcroFields
form
=
reader.getAcroFields();
37
String
firstName
=
form.getField("FirstName");
String
lastName
=
form.getField("LastName");
}
In het voorbeeld wordt de inhoud uit een ingevuld veld achterhaald door de methode form.getField(). Deze methode moet als argument de naam van het veld krijgen, zoals deze gedefinieerd is bij de opbouw van het PDF-document. Bij de opbouw van het document moet er dus op gelet worden dat elk veld een unieke naam krijgt. De methode leest elk veld in als een String. Indien het veld als een ander datatype in de database moet geplaatst worden, bijvoorbeeld een integer of een boolean, moet er dus steeds nog een conversie gebeuren. Het inlezen van de PDF-formulieren als een bytestroom biedt een extra voordeel. Hierdoor moet de server immers geen kopie van het document bijhouden en is de ingevulde data enkel zichtbaar in de database, wat op vlak van veiligheid meer wenselijk is.
3.4.2
OpenOffice.org
OpenOffice.org is een gratis (open source) softwarepakket voor kantoortoepassingen, vergelijkbaar met het meer bekende Microsoft Office. Het programma OpenOffice.org Writer uit het pakket biedt de mogelijkheid om PDF-formulieren aan te maken. De verschillende items zoals invulvelden, checkboxen en lijsten, kunnen eenvoudig in het formulier gesleept worden. OpenOffice.org heeft echter als nadeel dat enkel statische documenten kunnen aangemaakt worden: eens het PDF-formulier is opgesteld kan het niet meer gewijzigd worden om bijvoorbeeld extra keuzemogelijkheden toe te voegen. Omwille van de gebruiksvriendelijkheid van OpenOffice.org en omdat het via iText moeilijk een beter alternatief kon gemaakt worden voor onze formulieren, hebben we er voor gekozen om onze PDF-formulieren te creëren via de OpenOffice.org software. Ten slotte dient opgemerkt te worden dat PDF-formulieren niet ingevuld kunnen worden met de gratis versie van Adobe Reader. Gebruikers van die versie kunnen enkel een blanco kopie van het document opslaan. Hiervoor zal de gebruiker moeten beschikken over de volledige (betalende) versie van Adobe Reader.
38
3.5
Uitvoer: notificaties en rapportering
Deze sectie gaat dieper in op twee aspecten van de uitvoer van de applicatie, met name het automatisch versturen van de herinnerings e-mail en het exporteren van de data uit de database naar Excel.
3.5.1
Herinnerings E-mail
De applicatie vereist dat de artsen elke 6 maanden na de geboorte van een patiënt, een follow-up formulier invullen. Bij het naderen van een deadline, dient de applicatie automatisch een e-mail ter herinnering naar de arts sturen. Hiervoor maken we gebruik van de TimerService interface. Dit is een voorgeprogrammeerde ejb-component die specifiek ontwikkeld is om applicaties die tijdsafhankelijke functies bevatten eenvoudig te creëren.
Hiervoor
dient
men
enkel
javax.ejb.Timeout,
javax.ejb.Timer
en
javax.ejb.TimerService in de Javacode te importeren. Een voorbeeld van een eenvoudige Timer facade is: public
class
TimerFacade
implements
TimerFacadeRemote
{
@Resource
TimerService
timerService;
public
void
startTimer(long
time1,
long
time2)
{
System.out.println(”Creating
timer…”);
Timer
timer
=
timerService.createTimer(time1,
time2,
”Created
new
timer”);
System.out.println(”Timer
created…”);
}
@Timeout
public
void
timeout(Timer
timer)
{
System.out.println(”TimerFacade:
timeout
occurred”);
}
}
39
Een nieuwe timer kan elders in het programma eenvoudig gecreëerd worden door de startTimer methode via de remote facade op te roepen. In het voorbeeld zal de timer starten na time1 milliseconden en vervolgens elke time2 milliseconden aflopen. Wanneer de timer afloopt wordt steeds de timeout methode opgeroepen, waar gewenste acties kunnen uitgevoerd worden. In ons geval wordt er bij het opstarten van de applicatie een timer gecreëerd die elke dag afloopt. Wanneer de timeout methode opgeroepen wordt, gaat het programma na in de database welke patiënt een follow-up nodig heeft en vervolgens worden via de Patient_Doctor facade de behandelende artsen opgezocht. Ten slotte wordt er naar elke arts een e-mail verzonden met een verzoek om een follow-up formulier voor de patiënt in te vullen. Een nadeel van deze methode is dat ze niet de meest efficiënte is. Er moet immers dagelijks door het programma de volledige database doorlopen worden op zoek naar een patiënt die een follow-up nodig heeft. Een meer efficiënte methode die men bij een verdere uitbreiding van het programma kan onderzoeken, is om per patiënt een timer te creëren die elke 6 maanden afloopt. Hierdoor weet het programma onmiddellijk voor welke patiënt er follow-up gegevens dienen ingevuld te worden en wordt er dus verhinderd dat het programma dagelijks de volledige database moet doorzoeken. Het verzenden van de e-mails wordt afgehandeld door de session bean Mailsender. Aan deze component dient enkel de bestemmeling, het onderwerp en de inhoud van de e-mail te worden meegegeven. Als afzender van de berichten is momenteel het fictieve adres [email protected] ingesteld. De gebruikte SMTP server is smtp.UGent.be. Dit heeft tot gevolg dat de applicatie momenteel enkel in staat is om e-mails te verzenden, indien de machine waarop de applicatie draait verbonden is met het UGent netwerk. Indien het afzender adres en/of de SMTP server voor toekomstig gebruik dienen gewijzigd te worden, dient dit enkel aangepast te worden in de session bean Mailsender.
3.5.2
Exporteren en gegevensanalyse
Om aan de noodzaak te kunnen voldoen om de gegevens uit de database verder te analyseren, kan men in het admin menu de verschillende tabellen uit de database downloaden. Deze bestanden worden gedownload als een csv-bestand (Comma-separated values). Een csv-bestand is een eenvoudig tekstbestand dat gebruikt kan worden om een tabel weer te geven. Hierbij zijn de verschillende cellen van de tabel gescheiden door een puntkomma. Figuur 22 toont hoe Tabel 7 in een CSV-bestand wordt weergegeven. Merk op dat om een leeg veld weer te geven men twee maal “;” na elkaar plaatst (bij de geboortedatum van An Peeters).
40
Figuur 22 CSV bestand
Tabel 7 CSV invoer in Excel
Csv-bestanden kunnen geopend worden in Microsoft Excel. Hoe het bestand gelezen wordt hangt echter af van de regionale instellingen van het programma. Zo moet in België een puntkomma gebruikt worden, maar in Engelstalige landen moet een gewone komma gebruikt worden. In onze applicatie worden de verschillende csv-bestanden aangemaakt door de export session bean. Onderstaand voorbeeld toont aan hoe in Java vrij eenvoudig een csv-bestand kan gecreëerd worden. FileWriter
writer
=
new
FileWriter(”C:\\tabel.csv”);
String
result=”Voornaam;Naam;Geslacht”;
result+=”\nJan;Jansens;man”;
result+=”\nAn;Peeters;vrouw”;
writer.append(result);
writer.close();
Het document uit het voorbeeld kan men terugvinden op de C schijf als tabel.csv. Alle gegenereerde bestanden bevatten als eerste rij een tabelhoofd, zodat voor de gebruiker duidelijk is welke data in elke kolom staat. In Excel kan de gebruiker dan verdere analyses uitvoeren op data met bijvoorbeeld draaitabellen (Excel methode om gegevens op eenvoudige wijze samen te vatten en te groeperen) of andere Excel functies.
41
4
Uitgewerkte case
Dit hoofdstuk toont aan de hand van enkele stroomdiagrammen de sequentie van taken die uitgevoerd worden voor de belangrijkste functionaliteiten van de applicatie. Ten slotte geven we aan de hand van enkele screenshots een handleiding voor het gebruik van de applicatie.
4.1
Opeenvolging taken
In figuur 24 worden de verschillende acties weergegeven die ondernomen worden om het registratieproces van een nieuwe gebruiker te voltooien. Figuur 25 beschrijft de stappen die een gebruiker moet ondernemen om nieuwe gegevens van een patiënt in te brengen in de database. De mogelijkheden van het gebruikersbeheer worden in figuur 26 beschreven.
Figuur 23 legende stroomdiagram
42
Figuur 24 Stroomdiagram registratieproces
43
Figuur 25 Stroomdiagram Invullen patiëntgegevens
44
Figuur 26 Stroomdiagram gebruikersbeheer
45
4.2
Gebruikershandleiding
In wat volgt worden de belangrijkste functies uitvoerig beschreven zodat het voor de toekomstige gebruiker eenvoudig is om vertrouwd te raken met de applicatie.
4.2.1
Registreren als nieuwe gebruiker
Wanneer een gebruiker, een arts, surft naar de website, komt hij terecht op onderstaande startpagina. Hier zijn er twee opties: ofwel kan de gebruiker inloggen ofwel kan men zich registreren als nieuwe gebruiker.
Figuur 27 Startpagina website
46
Figuur 28 geeft het formulier weer dat nieuwe gebruikers dienen in te vullen om zich te registeren.
Figuur 28 Registratie pagina
Wanneer de nieuwe registratie verzonden wordt krijgt de gebruiker een e-mail met bevestiging van zijn registratie (Figuur 30). Elke admin krijgt eveneens een e-mail met de mededeling dat een nieuwe gebruiker zich geregistreerd heeft (Figuur 29).
Figuur 29 Mededeling nieuwe gebruiker aan admin
47
Figuur 30 E-mail bevestiging registratie
Vervolgens dient een admin in te loggen om de nieuwe gebruiker te accepteren (Figuur 31). De admin moet op het admin-icoon klikken om naar het admin menu te gaan.
Figuur 31 Welkomstpagina admin
48
Het admin menu geeft het aantal nieuwe registraties weer, die men kan bekijken door op ‘view’ te klikken (Figuur 32).
Figuur 32 Admin menu
49
De admin krijgt vervolgens een lijst met nieuwe gebruikers te zien. In de lijst staat ook het e-mailadres en het telefoonnummer van de (potentiële) gebruiker vermeld, zodat de admin contact met hem/haar kan opnemen indien nodig (Figuur 33). De admin heeft de keuze om de gebruiker te aanvaarden of te weigeren. In beide gevallen wordt een e-mail verzonden naar de gebruiker om hem/haar op de hoogte te brengen (Figuren 34 & 35).
Figuur 33 Pagina met lijst nieuwe registraties
Figuur 34 E-mail bevestiging toegang
50
Figuur 35 E-mail account verwijderd
4.2.2
PDF-formulieren downloaden en uploaden
Nu is de gebruiker in staat om in te loggen op de website. Op zijn persoonlijke welkomstpagina is het admin menu niet toegankelijk, indien de gebruiker geen admin rechten heeft (Figuur 36). Om een nieuwe patiënt te registreren kan de gebruiker het passende formulier downloaden door op het ‘Download PDF form’ icoon te klikken (Figuur 38). Indien de arts een ander formulier wenst in te vullen kan hij het ID-nummer van zijn patiënt opvragen door op ‘Search patiënts’ te klikken (Figuur 37). Figuren 39 en 40 geven een voorbeeld van respectievelijk het PDF-formulier voor de registratie van een nieuwe patiënt en de behandeling.
Figuur 36 Welkomstpagina gewone gebruiker
51
Figuur 37 Lijst patiënten van de gebruiker
Figuur 38 Download pagina
52
Figuur 39 PDF-formulier registratie patiënt
53
Figuur 40 PDF-Formulier Behandeling patiënt
Ten slotte kan de gebruiker zijn ingevulde PDF-formulieren in de database brengen door in het menu bovenaan op ‘Upload PDF form’ te klikken. De gebruiker kan zijn PDF-formulier zoeken zoals bij een e-mail applicatie (Figuur 41).
54
Figuur 41 Upload pagina
4.2.3
Het admin menu
Naast het hierboven beschreven accepteren of weigeren van een nieuwe gebruiker, heeft een admin nog twee extra opties (zie Figuur 32). Als eerste kan hij naar de ‘user management’ pagina gaan (Figuur 42). Op deze pagina heeft de admin de keuze om ofwel een gebruiker op te zoeken op familienaam of om alle gebruikers van de applicatie weer te geven. Van de opgezochte personen wordt het e-mailadres en telefoonnummer weer gegeven, zodat de admin indien nodig met hen contact kan opnemen. Daarnaast heeft de admin de keuze om de gebruiker admin rechten te geven of om de gebruiker te verwijderen. In beide gevallen wordt de gebruiker op de hoogte gebracht via e-mail (Figuren 35 & 43).
55
Figuur 42 User management
Figuur 43 E-mail toekennen admin rechten
56
De admin kan er ook voor kiezen om de data die in de tabellen van de database zit, te exporteren naar een csv-bestand(Figuur 44). Deze bestanden kunnen geopend worden in Excel, zodat er eventueel een verdere analyse kan op uitgevoerd worden.
Figuur 44 Bestanden exporteren naar csv
57
5
Conclusie en mogelijke uitbreidingen
We hebben een databankgestuurde applicatie ontwikkeld in Java Enterprise Edition. Deze applicatie biedt de artsen de mogelijkheid om patiëntgegevens op een elektronische manier op te slaan in een database. De invoer gebeurt door middel van offline invulbare PDF-formulieren die via de website kunnen worden gedownload. Nadien worden deze formulieren via dezelfde website geupload naar de database. De gegevens die in de database zitten kunnen geëxporteerd worden naar csv formaat, die het mogelijk maakt om verdere data-analyse uit te voeren in Excel. Dankzij deze applicatie lossen we een aantal van de huidige, minder efficiënte, werkwijzen op. Het is niet langer noodzakelijk om de resultaten van de onderzoeken op een papieren versie in een map te bewaren. Daarnaast vergemakkelijkt dit de mogelijkheid om data- en trendanalyse uit te voeren omdat het handmatig overbrengen van de gegevens naar Excel overbodig is geworden. Ten slotte kan de toepasbaarheid van de applicatie uitgebreid worden naar andere ziekenhuizen, wat het mogelijk maakt om gegevens op grote schaal te verzamelen en analyseren. Dit systeem leent zich er toe om in de toekomst uitgebreid te worden met extra functies. Een verdere uitwerking van iText kan het mogelijk maken om nieuwe items automatisch toe te voegen in de PDF-formulieren wanneer deze bij de optie ‘other’ worden ingevuld. Verschillende databaseviews kunnen ontwikkeld worden om een gepersonaliseerde selectie van de gegevens op te vragen. Daarmee samenhangend kunnen er Excel macro’s ontwikkeld worden die de gegevens automatisch analyseren. Daarnaast is het mogelijk om een patiëntdossier beschikbaar te stellen aan de behandelende arts zodat het tevens mogelijk is om de reeds ingevoerde gegevens te wijzigen. Ten slotte kunnen er gebruikersprofielen ontwikkeld worden die het mogelijk maken om lees- of schrijfrechten toe te kennen aan een gebruiker om, mits toelating, patiëntgegevens van een andere gebruiker te raadplegen.
58
Bijlagen Bijlage 1: Installatieprocedure
1. Open NetBeans IDE 6.8. Indien u niet over dit platform beschikt kan u het gratis downloaden via http://netbeans.org/downloads/index.html (De volledige versie of Java versie selecteren). 2. Ga naar het menu File en selecteer Open Project... . Als project selecteert u CMVEnterpriseApplication op bijgevoegde CD-ROM. Het project wordt zichtbaar in het project venster. 3. Rechter-klik op CMVEnterpriseApplication in het project venster en selecteer Set as Main Project en Open Required Projects. In het project venster zijn nu ook de bijhorende
projecten
zichtbaar
(CMVEnterpriseApplication-app-client,
CMVEnterpriseApplication-ejb en CMVEnterpriseApplicatio-war). 4. Rechter-klik op CMVEnterpriseApplication-ejb
en selecteer Resolve Reference
Problem. Klik op Resolve en selecteer iText-5.0.1.jar op bijgevoegde CD-ROM. Indien er geen Reference Problems zijn, rechter-klik op de folder Libraries en selecteer add JAR/Folder. Selecteer iText-5.0.1.jar op bijgevoegde CD-ROM. 5. Om de database aan te maken selecteert u het Services venster. Open de Databases folder. Rechter-klik op Java DB en selecteer Create Database. Geef uw database een naam en stel een gebruiker en wachtwoord in. 6. Ga
terug
naar
het
project
venster
en
selecteer
opnieuw
de
projectmap
CMVEnterpriseApplication-ejb. Open persistence.xml in de map Configuration Files. Selecteer New Database Source bij Data Source. Geef de databron een naam en selecteer als Database Connection de database die u in de vorige stap heeft aangemaakt. Als Table Generation Strategy selecteert u Create. 7. Om de timer functie te starten doet u rechter-klik op de CMVEnterpriseApplication folder en selecteer Properties. Selecteer CMVEnterpriseApplication-app-client als client Module in de categorie Run. Wanneer u deze client Module selecteert moet er manueel naar de website gesurft worden. Om bij het uitvoeren van het programma
onmiddellijk de website op te starten selecteert u CMVEnterpriseApplicatio-war als Client Module. 8. Maak een map met de naam “cmv files” aan op uw C-schijf. Alle bestanden die een admin exporteert komen terecht in deze map. Later kan dit uitgebreid worden zodat wanneer men een bestand wil exporteren het als download beschikbaar wordt en men zelf het pad kan kiezen waar het bestand dient opgeslaan te worden of het bestand kan onmiddellijk doorgestuurd worden via e-mail naar de ingelogde arts. 9. Om
het
programma
uit
te
voeren
doet
u
rechter-klik
op
de
CMVEnterpriseApplication folder en selecteer Clean and Build en vervolgens Run. 10. In de browser wordt de website http://localhost:8080/CMVEnterpriseApplicationwar/index.jsp geopend, die het mogelijk maakt de patiënten te registreren en op te volgen. (Indien de applicatie reeds gedeployed is (Deploy of Run in stap 9), dan kan je direct naar deze site surfen) 11. De eerste admin van het programma moet rechtstreeks ingebracht worden in de database. Ga hiervoor opnieuw naar het Services venster en open de databases folder. Rechter-klik op de database die u in stap 5 gecreëerd heeft en selecteer Connect. Open nu de folder van de database. Open de folder Tables in de folder die de naam heeft die u als gebruiker heeft gekozen in stap 5. Rechterklik op de tabel met de naam Doctor en klik View Data. Er verschijnt een tabel met daarin alle gebruikers van het programma. Rechter-klik op de lijst en selecteer Insert Record(s). U kan nu de gegevens voor de admin invullen. Belangrijk is dat u bij ISACTIVATED en ISADMIN “1” invult. Bij EMAIL vult u een geldig e-mailadres in en vul bij PASSWORD
een
paswoord
in. Als
ID_DOCTOR
vult u
bijvoorbeeld
“999999999” in en de overige velden zijn vrij in te vullen. Opgelet: om deze stap uit te voeren moet u stap 9 reeds 1 maal uitgevoerd hebben!
60
Bibliografie Abbott Diagnostics. (2006 December). Cytomegalovirus Reviewed. Retrieved 2010 01March
from
http://www.abbottdiagnostics.co.uk/About_Us/UK/Xchange_19/Cytomegalovirus_Reviewed .cfm Cade, M., Humphrey, & Sheil. (2010). Sun Certified Enterprise Architect for Java EE, study guide. Sun. Goossens, Temmerman, & Vanhaesebrouck. (2003). Perinatale cytomegalovirusinfectie. Tijdschrift voor Geneeskunde , 673-679. Lowagie, B. (2006). iText in Action. Creating and Manipulating PDF. New York: Manning Publications Co. Sriganesh, Brose, & Silverman. (2006). Mastering Enterprise JavaBeans. Indianapolis: Wiley Publishing Inc. Sun. (2008 October). The Java EE tutorial. Retrieved 2010 1-March from java.sun.com: http://java.sun.com/javaee/5/docs/tutorial/doc/
61
