Authentication class
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
98
99
100
101
102
103
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
<?php
class Authentication {
/**
* @acces protected.
* @var object.
*/
protected $oDatabase;
/**
* @acces protected.
* @var object.
*/
protected $oUserProvider;
/**
* @acces protected.
* @var integer.
*/
protected $iLifetime;
/**
* @acces public.
* @param object $oDatabase.
* @param integer $iLifetime.
*/
public function __construct($oDatabase, $iLifetime = 3600) {
$this->setDatabase($oDatabase);
$this->setLifetime($iLifetime);
$this->setUserProvider();
}
/**
* @acces public.
* @param object $oDatabase.
* @throws RuntimeException.
* @return self.
*/
public function setDatabase($oDatabase) {
$this->oDatabase = $oDatabase;
return $this;
}
/**
* @acces public.
* @return object.
*/
public function getDatabase() {
return $this->oDatabase;
}
/**
* @acces public.
* @param integer $iLifetime.
* @return self.
*/
public function setLifetime($iLifetime) {
$this->iLifetime= $iLifetime;
return $this;
}
/**
* @acces public.
* @return integer.
*/
public function getLifetime() {
return $this->iLifetime;
}
/**
* @acces public.
* @return self.
*/
public function setUserProvider() {
$this->oUserProvider = new UserProvider($this->oDatabase);
}
/**
* @acces public.
* @return boolean.
*/
public function setAuthentication() {
// Kijkt of de gebruiker bestaat via de $this->oUserProvider en set daar een Authentication voor.
}
/**
* @acces public.
* @return boolean.
*/
public function existsAuthentication() {
// Kijkt of er een Authentication bestaat en kijkt of de gebruiker bestaat via de $this->oUserProvider.
}
/**
* @acces public.
* @return boolean.
*/
public function removeAuthentication() {
// Verwijderd een Authentication.
}
}
?>
class Authentication {
/**
* @acces protected.
* @var object.
*/
protected $oDatabase;
/**
* @acces protected.
* @var object.
*/
protected $oUserProvider;
/**
* @acces protected.
* @var integer.
*/
protected $iLifetime;
/**
* @acces public.
* @param object $oDatabase.
* @param integer $iLifetime.
*/
public function __construct($oDatabase, $iLifetime = 3600) {
$this->setDatabase($oDatabase);
$this->setLifetime($iLifetime);
$this->setUserProvider();
}
/**
* @acces public.
* @param object $oDatabase.
* @throws RuntimeException.
* @return self.
*/
public function setDatabase($oDatabase) {
$this->oDatabase = $oDatabase;
return $this;
}
/**
* @acces public.
* @return object.
*/
public function getDatabase() {
return $this->oDatabase;
}
/**
* @acces public.
* @param integer $iLifetime.
* @return self.
*/
public function setLifetime($iLifetime) {
$this->iLifetime= $iLifetime;
return $this;
}
/**
* @acces public.
* @return integer.
*/
public function getLifetime() {
return $this->iLifetime;
}
/**
* @acces public.
* @return self.
*/
public function setUserProvider() {
$this->oUserProvider = new UserProvider($this->oDatabase);
}
/**
* @acces public.
* @return boolean.
*/
public function setAuthentication() {
// Kijkt of de gebruiker bestaat via de $this->oUserProvider en set daar een Authentication voor.
}
/**
* @acces public.
* @return boolean.
*/
public function existsAuthentication() {
// Kijkt of er een Authentication bestaat en kijkt of de gebruiker bestaat via de $this->oUserProvider.
}
/**
* @acces public.
* @return boolean.
*/
public function removeAuthentication() {
// Verwijderd een Authentication.
}
}
?>
Gewijzigd op 26/03/2013 13:59:29 door Joakim Broden
Maar als ik vragen mag: welke soort authentication moet er zijn?
Dus bijvoorbeeld rangen 1 t/m 10 of "admin", "moderator" en "gebruiker" ?
De klasse is via setDatabase() afhankelijk van een database-object dat je er al in de constructor in moet gooien:
Code (php)
Daarmee doet de klasse vervolgens niets, want het database-object wordt linea recta doorgegeven:
Code (php)
1
2
3
4
5
6
2
3
4
5
6
<?php
public function setUserProvider()
{
$this->oUserProvider = new UserProvider($this->oDatabase);
}
?>
public function setUserProvider()
{
$this->oUserProvider = new UserProvider($this->oDatabase);
}
?>
Daarmee hebben we tot slot een $this->oUserProvider die werkelijke login afhandelt.
Code (php)
1
2
3
4
5
6
7
8
9
10
11
12
13
2
3
4
5
6
7
8
9
10
11
12
13
De vraag is daarmee nog steeds: wat doet deze klasse nu eigenlijk? Ben je niet slechts een uienschil aan het toevoegen rond functionaliteit die je al hebt?
Gewijzigd op 26/03/2013 20:00:24 door Ward van der Put
In setAuthentication en existsAuthentication word ook $this->oDatabase gebruikt aangezien de Authentication opgeslagen word in de database. De ID van de Authentication word opgeslagen in een sessie. Aan de hand van deze sessie word de juiste Authentication uit database gehaald en vergeleken met de huidige gebruiker (ip en systeem word vergelijken met die van de gebruiker en wat er in de database staat).
Zie als dit anders moet, kan, beter is, hoor ik het graag ;-) Vandaar dat ik hier om feedback vraag. :-)
Gewijzigd op 26/03/2013 21:11:44 door Joakim Broden
• Je UserProvider weet wel dat de gebruiker bestaat maar niet wat zijn rechten zijn.
• Je UserProvider kan dat niet zelfstandig, maar alleen via het databaseobject dat je doorgeeft met:
new UserProvider($this->oDatabase)
Dat is een onbetrouwbare provider :)
Wat je ook kunt doen is gewoon op je gevoel af gaan en methods en 1 of meerdere classes maken zonder je te veel zorgen te maken. (begin gewoon ergens) Daarna kom je vanzelf verbeteringen tegen of wil je het weer uitbreiden. Dan begin je opnieuw of pas je de huidige code aan. En zo krijg je meestal toch een uitstekend resultaat.
Ward van der Put op 26/03/2013 21:32:58:
Niet flauw bedoeld (en dus niet zo lezen), maar ik zie dan dit:
• Je UserProvider weet wel dat de gebruiker bestaat maar niet wat zijn rechten zijn.
• Je UserProvider kan dat niet zelfstandig, maar alleen via het databaseobject dat je doorgeeft met:
new UserProvider($this->oDatabase)
Dat is een onbetrouwbare provider :)
• Je UserProvider weet wel dat de gebruiker bestaat maar niet wat zijn rechten zijn.
• Je UserProvider kan dat niet zelfstandig, maar alleen via het databaseobject dat je doorgeeft met:
new UserProvider($this->oDatabase)
Dat is een onbetrouwbare provider :)
• Klopt, want UserProvider geeft alleen de gebruiker. De rechten zijn weer wat anders, die worden weer ergens anders bepaald. Wat de UserProvider wel weet is de 'role/recht' wat de gebruiker is (een ID). Aan de hand van die 'role/recht' word er later gekeken welke rechten daar bij horen want volgens mij hoort dat niet in de UserProvider thuis of zit ik nu verkeerd? :-)
• En UserProvider kan dat inderdaad niet zelfstandig en daarom moet er een database object ingeladen worden aangezien de gebruikers in de database staan.
Ik ben nog aan het bedenken om in de UserProvider een soort van 'storage' te bouwen. Deze storage kan dan bijvoorbeeld een database of tekstbestand zijn met gebruikers zodat hij niet persee afhankelijk is van een database.
Harry hogeveen op 26/03/2013 21:44:01:
Ik weet bijna zeker dat het aan mij ligt, maar we doen weer heel moeilijk over een gewone manier om gebruikersrechten te controleren. Je vraagt ons allemaal hoe wij het zouden doen. Maar iedereen vindt bepaalde dingen weer beter of slechter. Stel je voor dat je dit in platte procedurele code zou doen, dan was het misschien al lang af. Ookal was dat wel veel minder professioneel. OOP is vaak veel ingewikkelder, alleen al omdat mensen gewoon twijfelen over namen, de indeling etc. Zelfs als ze pas een paar regels code hebben begint het al. Ik herken dit ook een beetje in mezelf. Vooral toen ik net begon.
Wat je ook kunt doen is gewoon op je gevoel af gaan en methods en 1 of meerdere classes maken zonder je te veel zorgen te maken. (begin gewoon ergens) Daarna kom je vanzelf verbeteringen tegen of wil je het weer uitbreiden. Dan begin je opnieuw of pas je de huidige code aan. En zo krijg je meestal toch een uitstekend resultaat.
Wat je ook kunt doen is gewoon op je gevoel af gaan en methods en 1 of meerdere classes maken zonder je te veel zorgen te maken. (begin gewoon ergens) Daarna kom je vanzelf verbeteringen tegen of wil je het weer uitbreiden. Dan begin je opnieuw of pas je de huidige code aan. En zo krijg je meestal toch een uitstekend resultaat.
Ben ik het opzich wel met je eens, alleen ik ben een 'beginner' met OOP en daarom vraag ik me wel eens af hoe andere het zouden aanpakken, of hoe anderen er over denken, of hoe het desnoods beter kan.
Gewijzigd op 26/03/2013 21:57:58 door Joakim Broden
A: Zeg B, is x een gebruiker?
B: Ja.
A: Ha, dank je! Welke rechten heeft hij dan?
B: Hij is admin!
Zie dit: http://phptuts.nl/view/45/9/
Gewijzigd op 26/03/2013 22:08:27 door Mark Hogeveen
Het Strategy pattern (door bijv. Role klassen) is de way to go.
Het veelvuldig gebruik van inheritance in OO code is vaak een indicator voor een beginner en bijna nooit het antwoord op een OO probleem.
Het wordt altijd ver gezocht met OOP vind ik. En je hebt nog steeds geen antwoord op de vraag die je eigenlijk stelde.
Wouter J. bedoelt volgens mij dat je voor de stukjes code die elk apart worden uitgevoerd voor admins, mods en users een verdeling moet maken.
Dus met "rollen" een admin heeft bijvoorbeeld toegang tot stukjes code die een mod of user niet heeft.
Zo als je in dit topic ziet kan iets dus op super veel manieren!
Harry hogeveen op 27/03/2013 13:25:09:
Het wordt altijd ver gezocht met OOP vind ik.
Het wordt over het algemeen niet ver genoeg gezocht als je het mij vraagt. De echte kracht van een OOP applicatie wordt door de meeste mensen nooit ontdekt, omdat ze te snel het al goed vinden en alsnog veel te veel dubbel aan het doen zijn. Ik zou bijna willen zeggen dat je nooit te ver kunt gaan.
Harry hogeveen op 27/03/2013 13:25:09:
En je hebt nog steeds geen antwoord op de vraag die je eigenlijk stelde.
En dat zal er ook nooit komen, tenzij je 'ja, ik zou het anders doen' een antwoord vind op de vraag. Dan bij deze....
Hertog Jan: https://gist.github.com/WouterJ/5254054 Merk op dat het een hele ruwe schets is. Het zou zo kunnen dat het iets te veel lagen heeft en niet echt makkelijk te gebruiken is. Maarja, dan heb je ong. het idee van mij in je hoofd. (in het echt zou ik dit met TDD hebben gedaan om een beter gebruik te krijgen)
Gewijzigd op 27/03/2013 14:13:08 door Wouter J
http://www.phphulp.nl/php/forum/topic/wat-voor-belachelijk-idee-heeft-bas-nu-weer-bedacht/89431/
En een beetje een zeurend topic:
http://www.phphulp.nl/php/forum/topic/waar-is-het-team/87721/
Gewijzigd op 28/03/2013 12:13:20 door Jasper DS
Of houdt men er alleen van de negatieve kanten van een mens te benadrukken en vergeet men de goede daden van een mens?
Of is het gewoon leuk om de eerste 2 topics van een persoon te linken en direct iemand af te klagen in je allereerste bericht op het forum?
Of verdiept men zich niet eerst in de materie voordat er uberhaupt een letter getypt wordt?
Gewijzigd op 28/03/2013 13:39:26 door Wouter J