Scripts › Bekijken

Toevoegen | Categorie:


OOP Gastenboek

Bestand.php

Code tonen/verbergenCodeDeze code in een nieuw vensterDeze code in een tekstveldDeze code in een zip file downloaden
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
<?php
/**
 * Bestand.php. Dit bestand bevat alle klassen uit de Bestand package.
 *
 * De Bestand package bevat alle klassen om te communiceren met diverse soorten bestanden.
 * Er is een interface Bestand die alle generieke methoden bevat en diverse implementaties
 * van deze interface om te communiceren met een specifiek bestand.
 *
 * @package Bestand
 *
 * @author Mark Kazemier <mark.kazemier@gmail.com>
 * @version $Revision v1.00$
 * @copyright Copyright (c) 2009, Mark Kazemier
 */

/**
 * De Bestand interface. Een bestand kan elk soort bestand dat op de server staat zijn.
 * 
 * Deze interface bevat alle generieke methoden die op elk bestand type uitgevoerd kunenn
 * worden. Om een specifiek bestand type te gebruiken kan deze interface geimplementeerd
 * worden.
 */
interface Bestand
{
    /**
     * Methode om een aantal bytes uit het bestand te lezen
     *
     * @param integer $bytes Het aantal bytes dat uit het bestand gelezen moet worden
     * @return string | boolean De gelezen tekst uit het bestand. Er wordt false gereturned als het eind van het bestand bereikt is
     */
    public function lees($bytes);
    
    /**
     * Methode om een regel uit het bestand te lezen
     *
     * @return string | boolean De gelezen regel uit het bestand. Er wordt false gereturned als het eind van het bestand bereikt is
     */
    public function regel_lezen();
    
    /**
     * Methode om een stuk tekst naar het bestand te schrijven
     *
     * @param string $tekst De tekst die naar het bestand geschreven moet worden
     */
    public function schrijf($tekst);
    
    /**
     * Methode om een regel tekst naar het bestand te schrijven
     *
     * @param string $tekst De regel tekst die naar het bestand geschreven moet worden
     */
    public function regel_schrijven($tekst);
}

/**
 * De TxtBestand klasse. Deze klasse is een implementatie van Bestand en geeft de mogelijkheid
 * om te lezen en te schrijven naar een .txt tekst bestand.
 */
class TxtBestand implements Bestand
{
    /**
     * @var string Bestand openen voor lezen
     */
    const LEES                   = 'r';
    
    /**
     * @var string Bestand openen voor lezen en schrijven
     */
    const LEES_EN_SCHRIJF        = 'r+';
    
    /**
     * @var string Bestand openen voor schrijven
     */
    const SCHRIJF                = 'w';
    
    /**
     * @var string Bestand legen en openen voor lezen en schrijven
     */
    const LEES_EN_SCHRIJF_LEEG   = 'w+';
    
    /**
     * @var Bestand openen voor schrijven aan het eind van het bestand
     */
    const SCHRIJF_EIND           = 'a';
    
    /**
     * @var Bestand openen voor lezen en schrijven aan het eind van het bestand
     */
    const LEES_EN_SCHRIJF_EIND   = 'a+';
    
    /**
     * @var Bestand creeëren en openen voor schrijven
     */
    const MAAK_SCHRIJF           = 'x';
    
    /**
     * @var Bestand creeëren en openen voor schrijven aan het eind van het bestand
     */
    const MAAK_LEES_EIND_SCHRIJF = 'x+';
    
    private $bestand;
    
    /**
     * De constructor. Maakt een nieuw bestand object. Opent het opgegeven bestand en
     * opend het volgens de in $open opgegeven methode
     *
     * @param string De naam van het te openen bestand
     * @param string De manier waarop het bestand geopend moet worden
     */
    public function __construct($bestand, $open)
    {
        if(!($this->bestand = fopen($bestand, $open)))
            throw new BestandException('Het bestand kon niet geopend worden.');
    }
    
    /**
     * De destructor. Vernietigd het Bestand object en sluit het bestand.
     */
    public function __destruct()
    {
        fclose($this->bestand);
    }
    
    /**
     * @return string
     */
    public function lees($bytes)
    {
        $tekst = fread($this->bestand, $bytes);
        return $tekst;    
    }
    
    /**
     * @return string
     */
    public function regel_lezen()
    {   
        $tekst = fgets($this->bestand);
        return $tekst;
    }
    
