user class rechten
Ik ben bezig met het maken van een user class. Het is mij gelukt om de gebruiker in te loggen en per pagina te controleren of de gebruiker toestemming heeft om deze pagina te bezoeken. Nu wil ik ook graag dat ik kan controleren of de gebruiker toestemming heeft om bepaalde acties uit te voeren op deze pagina zoals verwijden en wijzigen.
Ik heb hieronder de klasse, de variabele $userModule komt nog niet uit de database omdat dit misschien nog gaat veranderen m.b.t. de rechten. Misschien heeft iemand een idee of kan iemand mij een beetje in de goede richting helpen. Als het niet lukt kan ik de klasse ook zo afmaken en dit later toevoegen.
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
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
<?php
class User {
protected $id = null;
protected $userType = null;
protected $userName = null;
protected $email = null;
protected $pass = null;
protected $dateAdded = null;
protected $userModule = array('pages','news');
public function logIn($user){
if($user){
isset($_SESSION['user']) == $user;
}
}
public function getId() {
return $this->id;
}
public function getUserName(){
return $this->userName;
}
function privilegeIsAllowed($privillege){
}
public function isAllowed($object){
if(in_array($object,$this->userModule)){
return true;
}
else{
return false;
}
}
}
class userMapper extends User{
protected $db;
function __construct(PDO $pdo){
$this->db = $pdo;
}
public function setUser($userName,$pass) {
$query = 'SELECT id, userType, userName, email, pass FROM users WHERE userName=:userName AND pass=:pass';
$smtp = $this->db->prepare($query);
$result = $smtp->execute(array(
':userName' => $userName,
':pass' => $pass,
));
if($result){
$smtp->setFetchMode(PDO::FETCH_CLASS, 'User');
$user = $smtp->fetch();
return $user;
}
else{
return false;
}
}
}
?>
class User {
protected $id = null;
protected $userType = null;
protected $userName = null;
protected $email = null;
protected $pass = null;
protected $dateAdded = null;
protected $userModule = array('pages','news');
public function logIn($user){
if($user){
isset($_SESSION['user']) == $user;
}
}
public function getId() {
return $this->id;
}
public function getUserName(){
return $this->userName;
}
function privilegeIsAllowed($privillege){
}
public function isAllowed($object){
if(in_array($object,$this->userModule)){
return true;
}
else{
return false;
}
}
}
class userMapper extends User{
protected $db;
function __construct(PDO $pdo){
$this->db = $pdo;
}
public function setUser($userName,$pass) {
$query = 'SELECT id, userType, userName, email, pass FROM users WHERE userName=:userName AND pass=:pass';
$smtp = $this->db->prepare($query);
$result = $smtp->execute(array(
':userName' => $userName,
':pass' => $pass,
));
if($result){
$smtp->setFetchMode(PDO::FETCH_CLASS, 'User');
$user = $smtp->fetch();
return $user;
}
else{
return false;
}
}
}
?>
Alvast bedankt!!
Gewijzigd op 14/12/2012 00:33:36 door Tim S
Je maakt een aparte set aan classes die de rechten van gebruikers beheren en allemaal dezelfde interface implementeren. Een object van een van deze classes injecteer je in het user object en dat object gebruikt zo'n rechten object om te weten te komen wat wel en wat niet mag. De rechten zou je uit een database kunnen halen, uit een tekst bestand, of (als het een niet al te groot aantal sets van rechten is) voor elke rechtenset een apart rechten class maken.
Voordeel van deze aanpak is dat je altijd, voor elke gebruiker dezelfde user class kunt gebruiken. De rechten laat je hier los van en wanneer nodig haal je een rechtenset op via een rechten class. Eventueel kan dit dan zelfs nog tijdens de executie van je script veranderen. Ook als je dan eens een extra rechtenset wilt aanmaken, dan hoef je de user class nooit aan te passen.
Hopelijk is bovenstaande niet al te abstract en kan je er iets mee.
Voor de rechten uit de database in combinatie met de verschillende modules(het grootste probleem) heb ik even in php een ideetje gemaakt:
Code (php)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
<?php
//moet uit database komen
$privileges = array(
'pages' => array('edit','delete'),
'news' => array('add'),
);
//het recht dat we willen gebruiken
$privilege = 'add';
//op het object de niews pagina
$object = 'news';
//kijken of het recht dat we willen gebruiken voorkomt in de rechten die de gebruiker heeft voor dit opject/pagina
if(in_array($privilege,$privileges[$object])){
echo 'ja het mag';
}
else{
echo 'nee het mag niet';
}
?>
//moet uit database komen
$privileges = array(
'pages' => array('edit','delete'),
'news' => array('add'),
);
//het recht dat we willen gebruiken
$privilege = 'add';
//op het object de niews pagina
$object = 'news';
//kijken of het recht dat we willen gebruiken voorkomt in de rechten die de gebruiker heeft voor dit opject/pagina
if(in_array($privilege,$privileges[$object])){
echo 'ja het mag';
}
else{
echo 'nee het mag niet';
}
?>
ik controleer dan voor iemand de pagina wilt betreden of de ingelogde gebruiker toestemming heeft om de pagina $object te betreden. voor dat iemand dan iets wilt doen zoals verwijderen ga ik dan controleren isPrevilegeAllowed(); met iets zoals hierboven maar dan in een nieuwe klasse. Is dit een beetje in de goed richting?
Gewijzigd op 14/12/2012 01:28:14 door Tim S
In het geval van je rechten class kan je doormiddel van een interface dus afdwingen dat bepaalde methods om rechten te checken aanwezig zijn. Elke class die dus een rechten class wil zijn moet die interface implementeren en daarmee die methodes. Je user class kan vervolgens een type hint geven in de rechten injectie methode zodat je in de user class altijd zeker weet dat een geinjecteerd object de juiste methodes bevat.
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
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
<?php
//interface voor all rechten classes
interface Rights_Interface{
public function checkUserRights( $privilege );
}
//admin users hebben het recht
class Admin_Rights_Class implements Rights_Interface{
public function checkUserRights( $privilege ){
return true;
}
}
//Unregistered users hebben het recht niet
class Unregistered_Rights_Class implements Rights_Interface{
public function checkUserRights( $privilege ){
return false;
}
}
//user class met een method setRightsObject zodat een rechten object kan worden geinjecteerd
//alleen classes die Rights_Interface implementeren kunnen worden geinjecteerd,
//alle andere classes zullen een foutmelding opleveren.
class User_Class{
public function setRightsObject( Rights_Interface $obj ){
//zet het rights object in een property
}
}
?>
//interface voor all rechten classes
interface Rights_Interface{
public function checkUserRights( $privilege );
}
//admin users hebben het recht
class Admin_Rights_Class implements Rights_Interface{
public function checkUserRights( $privilege ){
return true;
}
}
//Unregistered users hebben het recht niet
class Unregistered_Rights_Class implements Rights_Interface{
public function checkUserRights( $privilege ){
return false;
}
}
//user class met een method setRightsObject zodat een rechten object kan worden geinjecteerd
//alleen classes die Rights_Interface implementeren kunnen worden geinjecteerd,
//alle andere classes zullen een foutmelding opleveren.
class User_Class{
public function setRightsObject( Rights_Interface $obj ){
//zet het rights object in een property
}
}
?>
Gewijzigd op 14/12/2012 01:42:51 door Erwin H
Jij heb een klasse admin_Rights en een klasse Unregistered_rights, maar als ik controleer met een functie zoals ik nu heb dan heb je deze klasse niet nodig. Als gebruikers type heb je standaard admin moderator en author of iets in die richting. Wat ik wil is dus zelf gebruikers type aanmaken in een database. Zo kan ik iemand toestemming geven om bijvoorbeeld de nieuws module te gebruiken. Ook kan ik deze klasse in een website gebruiken, dan heb je wel een aantal standaard gebruikers.
Het lijkt mij dus een beetje omslachtig om voor elke type gebruiker een klasse aan te maken.
Ik dacht zelf dan aan een interface met een klasse om te controleren of de gebruiker toestemming heeft om de pagina te bezoeken en om te kijken welke handelingen de gebruiker vervolgens mag uitvoeren. Ook moet ik dan nog iets maken waarmee je rechten kan toevoegen o.i.d.
Erwin H op 14/12/2012 00:47:52:
De rechten zou je uit een database kunnen halen, uit een tekst bestand, of (als het een niet al te groot aantal sets van rechten is) voor elke rechtenset een apart rechten class maken.
Het voorbeeld is (om het even simpel te houden) gebaseerd op de laatste mogelijkheid, maar is niet de enige.
Wat je bijvoorbeeld kan doen is een paar rechten classes maken. Een voor admins (jij), want dat staat wel redelijk vast, ik neem aan dat je dat niet in een database zet, maar ook een voor normale gebruikers. Die geef je in die class dan bepaalde standaard rechten al mee (het niet mogen aanpassen van gebruikersrechten bijvoorbeeld, wat een admin wel zou mogen), andere haal je uit je database.
Het voordeel van zo'n structuur is dat je volkomen flexibel bent in wat je wilt. Zonder dat je ooit nog iets aan je user class hoeft te doen kan je het rechten systeem zo complex, of zo simpel houden als je zelf wilt.
als gebruiker neem ik bijvoorbeeld Tim. Tim log ik in. Als ik ben ben ingelogd heb ik een een gebruikers type bijvoorbeeld admin.
Dan kan ik in een klasse maken voor admin en omdat ik een admin gebruiker ben ga ik naar die klasse. In die klasse kan ik dan bepalen welke rechten in heb per object. Waarbij de rechten en objecten uit een database kunnen komen. Deze worden dan vergeleken met het object wat ik per pagina aangeef(zoals nu: isAllowed('pages')).
Je kan dan een aantal gebruikers type aanmaken maar heb wel de optie om te bepalen welke rechten deze hebben.
Natuurlijk kan ik bij admin alle rechten vrijgeven.
Ik kan dan ook een normale gebruiker aanmaken zoals hier of dit forum en bijvoorbeeld een moderator. Bij moderator geldt bovenstaande beter.
Gewijzigd op 14/12/2012 13:39:01 door Tim S
Enige nuance die ik zou willen aanbrengen is waar je zegt dat 'omdat ik een admin gebruiker ben ga ik naar die klasse', zou ik zeggen 'die klasse wordt dan meegegeven aan het user object'. De classes die gebruik gaan maken van een rechten object weten over het algemeen zelf niet welk object ze krijgen. Dat hoeven ze ook niet te weten, ze hoeven ook helemaal niet te weten wat dat rechten object precies doet, of hoe. Het enige wat ze willen is dat ze antwoord krijgen op de vraag of de user bepaalde rechten heeft of niet.
Dit zijn 2 klassen. De Authentication (of Firewall) klasse kijkt wie je bent, hij maakt een User klasse en stelt in welke rechten je hebt (dit doet hij per request, dus als je niet ben ingelogd krijg je de rechten voor 'Anonymous' of 'Gast' oid). De Autorization klasse kijkt of je wel rechten genoeg hebt om een bepaalde actie uit te voeren. Deze actie kan een pagina bezoeken, een button, ect. zijn.
De code wordt dan bijv:
Code (php)
1
2
3
4
5
6
7
8
9
10
11
2
3
4
5
6
7
8
9
10
11
<?php
// de login pagina
session_start();
// ...
if ($form->isSend()) {
$user = Authentication::createUserFromForm($form); // maak een user object aan de hand van form data, databases, ect.
$_SESSION['user'] = serialize($user); // sla dat user object op in een sessie
}
?>
// de login pagina
session_start();
// ...
if ($form->isSend()) {
$user = Authentication::createUserFromForm($form); // maak een user object aan de hand van form data, databases, ect.
$_SESSION['user'] = serialize($user); // sla dat user object op in een sessie
}
?>
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
<?php
// een doodgewone andere pagina
$user = Authentication::createUserFromGlobals(); // maakt een user object aan aan de hand van de eerder opgeslage sessie
// autorization: voor deze actie zijn Admin rechten nodig
if ($user->isGranted('ROLE_ADMIN')) {
// ... een bepaalde actie voor de admin
}
if (!$user->isGranted('ROLE_USER')) {
exit('deze pagina is alleen beschikbaar als je bent ingelogd');
}
?>
// een doodgewone andere pagina
$user = Authentication::createUserFromGlobals(); // maakt een user object aan aan de hand van de eerder opgeslage sessie
// autorization: voor deze actie zijn Admin rechten nodig
if ($user->isGranted('ROLE_ADMIN')) {
// ... een bepaalde actie voor de admin
}
if (!$user->isGranted('ROLE_USER')) {
exit('deze pagina is alleen beschikbaar als je bent ingelogd');
}
?>
Code (php)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<?php
class Authentication
{
public static function createUserFromForm($form)
{
$username = $form->fields->name; // verander deze naar wat jij gebruikt
$password = $form->fields->password; // om form variable op te halen
$role = ...; // haal de role (ROLE_ADMIN, ROLE_MOD, ROLE_USER,ect.) ergens vandaan
$role = new Role($role); // Erwin noemde dit Rights (het zou dan bijv. `new Admin_Rights` worden)
$user = new User();
$user->setRole($role);
}
}
?>
class Authentication
{
public static function createUserFromForm($form)
{
$username = $form->fields->name; // verander deze naar wat jij gebruikt
$password = $form->fields->password; // om form variable op te halen
$role = ...; // haal de role (ROLE_ADMIN, ROLE_MOD, ROLE_USER,ect.) ergens vandaan
$role = new Role($role); // Erwin noemde dit Rights (het zou dan bijv. `new Admin_Rights` worden)
$user = new User();
$user->setRole($role);
}
}
?>
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
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
<?php
abstract class Person {
private $name;
protected $level;
const LEVEL_GUEST = 1;
const LEVEL_USER = 2;
const LEVEL_MOD = 4;
const LEVEL_ADMIN = 8;
public function __construct($name) {
$this->setName($name);
$this->setLevel(); // set in subclass
}
public function setName($name) {
$this->name = ucwords(strtolower($name));
}
public function getName() {
return $this->name;
}
public function getLevel() {
return $this->level;
}
abstract protected function setLevel();
}
?>
abstract class Person {
private $name;
protected $level;
const LEVEL_GUEST = 1;
const LEVEL_USER = 2;
const LEVEL_MOD = 4;
const LEVEL_ADMIN = 8;
public function __construct($name) {
$this->setName($name);
$this->setLevel(); // set in subclass
}
public function setName($name) {
$this->name = ucwords(strtolower($name));
}
public function getName() {
return $this->name;
}
public function getLevel() {
return $this->level;
}
abstract protected function setLevel();
}
?>
Wat is het verschil tussen deze 2 manieren en welke is beter/flexibeler?
een class ziet er dan als volgt uit bijvoorbeeld:
Code (php)
dus:
if($user->isGranted('nieuwsmodule')){
}
Dit is meer werk met de database maar is volgens mij makkelijker. Ik weet alleen niet of dit een goede manier is...?
Toevoeging op 15/12/2012 01:23:37:
@wouter
is de autentication klasse een vervanging van de mapper, dus kan je hierin ook gebruikers registreren of is het verstandig hier een nieuwe klasse voor te maken?
Quote:
Dit is meer werk met de database maar is volgens mij makkelijker. Ik weet alleen niet of dit een goede manier is...?
Het lijkt mij niet makkelijker... Stel je site wordt een succes en je wilt na een jaar een nieuwe feature toevoegen die alleen zichtbaar is voor moderators of hoger. Dan zul je dus in de database overal deze rechten moeten toevoegen voor elke gebruiker die moderator of hoger is en vervolgens ook nog je PHP code aanpassen.
Het lijkt mij veel makkelijker om een paar standaard ROLES te hebben en dan per feature in PHP te kijken welke role ervoor nodig is. Zo beperk je deze ROLES ook niet tot 1 onderdeel, namelijk de HTML, maar kun je ook pagina's en controllers gaan afschermen.
Quote:
is de autentication klasse een vervanging van de mapper, dus kan je hierin ook gebruikers registreren of is het verstandig hier een nieuwe klasse voor te maken?
Nee, registratie gebeurd apart, het inloggen kan wel door de authentication klasse gedaan worden.
Ik ben nog bezig met de klasse maar heb het als volgt gedaan.
Rollen:
admin - heeft alle rechten en kan modules activeren voor website eigenaar.
moderator - mag alles of de geactiveerde modules(is eigenaar website)
custom - heeft alle rechten tot modules maar maximaal die van de moderator
wat nog kan:
registered
premium registered
elke website die ik maak is in combinatie met een eigen cms. Ik heb nu een tabel users voor de gegevens van de gebruiker. Ook heb ik een tabel user_static_roles Hierin staan de standaard rollen zoals moderator of registered. In deze tabel staan de modules die beschikbaar zijn voor het cms en de website. Hierin ga ik er vanuit dat je voor de website gewoon een of twee modules maakt zoals bijvoorbeeld registered en premiumUser.
Hieronder de klasse(hij is nog niet af):
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
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
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
<?php
function isModuleActive($var)
{
//stuurt de array key alleen terug als in de value true staat.
//de array bestaat dan alleen uit actieve modules.
return ($var == 'true');
}
/* userRoles interfece
* -class isAdmin(alle rechten)
* -class isModerator(alle rechten op aangeschafte modules)
* -class isCustom(alle rechten die worden aangegeven op aangeschafte modules)
*/
interface userRoles{
public function isGranted($roleObject);
public function setUserRoleInSession($userRole);
}
class isAdmin{
public function setUserRoleInSession($userRole){
$_SESSION['userRole'] = serialize($userRole);
}
public function isGranted(){
return true;
}
}
class isModerator{
protected $userModules;
protected $db;
protected $userId;
function __construct($pdo,$userId){
$this->db = $pdo;
$this->userId = $userId;
}
public function setUserRoleInSession($userRole){
$_SESSION['userRole'] = serialize($userRole);
}
private function setActiveModules(){
$query = 'SELECT *
FROM user_static_roles
WHERE user_type=:user_type';
$smtp = $this->db->prepare($query);
$result = $smtp->execute(array(
'user_type' => 'moderator',
));
if($result){
foreach($smtp->fetchAll(PDO::FETCH_ASSOC) as $row){
$this->userModules[] = array_filter($row, "isModuleActive");
}
}
}
public function isGranted($roleObject){
$this->setActiveModules();
if(!empty($this->userModules)){
if(array_key_exists($roleObject,$this->userModules['0'])){
//tijdelijk de array printent
print_r($this->userModules);
if(in_array('true',$this->userModules['0'])){
return true;
}
}
}
}
}
class isCustomRole{
protected $userModules; //array met modules
protected $db;//database
protected $userId;
protected $userPreivileges;//array met rechten
protected $roleObject;//het object
function __construct($pdo,$userId){
$this->db = $pdo;
$this->userId = $userId;
}
public function setUserRoleInSession($userRole){
$_SESSION['userRole'] = serialize($userRole);
}
private function setActiveModules(){
$query = 'SELECT *
FROM user_roles
WHERE user_id=:userId';
$smtp = $this->db->prepare($query);
$result = $smtp->execute(array(
'userId' => $this->userId,
));
if($result){
foreach($smtp->fetchAll(PDO::FETCH_ASSOC) as $row){
$this->userModules[] = array_filter($row, "isModuleActive");
}
}
}
public function isGranted($roleObject){
$this->setActiveModules();
if(!empty($this->userModules)){
if(array_key_exists($roleObject,$this->userModules['0'])){
//tijdelijk de array printent
print_r($this->userModules);
if(in_array('true',$this->userModules['0'])){
return true;
}
}
}
}
}
/* class user
*
*/
class User{
protected $userId = null;
protected $userName = null;
protected $pass = null;
protected $userType = null;
protected $email = null;
protected $dateAdded = null;
public function setUserInSession($user){
$_SESSION['user'] = serialize($user);
}
public function getUserName(){
return $this->userName;
}
public function getuserType(){
return $this->userType;
}
public function setRoleClass($db){
switch ($this->userType){
case 'admin' :
return $user = new isAdmin();
break;
case 'moderator' :
return $user = new isModerator($db,$this->userId);
break;
case 'custom':
return $user = new isCustomRole($db,$this->userId);
break;
case 'registred':
break;
}
}
}
/* class userAuthentication
*
*/
class userAuthentication{
public static function createUserFromForm($db,$name,$pass){
$smtp = $db->prepare('SELECT id, userName, pass, userType, email, dateAdded
FROM users WHERE userName=:userName AND pass=:pass');
$smtp->setFetchMode(PDO::FETCH_CLASS, 'User');
$result = $smtp->execute(array(
'userName' => $name,
'pass' => $pass,
));
if($result){
$user = $smtp->fetch();
return $user;
}
}
public static function createUserFromSession(){
$user = $_SESSION['user'];
return unserialize($user);
}
public static function createUserRoleFromSession(){
$userRole = $_SESSION['userRole'];
return unserialize($userRole);
}
}
?>
function isModuleActive($var)
{
//stuurt de array key alleen terug als in de value true staat.
//de array bestaat dan alleen uit actieve modules.
return ($var == 'true');
}
/* userRoles interfece
* -class isAdmin(alle rechten)
* -class isModerator(alle rechten op aangeschafte modules)
* -class isCustom(alle rechten die worden aangegeven op aangeschafte modules)
*/
interface userRoles{
public function isGranted($roleObject);
public function setUserRoleInSession($userRole);
}
class isAdmin{
public function setUserRoleInSession($userRole){
$_SESSION['userRole'] = serialize($userRole);
}
public function isGranted(){
return true;
}
}
class isModerator{
protected $userModules;
protected $db;
protected $userId;
function __construct($pdo,$userId){
$this->db = $pdo;
$this->userId = $userId;
}
public function setUserRoleInSession($userRole){
$_SESSION['userRole'] = serialize($userRole);
}
private function setActiveModules(){
$query = 'SELECT *
FROM user_static_roles
WHERE user_type=:user_type';
$smtp = $this->db->prepare($query);
$result = $smtp->execute(array(
'user_type' => 'moderator',
));
if($result){
foreach($smtp->fetchAll(PDO::FETCH_ASSOC) as $row){
$this->userModules[] = array_filter($row, "isModuleActive");
}
}
}
public function isGranted($roleObject){
$this->setActiveModules();
if(!empty($this->userModules)){
if(array_key_exists($roleObject,$this->userModules['0'])){
//tijdelijk de array printent
print_r($this->userModules);
if(in_array('true',$this->userModules['0'])){
return true;
}
}
}
}
}
class isCustomRole{
protected $userModules; //array met modules
protected $db;//database
protected $userId;
protected $userPreivileges;//array met rechten
protected $roleObject;//het object
function __construct($pdo,$userId){
$this->db = $pdo;
$this->userId = $userId;
}
public function setUserRoleInSession($userRole){
$_SESSION['userRole'] = serialize($userRole);
}
private function setActiveModules(){
$query = 'SELECT *
FROM user_roles
WHERE user_id=:userId';
$smtp = $this->db->prepare($query);
$result = $smtp->execute(array(
'userId' => $this->userId,
));
if($result){
foreach($smtp->fetchAll(PDO::FETCH_ASSOC) as $row){
$this->userModules[] = array_filter($row, "isModuleActive");
}
}
}
public function isGranted($roleObject){
$this->setActiveModules();
if(!empty($this->userModules)){
if(array_key_exists($roleObject,$this->userModules['0'])){
//tijdelijk de array printent
print_r($this->userModules);
if(in_array('true',$this->userModules['0'])){
return true;
}
}
}
}
}
/* class user
*
*/
class User{
protected $userId = null;
protected $userName = null;
protected $pass = null;
protected $userType = null;
protected $email = null;
protected $dateAdded = null;
public function setUserInSession($user){
$_SESSION['user'] = serialize($user);
}
public function getUserName(){
return $this->userName;
}
public function getuserType(){
return $this->userType;
}
public function setRoleClass($db){
switch ($this->userType){
case 'admin' :
return $user = new isAdmin();
break;
case 'moderator' :
return $user = new isModerator($db,$this->userId);
break;
case 'custom':
return $user = new isCustomRole($db,$this->userId);
break;
case 'registred':
break;
}
}
}
/* class userAuthentication
*
*/
class userAuthentication{
public static function createUserFromForm($db,$name,$pass){
$smtp = $db->prepare('SELECT id, userName, pass, userType, email, dateAdded
FROM users WHERE userName=:userName AND pass=:pass');
$smtp->setFetchMode(PDO::FETCH_CLASS, 'User');
$result = $smtp->execute(array(
'userName' => $name,
'pass' => $pass,
));
if($result){
$user = $smtp->fetch();
return $user;
}
}
public static function createUserFromSession(){
$user = $_SESSION['user'];
return unserialize($user);
}
public static function createUserRoleFromSession(){
$userRole = $_SESSION['userRole'];
return unserialize($userRole);
}
}
?>
het gebruik:
de login pagina:
Code (php)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<?php
session_start();
include 'userClass.php';
$db = new PDO();
$user = userAuthentication::createUserFromForm($db,'tim','test');
$user->setUserInSession($user);
$userRole = $user->setRoleClass($db);
$userRole->setUserRoleInSession($userRole);
?>
session_start();
include 'userClass.php';
$db = new PDO();
$user = userAuthentication::createUserFromForm($db,'tim','test');
$user->setUserInSession($user);
$userRole = $user->setRoleClass($db);
$userRole->setUserRoleInSession($userRole);
?>
een andere pagina:
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
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
<?php
session_start();
include 'userClass.php';
$user = userAuthentication::createUserFromSession();
$userRole = userAuthentication::createUserRoleFromSession();
echo $user->getuserType();
// een module bijvoorbeeld news
if($userRole->isGranted('news')){
echo 'gebruiker is hier toegestaan';
}
else{
echo 'gebruiker is hier niet toegestaan';
}
//een admin pagina,kan je een module voor aankamen kan ook zo
if($userRole->isGranted('admin')){
echo 'gebruiker mag hier zijn';
}
//een pagina voor geregistreerde gebruikers
if($userRole->isGranted('registered')){
//laat hier bijvoorbeeld een menu zien
}
?>
session_start();
include 'userClass.php';
$user = userAuthentication::createUserFromSession();
$userRole = userAuthentication::createUserRoleFromSession();
echo $user->getuserType();
// een module bijvoorbeeld news
if($userRole->isGranted('news')){
echo 'gebruiker is hier toegestaan';
}
else{
echo 'gebruiker is hier niet toegestaan';
}
//een admin pagina,kan je een module voor aankamen kan ook zo
if($userRole->isGranted('admin')){
echo 'gebruiker mag hier zijn';
}
//een pagina voor geregistreerde gebruikers
if($userRole->isGranted('registered')){
//laat hier bijvoorbeeld een menu zien
}
?>
Ik ben erg benieuwd wat jij hier van vindt, ik zal dan voor het registreren een andere klasse aanmaken.
Ik kan hier zelf in elk geval alle kanten meer op, weet alleen niet zeker of het op sommige plaatsen netter kan.
Toevoeging op 18/12/2012 11:50:47:
Pdo werkt niet met serialize dus de functie setActiveModules moet je vanaf buiten aanroepen.