Session + Login klasse
Ik ben pas begonnen met OOP en probeer nu een login + session systeem te maken.
De bedoeling is dat een gebruiker in kan loggen er dan een cookie gemaakt word met als inhoud een hash.
Deze hash word ook opgeslagen in de database en ook word het user object opgeslagen in de database.
Verder wil in de cookie ook weer opslaan in een session met session_set_save_handler()
Nu was mijn vraag aan jullie ben ik goed op weg? Wat zijn mijn verbeter punten tot nu toe? Waar moet ik rekening mee houden? Wat moet ik anders doen?
LoginAction.class.php
Code (php)
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
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
<?php
/**
* LoginAction klasse
*
* @author Tom Swinkels
* @version v1.0 last edit on 26-02-2012
*/
class LoginAction
{
private $_userMapper;
private $_sessionMapper;
public function __construct(UserMapper $userMapper, $sessionMapper)
{
$this->_userMapper = $userMapper;
$this->_sessionMapper = $sessionMapper;
}
public function execute(Request $request)
{
$errors = array();
if(isset($request->postData['submit']))
{
/** Form are submit **/
$user = $this->_userMapper->login($request->postData['user_name'], $request->postData['user_password']);
if($user != null)
{
/** Make new session **/
$session = new Session('user', $user);
$this->_sessionMapper->save($session);
$this->_sessionMapper->saveCookie($session);
/** Redirect user to an page **/
//header("location:" . SITE_PATH);
return $user;
}
else
{
$errors[] = 'Login gegevens kloppen niet';
return $errors[0];
}
}
}
}
?>
/**
* LoginAction klasse
*
* @author Tom Swinkels
* @version v1.0 last edit on 26-02-2012
*/
class LoginAction
{
private $_userMapper;
private $_sessionMapper;
public function __construct(UserMapper $userMapper, $sessionMapper)
{
$this->_userMapper = $userMapper;
$this->_sessionMapper = $sessionMapper;
}
public function execute(Request $request)
{
$errors = array();
if(isset($request->postData['submit']))
{
/** Form are submit **/
$user = $this->_userMapper->login($request->postData['user_name'], $request->postData['user_password']);
if($user != null)
{
/** Make new session **/
$session = new Session('user', $user);
$this->_sessionMapper->save($session);
$this->_sessionMapper->saveCookie($session);
/** Redirect user to an page **/
//header("location:" . SITE_PATH);
return $user;
}
else
{
$errors[] = 'Login gegevens kloppen niet';
return $errors[0];
}
}
}
}
?>
Session.class.php
Code (php)
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
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
<?php
/**
* Session klasse
*
* @author Tom Swinkels
* @version v1.0 last edit on 26-02-2012
*/
class Session
{
private $_name;
private $_data;
private $_timestamp;
private $_hash;
public function __construct($name, $data)
{
$this->generateHash();
$this->_name = $name;
$this->_data = $data;
$this->_timestamp = time();
}
public function generateHash()
{
$this->_hash = hash("sha512", time() . uniqid() . session_id());
}
public function getData()
{
return array('name' => $this->_name,
'hash' => $this->_hash,
'data' => $this->_data,
'timestamp' => $this->_timestamp);
}
}
?>
/**
* Session klasse
*
* @author Tom Swinkels
* @version v1.0 last edit on 26-02-2012
*/
class Session
{
private $_name;
private $_data;
private $_timestamp;
private $_hash;
public function __construct($name, $data)
{
$this->generateHash();
$this->_name = $name;
$this->_data = $data;
$this->_timestamp = time();
}
public function generateHash()
{
$this->_hash = hash("sha512", time() . uniqid() . session_id());
}
public function getData()
{
return array('name' => $this->_name,
'hash' => $this->_hash,
'data' => $this->_data,
'timestamp' => $this->_timestamp);
}
}
?>
SessionMapper.class.php
Code (php)
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
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
<?php
/**
* SessionMapper klasse
*
* @author Tom Swinkels
* @version v1.0 last edit on 26-02-2012
*/
class SessionMapper
{
private $_db;
private $_cookieData;
const COOKIE_NAME = 'SESSION_ID';
public function __construct(PDO $db, array $cookieData)
{
$this->_db = $db;
$this->_cookieData = $cookieData;
}
public function getSession($name)
{
$resultWebs = $this->_db->prepare("SELECT
webs_id,
webs_name,
webs_data
FROM
web_session
WHERE
webs_hash = ?
AND
webs_name = ?
");
$resultWebs->execute(array($this->getSessionId(),
$name));
$listWebs = $resultWebs->fetch(PDO::FETCH_ASSOC);
$session = new Session($name, unserialize($listWebs['webs_data']));
return $session;
}
public function getSessionId()
{
return $this->_cookieData[self::COOKIE_NAME];
}
public function save(Session $session)
{
/** Get the session data **/
$dataArray = $session->getData();
$resultUsrs = $this->_db->prepare("INSERT INTO
web_session
SET
webs_date_add = NOW(),
webs_name = ?,
webs_hash = ?,
webs_data = ?,
webs_timestamp = ?
");
$resultUsrs->execute(array($dataArray['name'],
$dataArray['hash'],
serialize($dataArray['data']),
$dataArray['timestamp']));
}
public function saveCookie(Session $session)
{
/** Get the session data **/
$dataArray = $session->getData();
setcookie(self::COOKIE_NAME, $dataArray['hash'], strtotime("+20 years"));
}
}
?>
/**
* SessionMapper klasse
*
* @author Tom Swinkels
* @version v1.0 last edit on 26-02-2012
*/
class SessionMapper
{
private $_db;
private $_cookieData;
const COOKIE_NAME = 'SESSION_ID';
public function __construct(PDO $db, array $cookieData)
{
$this->_db = $db;
$this->_cookieData = $cookieData;
}
public function getSession($name)
{
$resultWebs = $this->_db->prepare("SELECT
webs_id,
webs_name,
webs_data
FROM
web_session
WHERE
webs_hash = ?
AND
webs_name = ?
");
$resultWebs->execute(array($this->getSessionId(),
$name));
$listWebs = $resultWebs->fetch(PDO::FETCH_ASSOC);
$session = new Session($name, unserialize($listWebs['webs_data']));
return $session;
}
public function getSessionId()
{
return $this->_cookieData[self::COOKIE_NAME];
}
public function save(Session $session)
{
/** Get the session data **/
$dataArray = $session->getData();
$resultUsrs = $this->_db->prepare("INSERT INTO
web_session
SET
webs_date_add = NOW(),
webs_name = ?,
webs_hash = ?,
webs_data = ?,
webs_timestamp = ?
");
$resultUsrs->execute(array($dataArray['name'],
$dataArray['hash'],
serialize($dataArray['data']),
$dataArray['timestamp']));
}
public function saveCookie(Session $session)
{
/** Get the session data **/
$dataArray = $session->getData();
setcookie(self::COOKIE_NAME, $dataArray['hash'], strtotime("+20 years"));
}
}
?>
Je zou een interface Storage class kunnen maken die bijv. SessionStorage of XmlStorage implend en dan zou je in de constructor van de Logic klasse kunnen kijken of het instance is van de Storage class. Iets als:
Code (php)
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
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
<?php
interface Storage
{
public function set( $key, $value );
public function get( $key );
}
class SessionStorage implements Storage
{
public function __construct()
{
if( headers_sent() )
throw new LogicException('Cannot use session storage, because headers alreay sent');
session_start();
}
public function set( $key, $value )
{
$_SESSION[$key] = $value;
}
public function get( $key )
{
if( !isset($_SESSION[$key]) )
throw new LogicException('The session '.$key.' is not set');
return $_SESSION[$key];
}
}
class Login
{
protected $storage;
public function __construct( Storage $storage )
{
$this->storage = $storage;
}
public function execute( User $user )
{
$this->storage->set($user->getID(), $user->getHash());
}
}
?>
interface Storage
{
public function set( $key, $value );
public function get( $key );
}
class SessionStorage implements Storage
{
public function __construct()
{
if( headers_sent() )
throw new LogicException('Cannot use session storage, because headers alreay sent');
session_start();
}
public function set( $key, $value )
{
$_SESSION[$key] = $value;
}
public function get( $key )
{
if( !isset($_SESSION[$key]) )
throw new LogicException('The session '.$key.' is not set');
return $_SESSION[$key];
}
}
class Login
{
protected $storage;
public function __construct( Storage $storage )
{
$this->storage = $storage;
}
public function execute( User $user )
{
$this->storage->set($user->getID(), $user->getHash());
}
}
?>
Eventueel kun je hiervoor zelfs een service container gebruiken, meer informatie.
Bij OO programmeren moet je altijd zorgen dat een klasse niet iets beslist waar hij niks over te zeggen heeft. In dit geval heeft de Login classe betrekken op het inloggen en niet op waar het inloggen wordt opgeslagen. Daar zijn de Storage klassen weer verantwoordelijkheid. Een klasse moet eigenlijk maar 1 verantwoordelijkheid hebben, bijv. het onthouden van User informatie, het opslaan van data, enz.
Een datamapper is altijd verantwoordelijk voor het overbrengen van data tussen de db en het object, zonder dat deze 2 van elkaar weten.
Het is ook verstandig om PHPDoc comments voor elke functie te zetten, dan wordt het een stuk beter. Ik heb het script nu nog maar een beetje globaal doorgekeken, omdat het een beetje onoverzichtelijk is als je dat voor je neus krijgt geworpen.
Gewijzigd op 26/02/2012 22:59:23 door Wouter J
Ik snap nog niet helemaal wat je met die interface storage wil zeggen.
Verder vind ik comments niet zo belangrijk ik vind het belangrijker dat de code netjes is en de benaming.
Om dat voor elkaar te krijgen moet ik zorgen dat ik storage klassen maak die op zijn minst een set en get method hebben en ik moet zorgen dat de klasse die ik in de constructor als storage inlaad wel iets is van storage.
Dit doe ik met de interface, meer over interfaces: http://phptuts.nl/view/45/12/
Dit neem ik in iedergeval mee in mijn hoofd en kijk of dat ik dat ook zo ga doorvoeren of dat het nog even te lastig word.
Zijn er nog andere dingen die jij anders zou doen?
Wat andere globale puntjes:
- Een sessionmapper die een cookie opslaat zie ik ook nog niet helemaal zitten. Een cookiemapper zou een cookie moeten opslaan.
- Ik ben benieuwd wat de login method in de usermapper doet, alles wat te maken heeft met het inloggen hoort in de Login klasse thuis.
- Een getData method mag wel, maar het is mooier om allemaal aparte getters te maken.
- Foutafhandeling zou ik met exceptions doen, dat is het meest gebruikelijke in OO. Meer info: http://phptuts.nl/view/35/7/
Verder zeg je dat je liever aparte getters hebt.
Wil je dit dan op de manier doen door allemaal losse methodes of via de __get() function? Ik zie dat de __get() bijna nooit gebruikt word.
Bijvoorbeeld zoals ik bij de user klasse doe:
Code (php)
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
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
<?php
/**
* User klasse
*
* @author Tom Swinkels
* @version v1.0 last edit on 09-02-2012
*/
class User
{
private $_name;
private $_password;
private $_email;
private $_firstName;
private $_middleName;
private $_lastName;
private $_dateBirth;
private $_adres;
private $_houseNr;
private $_zipcode;
private $_town;
private $_phoneNr;
private $_mobileNr;
public function __construct()
{
}
public function setName($name)
{
$this->_name = $name;
}
public function setPassword($password)
{
$this->_password = $password;
}
public function setEmail($email)
{
$this->_email = $email;
}
public function setFirstName($firstname)
{
$this->_firstName = $firstname;
}
public function setMiddleName($middlename)
{
$this->_middleName = $middlename;
}
public function setLastName($lastname)
{
$this->_lastName = $lastname;
}
public function setDateBirth($datebirth)
{
$this->_dateBirth = $datebirth;
}
public function setAdres($adres)
{
$this->_adres = $adres;
}
public function setHouseNr($housenr)
{
$this->_houseNr = $housenr;
}
public function setZipcode($zipcode)
{
$this->_zipcode = $zipcode;
}
public function setTown($town)
{
$this->_town = $town;
}
public function setPhoneNr($phonenr)
{
$this->_phoneNr = $phonenr;
}
public function setMobileNr($mobilenr)
{
$this->_mobileNr = $mobilenr;
}
public function getData()
{
return array('name' => $this->_name,
'password' => $this->_password,
'email' => $this->_email,
'firstName' => $this->_firstName,
'middleName' => $this->_middleName,
'lastName' => $this->_lastName,
'dateBirth' => $this->_dateBirth,
'adres' => $this->_adres,
'houseNr' => $this->_houseNr,
'zipcode' => $this->_zipcode,
'town' => $this->_town,
'phoneNr' => $this->_phoneNr,
'mobileNr' => $this->_mobileNr);
}
}
?>
/**
* User klasse
*
* @author Tom Swinkels
* @version v1.0 last edit on 09-02-2012
*/
class User
{
private $_name;
private $_password;
private $_email;
private $_firstName;
private $_middleName;
private $_lastName;
private $_dateBirth;
private $_adres;
private $_houseNr;
private $_zipcode;
private $_town;
private $_phoneNr;
private $_mobileNr;
public function __construct()
{
}
public function setName($name)
{
$this->_name = $name;
}
public function setPassword($password)
{
$this->_password = $password;
}
public function setEmail($email)
{
$this->_email = $email;
}
public function setFirstName($firstname)
{
$this->_firstName = $firstname;
}
public function setMiddleName($middlename)
{
$this->_middleName = $middlename;
}
public function setLastName($lastname)
{
$this->_lastName = $lastname;
}
public function setDateBirth($datebirth)
{
$this->_dateBirth = $datebirth;
}
public function setAdres($adres)
{
$this->_adres = $adres;
}
public function setHouseNr($housenr)
{
$this->_houseNr = $housenr;
}
public function setZipcode($zipcode)
{
$this->_zipcode = $zipcode;
}
public function setTown($town)
{
$this->_town = $town;
}
public function setPhoneNr($phonenr)
{
$this->_phoneNr = $phonenr;
}
public function setMobileNr($mobilenr)
{
$this->_mobileNr = $mobilenr;
}
public function getData()
{
return array('name' => $this->_name,
'password' => $this->_password,
'email' => $this->_email,
'firstName' => $this->_firstName,
'middleName' => $this->_middleName,
'lastName' => $this->_lastName,
'dateBirth' => $this->_dateBirth,
'adres' => $this->_adres,
'houseNr' => $this->_houseNr,
'zipcode' => $this->_zipcode,
'town' => $this->_town,
'phoneNr' => $this->_phoneNr,
'mobileNr' => $this->_mobileNr);
}
}
?>
- Het gebruik van een storage interface
- Het gebruik van PHPDoc
Ik zal ze hieronder beide even toelichten:
== Storage interface ==
Tijdens het programmeren kan je altijd zoveel abstraheren als je zelf wil. Je moet alleen wel bedenken voor jezelf wanneer het genoeg is. Hier kom je goed achter als je Test Driven Development (TDD) gaat toepassen. Ik denk in dit geval dat een storage interface een stap te ver is.
Als ik inlog wil ik altijd dat mijn data persistent blijft over verschillende requests. Dit is waar een session voor is. Ik zou dan ook altijd een session gebruiken voor het inloggen. De manier waarop de session opgeslagen moet worden zou ik vervolgens abstraheren zoals hier ook al gebeurd doormiddel van de SessionMapper. Je zou verschillende mappers kunnen maken voor de verschillende storage methoden die je kan toepassen.
Overigens denk ik dat het voor een deel ook gewoon is wat je zelf prettig vind werken. Iedereen zou de abstracties iets anders en verder / minder ver doorvoeren.
== PHPDoc ==
Ik heb nog nooit een nuttig gebruik gezien van PHPDoc. Sterker nog, ik heb er vaker last van gehad dan daadwerkelijk baat. Het belangrijkste bij het programmeren is duidelijke naamgeving van methoden, variabelen en klassen. Op het moment dat je naamgeving gebruikt die voor zich wijst en de intentie van de code beschrijft, heb je geen commentaar meer nodig om te achterhalen hoe iets werkt.
Sterker nog het commentaar wordt dubbelop en vertelt eigenlijk hetgene wat de naam van een methode ook al zegt. Dit is een gevaarlijke situatie, want terwijl er verder ontwikkelt wordt aan een systeem, zal wellicht de werking van de methode veranderen. Er wordt echter zelden meer gekeken naar de PHPDoc die erboven staat, wat deze outdated en daardoor juist heel erg verwarrend maakt.
Voor mensen die willen weten hoe deze code tot stand is gekomen zie ook dit topic:
https://webdevils.nl/forum/serverside/348-tip-s-voor-mijn-class/
== Opmerkingen over laatste reactie Tom ==
Ik zou zelf alles opdelen in losse get en set methoden zover je die nodig hebt. Pas hier echter wel mee op, want als je vervolgens niets doet in de get en set kan dit het risico veroorzaken dat je dingen buiten de user klasse gaat doen die je er eigenlijk in zou moeten doen.
Verder zou ik als je een klasse hebt met zoveel properties kijken of je de klasse niet verder zou moeten opsplitsen. Bijv. in een aantal data objecten. In jou voorbeeld zou ik zelf bijv. voor een Adres klasse gaan die de adres informatie bijhoudt. Je kan er dan ook direct voor zorgen dat je het adres alleen in zijn geheel kan vervangen. Het enige moment waarop een adres zou wijzigen is namelijk op het moment dat iemand verhuist en dan wil je sowieso alles vervangen en niet alleen de postcode. Dat kan je op die manier afdwingen.
Gewijzigd op 27/02/2012 14:08:03 door Mark Kazemier
Een adres klasse gaat er ook zeker komen.
Verder maak ik liever gebruik van losse get's en set's i.v.m de magic methode.
Verder een login hoort bij de userMapper omdat hij de gegevens dan de user ophaalt, eigenlijk zou de naam van die methode moeten zijn getUserByNameAndPassword().
Quote:
Overigens denk ik dat het voor een deel ook gewoon is wat je zelf prettig vind werken. Iedereen zou de abstracties iets anders en verder / minder ver doorvoeren.
Dit ben ik met je eens. De Storage Interface is misschien een stapje te ver voor alleen een inlog systeem. Maar als ik een hele site ga maken in OOP is het handig dat ik al van dit soort verschillende storage objecten heb en er zo eentje bij kan bouwen.
Quote:
Het belangrijkste bij het programmeren is duidelijke naamgeving van methoden, variabelen en klassen.
Dit is inderdaad het belangrijkste. Maar gebruik jij dan type prefixen in namen? Zodat je kan zien wat er gereturned word en welk type een parameter moet zijn? Voor dat soort dingen is de PHPdoc heel handig. Je hebt snel overzicht wat er in moet en wat je terug krijgt.
Bij getter en setters zou ik geen PHPdoc gebruiken, dat weet je zo wel. Maar bij de wat uitgebreidere methods is het altijd handig om een kort overzicht te zien.
Verder vind ik de " Er wordt echter zelden meer gekeken naar de PHPDoc die erboven staat, wat deze outdated en daardoor juist heel erg verwarrend maakt." mening een beetje vreemd. Hoe weet je dat er zelden naar de PHPdoc wordt gekeken? Als ik iets verander verander ik namelijk ook meteen de PHPdoc erboven. Ik denk dat het vooral aan de persoon ligt of dit wel of niet wordt gedaan, maar als je PHPdoc gebruikt moet je het ook goed gebruiken...
Quote:
Dit ben ik met je eens. De Storage Interface is misschien een stapje te ver voor alleen een inlog systeem. Maar als ik een hele site ga maken in OOP is het handig dat ik al van dit soort verschillende storage objecten heb en er zo eentje bij kan bouwen.
Hangt er geheel vanaf hoe je alles opgebouwd hebt. Ik gebruik zelf het domain model pattern. Waarbij ik repositories gebruik waaruit je de domein modellen kan opvragen en in kan toevoegen. De repository bepaalt zelf vervolgens doormiddel van een ORM hoe en waar de object opgeslagen worden en waar ze vandaan komen. Zo heb ik ook nooit meer te maken met de relationele structuur van de database. Daarnaast is mijn domein model op die manier volledig losgekoppeld van de infrastructuur. Het domein model weet niet eens dat het opgeslagen kan worden.
Quote:
zien.
Verder vind ik de " Er wordt echter zelden meer gekeken naar de PHPDoc die erboven staat, wat deze outdated en daardoor juist heel erg verwarrend maakt." mening een beetje vreemd.
Verder vind ik de " Er wordt echter zelden meer gekeken naar de PHPDoc die erboven staat, wat deze outdated en daardoor juist heel erg verwarrend maakt." mening een beetje vreemd.
Dat is geen mening, maar gewoon wat ik in de praktijk tegen kom als ik code van andere moet aanpassen of moet samenwerken met andere. Het schrijven van PHPDoc kost tijd en vaak is die tijd er niet. Zeker niet als er een set met bugs gefixt moeten worden. De fixes en features worden snel toegevoegd en de PHPDoc blijft staan. Helaas is niet iedereen zo netjes daarmee dus.
Daarnaast heb ik nog nooit een methode gezien waarbij de naam goed was en PHPDoc nog enige toegevoegde waarde kon hebben. Natuurlijk zijn er wel methoden waar PHPDoc kan helpen, maar meestal zijn er dan één van de volgende dingen mis:
- De methode heeft naam die niet goed beschrijft wat de methode doet
- De methode doet meer dan één ding en zou opgesplitst moeten worden
Ik heb de afgelopen vijf jaar geen PHPDoc of Javadoc of Doxygen geschreven en het ook geen moment gemist. En de mensen die bij mij in het team zaten heb ook nog nooit horen klagen dat ze misten. Ook niet voor het opgeven van typen. Ik gebruik namelijk voor klassen altijd typehinting en bij primitieve typen geven de parameter namen en methode namen al duidelijk aan wat er voor type verwacht wordt. Voor Java en C++ is dit verder helemaal zinloos, want bij die talen geef je gewoon in je methode interface al de typen aan.
Zie ook mijn artikel Commentaar wanneer is het nuttig? over deze kwestie. Veel mensen noemen commentaar (en dus ook PHPDoc) in hun code ten onrechte documentatie. Maar commentaar en documentatie zijn twee compleet verschillende dingen. Documentatie ben ik wel een heel groot voorstander van.
Gewijzigd op 29/02/2012 13:21:51 door Mark Kazemier
Moet ik nu om te bepalen wie er ingelogd is de functie getSession oproepen? Hoe kan ik deze functie beter beveiligen en waar zouden jullie op beveilingen enkel IP?
Code (php)
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
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
<?php
/**
* SessionMapper klasse
*
* @author Tom Swinkels
* @version v1.0 last edit on 27-02-2012
*/
class SessionMapper
{
private $_db;
const COOKIE_NAME = 'SESSION_ID';
public function __construct(PDO $db)
{
$this->_db = $db;
}
public function getSession($name, $request)
{
$resultWebs = $this->_db->prepare("SELECT
webs_id,
webs_name,
webs_data
FROM
web_session
WHERE
webs_hash = ?
AND
webs_name = ?
");
$resultWebs->execute(array($this->getSessionId($request),
$name));
$listWebs = $resultWebs->fetch(PDO::FETCH_ASSOC);
$session = new Session($name, unserialize($listWebs['webs_data']));
return $session;
}
public function getSessionId(Request $request)
{
return $request->getCookie[self::COOKIE_NAME];
}
public function save(Session $session)
{
$resultUsrs = $this->_db->prepare("INSERT INTO
web_session
SET
webs_date_add = NOW(),
webs_name = ?,
webs_hash = ?,
webs_data = ?,
webs_timestamp = ?
");
$resultUsrs->execute(array($session->getName(),
$session->getHash(),
serialize($session->getData()),
$session->getTimestamp()));
$this->saveCookie($session->getHash());
}
private function saveCookie($hash)
{
setcookie(self::COOKIE_NAME, $hash, strtotime("+20 years"));
}
}
?>
/**
* SessionMapper klasse
*
* @author Tom Swinkels
* @version v1.0 last edit on 27-02-2012
*/
class SessionMapper
{
private $_db;
const COOKIE_NAME = 'SESSION_ID';
public function __construct(PDO $db)
{
$this->_db = $db;
}
public function getSession($name, $request)
{
$resultWebs = $this->_db->prepare("SELECT
webs_id,
webs_name,
webs_data
FROM
web_session
WHERE
webs_hash = ?
AND
webs_name = ?
");
$resultWebs->execute(array($this->getSessionId($request),
$name));
$listWebs = $resultWebs->fetch(PDO::FETCH_ASSOC);
$session = new Session($name, unserialize($listWebs['webs_data']));
return $session;
}
public function getSessionId(Request $request)
{
return $request->getCookie[self::COOKIE_NAME];
}
public function save(Session $session)
{
$resultUsrs = $this->_db->prepare("INSERT INTO
web_session
SET
webs_date_add = NOW(),
webs_name = ?,
webs_hash = ?,
webs_data = ?,
webs_timestamp = ?
");
$resultUsrs->execute(array($session->getName(),
$session->getHash(),
serialize($session->getData()),
$session->getTimestamp()));
$this->saveCookie($session->getHash());
}
private function saveCookie($hash)
{
setcookie(self::COOKIE_NAME, $hash, strtotime("+20 years"));
}
}
?>
Moet het ophalen van iemand die is ingelogd op de volgende manier?
Code (php)
1
2
3
4
5
6
2
3
4
5
6
$logindata = $sessionMapper->getSession('user', $request);
//Check login?
if($logindata->data)
{
echo 'Ingelogd als ' . $logindata->data->name;
}
//Check login?
if($logindata->data)
{
echo 'Ingelogd als ' . $logindata->data->name;
}
Verder krijg ik een error als er een gebruiker naar de pagina gaat waar nog geen session voor gemaakt is, hoe kan ik dat oplossen?
Code (php)
1
2
3
4
2
3
4
public function getSessionId(Request $request)
{
return $request->getCookie[self::COOKIE_NAME];
}
{
return $request->getCookie[self::COOKIE_NAME];
}