    public function schrijf($tekst)
    {
        
        if(!fwrite($this->bestand, $tekst))
            throw new BestandException('Kon de tekst niet naar het bestand schrijven');
    }
    
    public function regel_schrijven($tekst)
    {
        if(!fwrite($this->bestand, "\n" . $tekst))
            throw new BestandException('Kon de regel niet naar het bestand schrijven');
    }
}

/**
 * De BestandException klasse. De BestandException klasse is een extensie op de Exception klasse en wordt
 * gebruikt om fouten die optreden tijdens het lezen en of schrijven van een Bestand naar voren te brengen.
 *
 * De BestandException is gemaakt om het mogelijk te maken om in een try catch block het verschil tussen een
 * normale Exception en een BestandException te kunnen maken.
 */
class BestandException extends Exception
{
}



Database.php

Code tonen/verbergenCodeDeze code in een nieuw vensterDeze code in een tekstveldDeze code in een zip file downloaden
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
<?php
/**
 * Database.php. Dit bestand bevat alle klassen die bij de Database package horen.
 *
 * De Database package bevat alle klassen die rechtstreeks met de Database communiceren
 * en gebruik maken van Database specifieke functies vanuit PHP.
 *
 * @package Database
 *
 * @author Mark Kazemier <mark.kazemier@gmail.com>
 * @version $Revision v1.00$
 * @copyright Copyright (c) 2009, Mark Kazemier
 */

/**
 * De Database interface. Deze interface wordt gebruikt om aan te geven hoe een Database eruit moet zien.
 *
 * De Database kan verbinding maken en er kunnen queries op uitgevoerd worden. Het resultaat van een query
 * wordt verwerkt door het DatabaseResult. Alle methoden uit deze interface maken het mogelijk om op een 
 * generieke manier acties uit te voeren op de database.
 */
interface Database
{
    /**
     * Methode die verbinding met de database maakt. Gebruik makend van de meegegeven login gegevens
     *
     * @param string $host De host waar de database gehost staat
     * @param string $gebruikersnaam De gebruikersnaam om in te loggen op de database
     * @param string $wachtwoord Het wachtwoord om in te loggen op de database
     * @param string $naam De naam van de database waarmee verbinding gemaakt moet worden
     */
    public function maak_verbinding($host, $gebruikersnaam, $wachtwoord, $naam);
    
    /**
     * Methode om de opgegeven query uit te voeren op de Database
     *
     * @param string $query De query die uitgevoerd moet worden op de Database
     * @return DatabasResult Het resultaat van de query
     */
    public function query($query);
}

/**
 * De DatabaseResult interface. Deze interface wordt gebruikt om een resultaat van een query op de Database
 * te beschrijven.
 *
 * Op het moment dat een query uitgevoerd wordt, komt er een DatabaseResult terug. De DatabaseResult bevat
 * het resultaat van de query en geeft de mogelijkheid om dit resultaat op diverse manieren op te vragen.
 */
interface DatabaseResult
{
    /**
     * Methode om een enkele regel uit het resultaat op te vragen in de vorm van een array met key => value
     * paren. Elke key correspondeert met een geselecteerd veld uit de database
     *
     * @return array Een enkele regel uit het resultaat in de vorm van een array met key => value paren
     */
    public function fetch_assoc();
    
    /**
     * Methode om het hele resultaat in één array op te vragen. De array is een lijst van alle geselecteerde
     * regels opgevraagd met $this->fetch_assoc()
     *
     * @return array Een lijst met alle geselecteerde regels
     */
    public function fetch_alles();
    
    /**
     * Methode om het aantal regels in het resultaat op te vragen
     *
     * @return integer Het aantal regels in het resultaat
     */
    public function aantal_regels();
}

/**
 * De MySQL klasse. De MySQL klasse is een implementatie van de Database interface specifiek gericht
 * om te communiceren met een MySQL database.
 */
class MySQL implements Database
{
    private $connectie;
    
    public function maak_verbinding($host, $gebruikersnaam, $wachtwoord, $naam)
    {
        if(!($this->connectie = mysql_connect($host, $gebruikersnaam, $wachtwoord)))
            throw new DatabaseException('Kon geen verbinding maken');
            
        if(!mysql_select_db($naam, $this->connectie))
            throw new DatabaseException(mysql_error());    
    }
    
