SQUELETTE DE GESTION DES DROITS
DiGhan
Messages postés
239
Date d'inscription
samedi 21 février 2004
Statut
Membre
Dernière intervention
3 juin 2010
-
20 déc. 2008 à 17:38
Betamax Messages postés 2 Date d'inscription mercredi 15 février 2006 Statut Membre Dernière intervention 23 décembre 2008 - 23 déc. 2008 à 00:59
Betamax Messages postés 2 Date d'inscription mercredi 15 février 2006 Statut Membre Dernière intervention 23 décembre 2008 - 23 déc. 2008 à 00:59
Cette discussion concerne un article du site. Pour la consulter dans son contexte d'origine, cliquez sur le lien ci-dessous.
https://codes-sources.commentcamarche.net/source/48756-squelette-de-gestion-des-droits
https://codes-sources.commentcamarche.net/source/48756-squelette-de-gestion-des-droits
23 déc. 2008 à 00:59
de cette façon je pousse un peu plus loin dans le degrés d'autorisation.
Je me lance dans les designs pattern (d'ailleurs tu as posté de très bon tuto :) ) mais but dans la manière de procéder pour la construction de divers objets différent (factory) avec accès à plusieurs tables (multiton) et gestion des droits pour certains objets (masque binaire) (user , image ,file etc...)... dur dur.
surtout que je n'ai pas beaucoup de temps :(
merci @ bientôt
22 déc. 2008 à 21:49
Betamax : dans un environnement "simple", en restant à 1 niveau de droits, on reste bloqués à 32 possibilités (à moins d'avoir un serveur 64 bits évidemment). Ca n'empêche pas de moduler tout ça : un module, 32 droits...donc un projet, X fois 32 droits. Ca devrait suffire...
Utilisation des objets : ça fait potentiellement bcp d'objets, et ce n'est pas forcément optimal en terme de perf. Tout dépend de la façon dont s'est utilisé...et de savoir si la légère perte en perf vs la très large "scalability", l'évolutivité, etc...n'en vaut pas la chandelle, au final (moi, je suis un convaincu...).
Les droits "binaires", c'est bien, mais on s'y perd vite si on ne gère pas ça correctement (bordel, 100101 ça correspond à QUOI????). Pareil pour les entiers (hmmm...57, donc...voué voué voué...le gars y peut s'logger...ah non, c'est de l'écriture pplus du log plus l'accès en consultation à cette partie du module...ah nan...merde, chais plus).
C'est difficile à débugger pour la même raison.
Enfin, en l'état, c'est insuffisant. Enfin...c'est suffisant pour un petit projet, ça ne l'est pas pour un gros. Il faut moduler plus, réfléchir intensément aux accès, aux groupes d'accès, aux profils utilisateur etc...et faire bien les choses de manière à pouvoir ajouter de nouveaux types d'accès par la suite. Mais ça...c'est après tout le lot commun de tout gros projet :-)
Globalement, je pense que la gestion des droits via les opérateurs binaires est plutôt une approche performante. Et elle est élégante, et permet une programmation "agile" si on s'y prend bien. Mais il y a d'autres solutions...
22 déc. 2008 à 13:19
22 déc. 2008 à 08:41
par cette note ,je voudrai simplement dire bravo à notre cher malalam que nous apprécions beaucoup mais ça serai cool si tu nous disait ou son les inconvénients dans cette approche .
merci également à CS et à tous ceux qui y contribuent .
21 déc. 2008 à 19:14
@Opossum_farceur : c'est presque trop technique pour moi... Presque, hein... Disons que j'ai tellement peu l'habitude d'utiliser les opérateurs sur les bits, que j'ai un peu de mal à me représenter quel est le résultat, quand m'en servir et surtout, comment ça marche...
Comment ça marche, je sais : quand je mets sur papier... Faut que je fasse des tableaux, tout ça... Je m'embrouille vite... Donc je plussoie au commentaire de Malalam : un petit tuto, ça pourrait être une super bonne idée, parce qu'effectivement, j'en étais arrivé à la même conclusion que lui quant à l'utilisation des opérateurs de bits par les jeunes développeurs.
@Malalam : pour la mail, je viens de m'y coller... C'est à ton tour. ^^
Sinon, excuse-moi d'avoir soulevé le point que tu ne souhaitais pas aborder lol Je prends ça comme un compliment sur ce coup là :) Et... Cette discussion naissante sur ce sujet que tu ne voulais pas montrer, ben... Ca confirme le bien fondé de notre projet (pu*$€ ça fait pas un an qu'on a commencé à en parler, mais pas loin !)
Allez, zou, bonne soirée à tous !
21 déc. 2008 à 12:05
Salut Olivier!
Ca fait un bail en effet...je suis toujours à ta dispo pour notre petit projet, dès que tu auras le temps (j'en manque aussi, rassure-toi...plus que jamais!)
Bon...
Dighan : alternative sympa en effet! Merci pour ta contribution. Elle a le mérite de montrer un peu plus l'utilisation des opérateurs "bitwise". Et elle est plus courante que la mienne :-)
Opossum_farceur : merci aussi pour ta contribution, et ce rappel...qui risque d'être une sacrée nouveauté pour beaucoup :-) Je me suis mal exprimé quand je disais "peu utilisés [les opérateurs bit à bit] par la plupart des codeurs php" : j'aurais dû préciser les codeurs débutants, voire amateurs. Et du coup, je serais toi, j'expliquerais un peu plus tout ça...un tuto serait peut-être le bienvenue, avec des exemples appliqués concrets, sur l'utilisation de ces opérateurs.
Neige : un chtit mail ? :-) Ceci dit : je m'oriente de plus en plus vers les projets composés de nombreuses classes, dont beaucoup sont petites et utilitaires, plus quelques moteurs utilisant ces classes utilisateur. Je me rends compte que c'est bien plus facile à faire évoluer et à utiliser que des projets composés de grosses classes qui font tout...je t'enverrai un exemple d'un framework que j'ai monté il y a peu (et que je ne peux pas mettre ici...car il est vendu, et cher, par ma boîte, aussi je compte sur ton intégrité :-) garde le pour toi!) et qui montre mon orientation objet. En effet, ici ce n'est qu'un squelette, et en utilisation réelle, les classes doivent être remplies un peu plus. En fait je vais même plus loin, en utilisation réelle...je complèterai sans doute un jour, mais sur un projet plus concret que je peux divulguer ici. Le but étant, dans un environnement complexe de type ERP, avec énormément d'utilisateurs aux profils très différents, de gérer facilement leurs accès, et d'inventer de nouveaux profils au fil de l'eau.
Bref, ce choix de code "prétexte" n'était pas si anodin que ça :-) C'est une vraie réflexion de ma part ces temps-ci...et tu as vu ce que je ne comptais pas montrer au fond : je pensais qu'on allait se concentrer sur les opérateurs "bitwise", car c'est le but de ce code sur phpcs, mais au fond, il y a autre chose, pour moi... :-)
21 déc. 2008 à 01:50
Petite piqure de rappel (indolore!) sur les "masques".
En considérant que le bit de poids faible a le rang 0,
Lecture du bit $bit de la variable $var :
echo ($var>>$bit)&1;
Mise à 1 du bit $bit de la variable $var :
$var|=(1<<$bit);
Mise à 0 du bit $bit de la variable $var :
$var&=~(1<<$bit);
20 déc. 2008 à 21:12
Salut Boss, ça fait un bail !
Ca me fait plaisir de voir que je suis pas tout seul à utiliser les opérateurs binaires pour gérer des droits... Je les ai découvert dans phorum.org , alors que phpBB (j'étais très forum à l'époque...) utilisais un système très peu évolutif (et qui ne me semble pas avoir été beaucoup amélioré avec la version 3, mais là n'est pas la question).
Par contre, j'apprécie l'utilisation d'objets pour chaque permission... C'est une approche à laquelle je n'avais pas pensé (merci donc de l'avoir fait pour moi). Ca me perturbe un peu, d'ailleurs... En même temps, c'est bien plus Orienté Objet... Plus qu'avec des constantes (je ne critique pas, hein, puisque j'ai tendance à utiliser des constantes également...).
Du coup... Si on veut gérer davantage de permissions (parce que là, c'est quand même archi simple), ça fait autant de classes que de permissions... Cependant (c'est un sujet à creuser) on doit pouvoir utiliser des classes plus complexes (héritages, tout ça tout ça)... C'est une approche qui me plait, quoi...
C'est vrai que si j'utilise pas mal d'objets, finalement, je n'en utilise peut-être pas suffisament...
20 déc. 2008 à 17:38
En complément (dans le fond exactement pareil mais qui présente des subtilités) :
<?php
define('RIGHT_READ' , 1);
define('RIGHT_WRITE', 2);
define('RIGHT_EXEC' , 4);
abstract class User
{
protected $iRights = 0;
public function isAllowedToRead() {
return (($this->iRights & RIGHT_READ) === RIGHT_READ);
}
public function isAllowedToWrite() {
return (($this->iRights & RIGHT_WRITE) === RIGHT_WRITE);
}
public function isAllowedToExec() {
return (($this->iRights & RIGHT_EXEC) === RIGHT_EXEC);
}
}
class Guest extends User
{
public function __construct() {
$this->iRights = RIGHT_READ;
}
}
class Member extends User
{
public function __construct() {
$this->iRights = RIGHT_READ | RIGHT_WRITE;
}
}
class Admin extends User
{
public function __construct() {
$this->iRights = RIGHT_READ | RIGHT_WRITE | RIGHT_EXEC;
}
}
$oGuest = new Guest;
$oMember = new Member;
$oAdmin = new Admin;
var_dump($oGuest->isAllowedToRead());
var_dump($oGuest->isAllowedToWrite());
var_dump($oGuest->isAllowedToExec());
var_dump($oMember->isAllowedToRead());
var_dump($oMember->isAllowedToWrite());
var_dump($oMember->isAllowedToExec());
var_dump($oAdmin->isAllowedToRead());
var_dump($oAdmin->isAllowedToWrite());
var_dump($oAdmin->isAllowedToExec());
?>