    /**
     * @return MysqlResult Het resultaat van de query
     */
    public function query($query)
    {
        $resultaat = mysql_query($query, $this->connectie);
        
        if(!$resultaat)
            throw new DatabaseException(mysql_error());
        
        return new MySQLResult($resultaat);        
    }
}


/**
 * De MySQLResult klasse. De MySQLResult klasse in een implementatie van de DatabaseResult interface
 * die specifiek gericht is op het communiceren met een MySQL Database.
 */
class MySQLResult implements DatabaseResult
{
    private $resultaat;
    
    /**
     * De constructor. De constructor maakt een nieuw MySQLResult gebruikt makend van de result
     * handler verkregen bij het uitvoeren van een query.
     *
     * @param handler $resultaat De result handler verkregen bij het uitvoeren van een query
     */
    public function __construct($resultaat)
    {
        $this->resultaat = $resultaat;
    }
    
    /**
     * @return array
     */
    public function fetch_assoc()
    {
        return mysql_fetch_assoc($this->resultaat);
    }
    
    /**
     * @return array
     */
    public function fetch_alles()
    {
        $resultaat = array();
        while($regel = $this->fetch_assoc())
        {
            $resultaat[] = $regel;
        }
        
        return $resultaat;
    }
    
    /**
     * @return integer
     */
    public function aantal_regels()
    {
        return mysql_num_rows($this->resultaat);
    }
}

/**
 * De DatabaseExcpetion klasse. De DatabaseException klasse is een extensie op van de
 * Exception klasse en wordt gebruikt om fouten die optreden tijdens het gebruik van de
 * database naar voren te brengen.
 *
 * De DatabaseException is gemaakt om het mogelijk te maken om in een try catch block 
 * het verschil tussen een normale Exception en een DatabaseException te kunnen maken.
 */
class DatabaseException extends Exception
{
}



Gastenboek.Adapter.php

Code tonen/verbergenCodeDeze code in een nieuw vensterDeze code in een tekstveldDeze code in een zip file downloaden
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
<?php
/**
 * Gastenboek.Adapter.php. Deze file bevat de package Adapter als sub package van de Gastenboek pachage
 *
 * Deze package bevat alle Adapter klassen die gebouwd zijn om te communiceren met data
 * over het Gastenboek. Voor het Gastenboek kunnen verschillende data bronnen gebruikt
 * worden. Zo is een mogelijkheid om met de Database of met een Bestand te communiceren.
 *
 * @package Gastenboek
 * @subpackage Adapter
 *
 * @author Mark Kazemier <mark.kazemier@gmail.com>
 * @version $Revision v1.00$
 * @copyright Copyright (c) 2009, Mark Kazemier
 */

/**
 * De GastenboekAdapter interface. Deze interface wordt gebruikt om aan te geven hoe
 * een Adapter voor het Gastenboek eruit moet zien.
 *
 * Alle methoden uit deze klasse geven een mogelijkheid om op een generieke manier
 * gegevens over het Gastenboek op te vragen. Implementaties van deze interface
 * kunnen zelf bepalen waar deze gegevens uit gehaald worden.
 */
interface GastenboekAdapter
{
    /**
     * Methode die het mogelijk maakt om een reactie toe te voegen aan het gastenboek.
     *
     * @param string $reactie De reactie van de gebruiker
     * @param string $gebruiker_naam De naam van de gebruiker
     * @param string $gebruiker_email Het email adres van de gebruiker
     * @param string $gebruiker_website De website van de gebruiker
     * @param string $datum De datum waarop de reactie is geplaatst
     * @param string $tijd De tijd waarop de reactie is geplaatst
     */
    public function reactie_toevoegen($reactie, $gebruiker_naam, $gebruiker_email,
                                      $gebruiker_website, $datum, $tijd);
    
    /**
     * Methode die alle reacties uit het gastenboek op vraagt en in de vorm van een
     * lijst met reacties terug geeft.
     *
     * @return array Een lijst met alle reacties op het Gastenboek
     */
    public function alle_reacties();
}

/**
 * De DatabaseGastenboekAdapter abstract klasse. Deze klasse is een implementatie
 * van de GastenboekAdapter interface en zorgt ervoor dat de gegevens van het
 * Gastenboek opgehaald kunnen worden uit de Database
 *
 * De klasse heeft alle database generieke methoden geimplementeerd. Als er
 * database specifieke queries uitgevoerd moeten worden, kan een sub
 * klasse van deze klasse deze methoden overschrijven en implementeren. Deze
 * klasse zorgt ervoor dat de Database en het Databas type volledige 
 * geabstraheerd kan worden van het Gastenboek zelf.
 */
abstract class DatabaseGastenboekAdapter implements GastenboekAdapter
{
    /**
     * @var Database Bevat de Database die gebruikt wordt om queries op uit te voeren
     */
    protected $database;
    
    /**
     * De constructor. De constructor maakt een nieuwe DatabaseGastenboekAdapter
     * aan. Deze constructor verwacht een Database die vervolgens gebruikt
     * kan worden om queries op uit te voeren.
     *
     * @param Database $database De database die gebruikt moet worden
     */
    public function __construct(Database $database)
    {
        $this->database = $database;
    }
    
    public function reactie_toevoegen($reactie, $gebruiker_naam, $gebruiker_email,
                                      $gebruiker_website, $datum, $tijd)
    {
        $query = "INSERT INTO reactie
                    (reactie, gebruiker_naam, gebruiker_email, gebruiker_website, datum, tijd)
                  VALUES ('" . $reactie . "',
                          '" . $gebruiker_naam . "',
                          '" . $gebruiker_email . "',
                          '" . $gebruiker_website . "',
                          '" . $datum . "',
                          '" . $tijd . "');";
        $this->database->query($query);
    }
    
    /**
     * @return array
     */
    public function alle_reacties()
    {
        $query = "SELECT reactie, gebruiker_naam, gebruiker_website, datum, tijd
                  FROM reactie ORDER BY datum DESC, tijd DESC;";
        return $this->database->query($query)->fetch_alles();
    }
}

/**
 * De MysqlGastenboekAdapter klasse. Deze klasse geeft de mogelijkheid om gebruik te maken
 * van de MySQL database.
 * 
 * Deze klasse breid de DatabaseGastenboekAdapter klasse uit en implementeerd alle
 * MySQL specifieke methoden.
 */
class MysqlGastenboekAdapter extends DatabaseGastenboekAdapter
{
    /**
     * De constructor. De constructor maakt een nieuwe MysqlGastenboekAdapter met
     * een specifieke verbinding naar de MySQL database.
     *
     * @param MySQL $mysql De database waarop de queries uitgevoerd gaan worden
     */
    public function __construct(Mysql $mysql)
    {
        parent::__construct($mysql);
    }
}

/**
 * De TxtGastenboekAdapter klasse. De TxtGastenboekAdapter zorgt ervoor dat het Gastenboek
 * kan communiceren met een tekst bestand.
 *
 * De TxtGastenboekAdapter is een implementatie van de GastenboekAdapter interface en
 * implementeerd alle methoden met behulp van een tekst bestand.
 */
class TxtGastenboekAdapter implements GastenboekAdapter
{
    private $bestand;
   
    /**
     * De constructor. De constructor maakt een nieuwe TxtGastenboekAdapater. De
     * constructor krijgt een Bestand dat gebruikt wordt om de gegevens over
     * het Gastenboek in weg te schrijven of uit te lezen
     *
     * @param TxtBestand $bestand Het bestand waarin de gegevens over het Gastenboek staan
     */ 
    public function __construct(TxtBestand $bestand)
    {
        $this->bestand = $bestand;
    }
    
    public function reactie_toevoegen($reactie, $gebruiker_naam, $gebruiker_email,
                                      $gebruiker_website, $datum, $tijd)
    {
        $data = array('reactie'           => $reactie,
                      'gebruiker_naam'    => $gebruiker_naam,
                      'gebruiker_email'   => $gebruiker_email,
                      'gebruiker_website' => $gebruiker_website,
                      'datum'             => $datum,
                      'tijd'              => $tijd);
        $this->bestand->regel_schrijven(serialize($data));
    }
    
    /**
     * @return array
     */
    public function alle_reacties()
    {
        $data = array();
        
        while($regel = $this->bestand->regel_lezen())
        {
            $data[] = unserialize($regel);
        }
        
        return $data;
    }
}



Gastenboek.php

Code tonen/verbergenCodeDeze code in een nieuw vensterDeze code in een tekstveldDeze code in een zip file downloaden
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
<?php
/**
 * Gastenboek.php. Deze file bevat alle klassen die bij de Gastenboek package horen.
 *
 * De Gastenboek package bevat alle klassen die specifiek zijn voor het Gastenboek. Zo
 * Bevat deze package de klassen voor een reactie, de gebruiker en het Gastenboek zelf.
 * Om het Gastenboek te laten communiceren met een database of bestanden bevat de 
 * Gastenboek package ook een sub package Adapter waarin alle adapters zitten om
 * met een data bron te communiceren.
 *
 * @package Gastenboek
 *
 * @author Mark Kazemier <mark.kazemier@gmail.com>
 * @version $Revision v1.00$
 * @copyright Copyright (c) 2009, Mark Kazemier
 */

/**
 * De Gastenboek klasse, deze klasse is een beschrijving van het gastenboek
 *
 * Deze klasse zorgt ervoor dat het gastenboek weergegeven kan worden. Hiervoor maakt 
 * deze klasse gebruik van de klasse Gebruiker en de klasse Reactie.
 */
class Gastenboek
{
    private $adapter;
    
    /**
     * De constructor. De constructor maakt het gastenboek aan en verwacht een
     * GastenboekAdapter. Deze adapter wordt later in de klasse gebruikt om
     * gegevens over het gastenboek op te vragen.
     *
     * @param GastenboekAdapter $adapter De GastenboekAdapter die gebruikt gaat worden voor de gegevens over het gastenboek
     */
    public function __construct(GastenboekAdapter $adapter)
    {
        $this->adapter = $adapter;
    }
    
    /**
     * De weergeven() methode. Deze methode zorgt ervoor dat het gastenboek in
     * zijn geheel weergegeven wordt. De methode geeft de weergave in de vorm
     * van een string terug.
     *
     *
     * @param GastenboekWeergave De GastenboekWeergave die gebruikt wordt voor het weergeven van het Gastenboek
     * @return string De weergave van het gastenboek
     */
    public function weergeven(GastenboekWeergave $weergave)
    {
    
        $reacties = $this->adapter->alle_reacties();
        
        $resultaat = $weergave->boven();
        foreach($reacties as $reactie)
        {
            $gebruiker = new Gebruiker($reactie['gebruiker_naam'], null, $reactie['gebruiker_website']);
            $reactie = new Reactie($this->adapter, $reactie['reactie'], $gebruiker, $reactie['datum'], $reactie['tijd']);
            
            $resultaat .= $weergave->reactie($reactie);
        }
        
        return $resultaat . $weergave->onder();
    }
}

/**
 * De Gebruiker klasse, deze klasse is een beschrijving van de gebruiker van het Gastenboek
 *
 * Deze klasse zorgt ervoor dat een gebruiker een reactie kan plaatsen en dat de gebruiker
 * weergegeven kan worden in het Gastenboek.
 */
class Gebruiker
{
    private $naam;
    private $email;
    private $website;
    
    /**
     * De constructor. De constructor maakt een nieuwe Gebruiker aan met alle gegevens
     * van de gebruiker zoals Naam, Email en Website.
     *
     * @param string $naam De naam van de Gebruiker
     * @param string $email Het email adres van de Gebruiker
     * @param string $website De website van de gebruiker. Een website is niet verplicht
     */
    public function __construct($naam, $email, $website)
    {
        $this->naam = $naam;
        $this->email = $email;
        $this->website = $website;
    }
    
    /**
     * Methode die het mogelijk maakt voor de Gebruiker om een reactie te plaatsen. Een
     * GastenboekAdapter wordt meegegeven om de reactie aan de data source toe te voegen.
     *
     * @param GastenboekAdapter $adapter De GastenboekAdapter die helpt bij het opslaan van de reactie
     * @param string $reactie De reactie van de gebruiker
     */
    public function reactie_plaatsen(GastenboekAdapter $adapter, $reactie)
    {
        $reactie = new Reactie($adapter, $reactie, $this, date('Y-m-d'), date('H:i'));
        $reactie->opslaan();
    }
    
    /**
     * Methode om de gebruiker weer te geven. Deze methode zorgt ervoor dat de niet kritieke
     * gegevens van de gebruiker getoond worden in het Gastenboek.
     *
     * @param GebruikerWeergave De weergave die bij het weergeven van de Gebruiker gebruikt zal worden
     * @return string De weergave van de gebruiker.
     */
    public function weergeven(GebruikerWeergave $weergave)
    {
        return $weergave->weergeven($this->naam, $this->email, $this->website);
    }
    
    /**
     * Methode om de gegevens van de gebruiker op te vragen. Deze methode kan gebruikt worden
     * in gevallen dat de gegevens gebruikt worden in een situatie waar de Gebruiker klasse
     * niet zelf verantwoordelijk is.
     *
     * @return array Een lijst de gegevens van de Gebruiker
     */
    public function geef_gegevens()
    {
        return array('naam'    => $this->naam,
                     'email'   => $this->email,
                     'website' => $this->website);
    }
}

/**
 * De Reactie klasse. Deze klasse is een beschrijving van een Reactie in het Gastenboek.
 *
 * Deze klasse zorgt ervoor dat een reactie opgeslagen kan worden en dat de reactie
 * weegegeven kan worden in het Gastenboek.
 */
class Reactie
{
    private $adapter;
    
    private $gebruiker;
    private $reactie;
    private $datum;
    private $tijd;
   
    /**
     * De constructor. De constructor maakt een nieuwe reactie met alle gegevens over de 
     * reactie zoals de Gebruiker, de datum, de tijd en de reactie zelf. Ook wordt er een
     * GastenboekAdapter meegegeven die later gebruikt kan worden om de reactie mee op te
     * slaan.
     *
     * @param GastenboekAdapter $adapter De GastenboekAdapter die gebruik gaat worden om de reactie op te slaan
     * @param string $reactie De reactie van de gebruiker
     * @param Gebruiker $gebruiker De auteur van de reactie
     * @param string $datum De datum waarop de reactie geplaatst is
     * @param string $tijd De tijd waarop de reactie geplaatst is
     */
    public function __construct(GastenboekAdapter $adapter, $reactie, Gebruiker $gebruiker, $datum, $tijd)
    {
        $this->adapter = $adapter;
        
        $this->reactie = $reactie;
        $this->gebruiker = $gebruiker;
        $this->datum = $datum;
        $this->tijd = $tijd;
    }
    
    /**
     * Methode om de reactie weer te geven in het Gastenboek.
     *
     * @param ReactieWeergave De weergave die gebruikt wordt voor het weergeven van de Reactie
     * @return string De weergave van een Reactie
     */
    public function weergeven(ReactieWeergave $reactie)
    {
        return $reactie->weergeven($this->gebruiker, $this->reactie, $this->datum, $this->tijd);
    }
    
    /**
     * Methode om de reactie op slaan met behulp van de GastenboekAdapter
     */
    public function opslaan()
    {
        $gebruiker = $this->gebruiker->geef_gegevens();
        $this->adapter->reactie_toevoegen($this->reactie,
                                          $gebruiker['naam'],
                                          $gebruiker['email'],
                                          $gebruiker['website'],
                                          $this->datum,
                                          $this->tijd);
    }
}



Gastenboek.Weergave.php

Code tonen/verbergenCodeDeze code in een nieuw vensterDeze code in een tekstveldDeze code in een zip file downloaden
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
<?php
/**
 * Gastenboek.Weergave.php. Deze file bevat alle klassen uit de Gastenboek.Weergave package.
 *
 * De Gastenboek.Weergave package bevat alle klassen die iets te maken hebben met het
 * weergeven van het Gastenboek. De package bevat verschillende klassen die het mogelijk
 * maken om het Gastenboek op verschillende manieren weer te geven. Zo kan het Gastenboek
 * weergegeven worden als HTML en in de vorm van een RSS feed.
 *
 * @package Gastenboek
 * @subpackage Weergave
 *
 * @author Mark Kazemier <mark.kazemier@gmail.com>
 * @version $Revision v1.00$
 * @author Mark Kazemier
 */

/**
 * De GastenboekWeergave interface is verantwoordelijk voor het weergeven van het Gastenboek.
 *
 * De GastenboekWeergave interface kan geimplementeerd worden door verschillende klassen die
 * een specifieke weergave van het Gastenboek mogelijk maken. De weergave() methode uit de
 * Gastenboek klasse zorgt er vervolgens voor dat het Gastenboek helemaal weergegeven wordt
 * als het zou moeten.
 */
interface GastenboekWeergave
{
    /**
     * De methode headers(). Deze methode zorgt ervoor dat alle headers die met de weergave
     * maken hebben, verzonden worden.
     */
    public function headers();
    
    /**
     * Deze methode zorgt ervoor dat het bovenste gedeelte van de weergave uitgevoerd en
     * teruggegeven wordt.
     *
     * @return string De output van het bovenste gedeelte van de weergave.
     */
    public function boven();
    
    /**
     * Deze methode zorgt ervoor dat het onderste gedeelte van de weergave uitgevoerd
     * end teruggegeven wordt.
     *
     * @return string De output van het onderste gedeelte van de weergave.
     */
    public function onder();
    
    /**
     * Methode die ervoor zorgt dat een Reactie binnen het Gastenboek weergegeven wordt
     *
     * @param Reactie De Reactie die weergegeven moet worden
     * @return string De weergave van de Reactie
     */
    public function reactie(Reactie $reactie);
}

/**
 * De HTMLGastenboekWeergave klasse zorgt ervoor dat het Gastenboek in HTML weergegeven
 * kan worden.
 *
 * De HTMLGastenboekWeergave implementeert de GastenboekWeergave interface om de mogelijkheid
 * te bieden deze klasse te gebruiken in de weergeven() methode van de Gastenboek klasse.
 */
class HTMLGastenboekWeergave implements GastenboekWeergave
{
    public function headers()
    {
        header('Content-Type: text/html');
    }
    
    /**
     * @return string
     */
    public function boven()
    {
        return '<div id="gastenboek">';
    }
    
    /**
     * @return string
     */
    public function onder()
    {
        return '</div>';
    }
    
    /**
     * @return string
     */
    public function reactie(Reactie $reactie)
    {
        return $reactie->weergeven(new HTMLReactieWeergave());
    }
}

/**
 * De RSSGastenboekWeergave klasse zorgt ervoor dat het Gastenboek in RSS weergegeven
 * kan worden.
 * 
 * De RSSGastenboekWeergave implementeert de GastenboekWeergave interface om de mogelijkheid
 * te bieden deze klasse te gebruiken in de weergeven() methode van de Gastenboek klasse.
 */
class RSSGastenboekWeergave implements GastenboekWeergave
{
    public function headers()
    {
        header('application/rss+xml');
    }
    
    /**
     * @return string
     */
    public function boven()
    {
        return '<?xml version="1.0" encoding="ISO-8859-1" ?>
                <rss version="2.0">
                <channel>
                <title>OOP Gastenboek</title>
                <link>http://localhost/OOPGastenboek/</link>';
    }
    
    /**
     * @return string
     */
    public function onder()
    {
        return '</channel>
                </rss>';
    }
    
    /**
     * @return string
     */
    public function reactie(Reactie $reactie)
    {
        return $reactie->weergeven(new RSSReactieWeergave());
    }
}

/**
 * De ReactieWeergave interface zorgt voor de weergave van een Reactie uit het Gastenboek
 *
 * De ReactieWeergave interface is gemaakt om de mogelijkheid te bieden verschillende soorten
 * weergaven te maken voor een Reactie. De ReactieWeergave interface wordt doorgegeven aan
 * de weergeven() methode van Reactie en krijgt Reactie data doorgegeven om weer te geven
 */
interface ReactieWeergave
{
    /**
     * Methode die ervoor zorgt dat de meegegeven data over het Reactie weergegeven wordt.
     *
     * @param Gebruiker $auteur De auteur van het Reactie
     * @param string $reactie De reactie zelf
     * @param string $datum De datum waarop het Reactie geplaatst is
     * @param string $tijd De tijd waarop het Reactie geplaatst is
     * @return string De weergave van het Reactie
     */
    public function weergeven(Gebruiker $auteur, $reactie, $datum, $tijd);
}

/**
 * De HTMLReactieWeergave klasse zorgt ervoor dat het Reactie in HTML weergegeven wordt
 *
 * De HTMLReactieWeergave klasse is een implementatie van de ReactieWeergave klasse.
 * Dit maakt het mogelijk om deze klasse in de weergeven() methode van Reactie te
 * gebruiken.
 */
class HTMLReactieWeergave implements ReactieWeergave
{
    /**
     * @return string
     */
    public function weergeven(Gebruiker $auteur, $reactie, $datum, $tijd)
    {
        return '<div class="reactie">
                <span class="geplaatst">Geplaatst door: ' . $auteur->weergeven(new HTMLGebruikerWeergave()) . ' op 
                <strong>' . $datum . '</strong> om <strong>' . $tijd . '</strong></span>
                <p>' . $reactie . '</p></div>';
    }
}

/**
 * De RSSReactieWeergave klasse zorgt ervoor dat het Reactie in RSS weergegeven wordt
 *
 * De RSSReactieWeergave klasse is een implementatie van de ReactieWeergave klasse.
 * Dit maakt het mogelijk om de deze klasse in de weergeven() methode van Reactie te
 * gebruiken.
 */
class RSSReactieWeergave implements ReactieWeergave
{
    /** 
     * @return string
     */
    public function weergeven(Gebruiker $auteur, $reactie, $datum, $tijd)
    {
        return '<item>
                <title></title>
                <link>http://localhost/OOPGastenboek/</link>
                <description>' . $reactie . '</description>
                <author>' . $auteur->weergeven(new RSSGebruikerWeergave()) . '</author>
                </item>';
    }
}

/**
 * De GebruikerWeergave interface zorgt ervoor dat een Gebruiker weergegeven kan worden
 *
 * De GebruikerWeergave interface maakt het mogelijk om diverse weergaves te maken voor
 * een gebruiker. Zo is het mogelijk om de Gebruiker in bijvoorbeeld HTML en RSS weer
 * te geven
 */
interface GebruikerWeergave
{
    /**
     * Methode om de gebruiker weer te geven
     *
     * @param string $naam De naam van de gebruiker
     * @param string $email Het email adres van de gebruiker
     * @param string $website De website van de gebruiker
     *
     * @return string De weergave van de Gebruiker
     */
    public function weergeven($naam, $email, $website);
}

/**
 * De HTMLGebruikerWeergave klasse zorgt ervoor dat de gebruiker in HTML weergegeven kan
 * worden.
 *
 * De HTMLGebruikerWeergave is een implementatie van de GebruikerWeergave. Op deze manier
 * is het mogelijk om deze weergave te gebruiken in de weergeven() methode van Gebruiker
 */
class HTMLGebruikerWeergave implements GebruikerWeergave
{
    /**
     * @return string
     */
    public function weergeven($naam, $email, $website)
    {
        if($website != null)
            return '<a href="' . $website . '">' . $naam . '</a>';
        else
            return $naam;
    }
}

/**
 * De RSSGebruikerWeergave klasse zorgt ervoor dat de gebruiker in RSS weergegeven kan
 * worden.
 *
 * De RSSGebruikerWeergave is een implementatie van de GebruikerWeergave. Op deze manier
 * is het mogelijk om deze weergave te gebruiken in de weergeven() methode van Gebruiker.
 */
class RSSGebruikerWeergave implements GebruikerWeergave
{
    /**
     * @return string
     */
    public function weergeven($naam, $email, $website)
    {
        return $naam;
    }
}



Gastenboek weergeven:

Code tonen/verbergenCodeDeze code in een nieuw vensterDeze code in een tekstveldDeze code in een zip file downloaden
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
require_once 'Database.php';
require_once 'Gastenboek.php';
require_once 'Gastenboek.Adapter.php';
require_once 'Gastenboek.Weergave.php';

try
{
    $database = new Mysql();
    $database->maak_verbinding('localhost', 'root', '', 'gastenboek');
    
    $adapter = new MysqlGastenboekAdapter($database);
    
    $gastenboek = new Gastenboek($adapter);
    echo $gastenboek->weergeven(new HTMLGastenboekWeergave());
}
catch(DatabaseException $e)
{
    print $e->message;
}



Reactie toevoegen:

Code tonen/verbergenCodeDeze code in een nieuw vensterDeze code in een tekstveldDeze code in een zip file downloaden
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
require_once 'Database.php';
require_once 'Gastenboek.php';
require_once 'Gastenboek.Adapter.php';
require_once 'Gastenboek.Weergave.php';

try
{
    $database = new Mysql();
    $database->maak_verbinding('localhost', 'root', '', 'gastenboek');
    
    $adapter = new MysqlGastenboekAdapter($database);
    $gebruiker = new Gebruiker($_GET['naam'], $_GET['email'], $_GET['website']);
    $gebruiker->reactie_plaatsen($adapter, $_GET['reactie']);
}
catch(DatabaseException $e)
{
    print $e->message;
}




Waarschuwing: Het script houdt geen rekening met SQL Injection of andere veiligheids dingen. Je zal dus zelf de user input moeten controleren en er voor moeten zorgen dat HTML etc gestript worden!

Klassen diagram voor meer duidelijkheid:





Download (268)

7 reacties | reageren


Rating

Stemmen: 8Je moet ingelogd zijn om te stemmen!