Discussion :

[sfxElrick]

bonjour,

je dois ajouter a mon appli une gestion de droits d'utilisateurs (de l'appli) et je sais pas trop par ou prendre le probleme.
le but etant de permetter ou plutot d'interdire un utilisateur de l'appli tout ou partie des fiches / boutons selon les droits qui lui sont donnés. le tout en offrant une certaine souplesse a cette gestion des droits.

je pensais procéder ainsi:
ds ma table utilisateurs, je stock les droits dans un camp 'droits'

ds ma classe utilisateur j'ai un truc du style:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
 
TDroits = (dNone,dModifContrats,dSupprContrat ....);
TDroitsUtilisateurs = set of TDroits;
TUtilisateur = class
...
private
FDroits : TDroitsUtilisateurs;
...
published
property Droits : TDroitsUtilisateurs read FDroits right FDroits;
...
end;

et pour verifier si le mec a le droit:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
...
if dModifContrat in Utilisateur.Droits then
 //ok il a le droit
else
 //non il a pas le droit
...

le soucis c'est que le fait d'ajouter une nouvelle fiche me forcera a ajouter un dDroitSurlanouvellefiche (par exemple) ce qui est pas tres pratique de mon pts de vue.
(surtout que j'ai pas mal de fiches / boutons un peu partout donc c'est pas super pour maintenir tt ça)

idem pour la fiche d'attribution des droits, si j'ajoute un nouveau droit faudrais que la modif se repercute dynamiquement
(voir si je peut ajouter un commentaire a chaque valeur du Type TDrois pour le texte associé, je sais que c'est possible en c# par contre en delphi j'en sai rien)

donc voila
si vous avez des idées, des suggestions, elles sont les bienvenues.
(ou avez vous meme mis en place une gestion de droits ds vos applis)

merci d'avance

Elrick.

ps: question bonus, comment on stock une variable de type 'Set of' ds un champ de base de donnée (access) ?

[Bob Deuxfleurs]

tu peut par exemple créer une fiche de base dont hériterons toutes les fiches de ton application, il te suffit alors de gérer les droits dans cette fiche de base.

[sfxElrick]

j'y ai pensé, mais ça resoud pas tt les problemes
en particulier celui de l'attribution des droits a l'utilisateur

ex:
utilisateur toto
droits:
peut supprimer un contrat (dCanDelete_Contrat)
peut supprimer une intervention (dCanDelete_Intervention)
peut supprimer une facture (dCanDelete_Facture)

si j'ajoute une nouvelle fiche, l'heritage me permet de voir a la creation par exemple si l'utilisateur a le droit de l'ouvrir,
mais c'est plus simple en terme de code de faire l'inverse:
verifier quand l'utilisateur clic sur un bouton, si il a le droit de faire l'action associée (supprimer un contrat par exemple) ou meme de desactiver le bouton le cas echeant.

par contre l'heritage d'une 'TRestrictedForm' par exemple m'offre pas grand chose comme marge de manoeuvre,
il faudra quand meme que je rajoute le dCanOpen_MaNouvelleForm ds le set de droits
enfin bref c pas la solution miracle :p

[sfxElrick]

d'ailleur j'pense que je vais m'orienter sur une gestion de droits restrictive, plutot que permissive

sera plus simple de faire un 'droit a tout sauf ce qui est interdit', plutot qu'un 'droit a rien sauf ce qui est autorisé'

[Jean44]

un 'droit a tout sauf ce qui est interdit', plutot qu'un 'droit a rien sauf ce qui est autorisé'

Hmmm... c'est un peu le distingo Windows/Linux on dirait...

[sfxElrick]

tout a fait
mais comme il faut que je prenne en compte la constante 'utilisateur de base pas ou peu receptif au formations données', je pense que tt autorisé sauf ce qui est interdit est mieux (j'aurais moin d'appel du style: pkoi j'peux pas faire ça ?)

[Pedro]

Salut
Ok si j'ai bien compris, j'ai plusieurs solution:

Tu mets un variable droits sur ta fiche utilisateur.
Dans les fiches qui doivent s'afficher ou non, tu crées une petite fonction du style:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
procedure Execute(Droits:TDroits);
begin
  if Droits=LeDroitQuIlFaut then ShowMoadl else
    MessageDlg('Vous n''avez pas les droits nécessaires pour afficher cette fiche',mtInformation,[mbok],0);
end;

Comme ça, à chaque fois que tu lances ta fiche, tu appelles cette procédure en passant les droits de l'utilisateur en paramètre et c'est elle (la fiche) qui vérifie si elle peut s'afficher ou non...

Autre solution, Tu crées une variable de type TDroits en public dans ta fiche utilisateur.
Dans chaque fiche à afficher ou non, tu mets une constante du type DroitsRequis que tu initialises à la valeur du droit requis pour l'affcher.
Ensuite, même principe:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
procedure Execute;
begin
  if Main.Droits=DroitsRequis then ShowModal else
    MessageDlg('Vous n''avez pas les droits nécessaires pour afficher cette fiche',mtInformation,[mbok],0);
end;

Voilà, j'espère que ça pourra t'aider

[Laurent Dardenne]

ex:
utilisateur toto
droits:
peut supprimer un contrat (dCanDelete_Contrat)
peut supprimer une intervention (dCanDelete_Intervention)
peut supprimer une facture (dCanDelete_Facture)

Si tu utilises une base de donnée pourquoi ne pas s'appuyer sur les droits du SGBDR ? Dans ce cas tu ne géres que les accés au menu.

[qi130]

Dans 1 petite appli, j'avais mis en place un truc économique:
- la propriété Tag des objets à protéger reçoivent une valeur correspondant à une classe de protection (pas un niveau fonctionnel de protection)

- chaque utilisateur de l'appli est habilité sur la ou les classes souhaitées

le résultat de cette habilitation est un nombre = somme des 2 puissance(classe habilitée)

ex: habilité sur les fonctions de classes 0, 2 et 5 => 1+4+32=37

quand l'utilisateur se signe, je récupère ce 37, je le décompose pour récupérer 0,2 et 5 puis, je désactive les compo dont le tag n'est pas dans cet ensemble de valeurs.

j'applique cette mécanique sur les options de menu de ma form principale, mais rien n'interdit de descendre au niveau des boutons et des TEdits.

[sfxElrick]

@pedro: j'avais pensé a ça effectivement

@laurent: hmm j'y ai pensé aussi, mais les droits access ... enfin bon j'sais pas faire ça.
en plus j'pensais faire une sorte de mot binaire avec un masque ds l'appli pour trouver le bit qui correspond au droit

(j'suis pour l'instant parti sur un set of ... mais j'sais pas comment stoqué cte chose ds un champ ! :p)

[sfxElrick]

@qi130: houais en gros tu utilise une variable et un masque pour trouver si le bit qui caracterise ton droit d'acces est a 0 ou a 1 non ?

genre:
const
droitspourlire = 0x01;
droitpourecrire = 0x02;

mesdroits = 2
donc si j'applique le masque droitpourlire avec mes droits actuels, ça renvoie false, parce que j'ai pas les droits

0x01 => 0001
0x02 => 0010
2 => 0x02 => 0010
0001 & 0010 = 0000 j'ai pas le droit d'ecrire
0001 & 0001 = 0001 je peux lire

si par contre j'ai mesdroits = 3

0x01 => 0001
0x02 => 0010
3 => 0x03 => 0011
0011 & 0010 = 0010 je peux ecrire
0011 & 0001 = 0001 je peux lire

c'est du calcul binaire de base

[Higgins]

L'idéal est d'attribuer les droits en fonction des classes. Tu définis les droits, puis un tableau de droits avec autant d'entrées que de classes;

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
type droit=(ajouter,supprimer,editer);
       droits=set of droit;
        tdroits: array[1..4] of droits;

Dans ta classe utilisateur tu définis une propriété autorisation

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
    fautorisation:tdroits
public
   property autorisation:tdroits read fautorisation write fautorisation;

pour chaque classe tu définis son index dans le tableau et tu peux ensuite coder des trucs du style

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
if [supprimer] in utilisateur.autorisation[contrat.index] then      contrat.delete;
if [supprimer] in utilisateur.autorisation[intervention.index] then      intervention.delete;
etc...

[sfxElrick]

@higgins: ça c'est pas bete du tout et ça m'a l'air bien flexible du pts de vue de l'ajout de nouvelles fiches. pas besoin de devoir creer 50 type de droits
juste verifier.

reste plus qu'a trouver comment stoquer le tout ds un champ
(ou sinon faut que je recreer une table droits utilisateurs avec une clé etrangere pointant sur l'id de l'utilisateur)

et voir comment on peut faire pour la fiche d'attribution des droits

merci higgins (merci a tt les autres aussi d'ailleur ! :p)

[qi130]

@qi130: houais en gros tu utilise une variable et un masque pour trouver si le bit qui caracterise ton droit d'acces est a 0 ou a 1 non ?
...
c'est du calcul binaire de base

Oui! j'ai bien parlé d'un truc économique

Mais ça permet de sortir du traditionnel modèle gigogne
READ/CREATE/UPDATE/DELETE qui lui est très binaire

Ainsi, l'administrateur-responsable de l'appli peut:
1/ décréter les fonctions sensibles de manière fine (éditer un chèque est + sensible qu'éditer une liste de clients, et pourtant c'est de l'édition)
2/ habiliter tout aussi finement les utilisateurs de base

[Higgins]

juste verifier.

Pas besoin de vérifier, je confirme que cela fonctionne(depuis plusieurs années)

(ou sinon faut que je recreer une table droits utilisateurs avec une clé etrangere pointant sur l'id de l'utilisateur)

C'est comme çà que je fais 8)

et voir comment on peut faire pour la fiche d'attribution des droits

lors de la création de l'instance d'utilisateur par exemple

[sfxElrick]

mais ta réponse a tout ma parole !! :p

[sfxElrick]

bon la solution est proche, donc je commence a retranscrire ce que j'ai fait ici, si ça peut aider quelqu'un

alors on commence:

Avant propos:
1 - je ne detient pas la verité universelle, je n'offre donc pas une solution miracle pour gerer les droits d'utilisateurs, mais seulement mon approche du probleme dans le cas qui me concerne, cet a dire la mise en place d'une gestion de droits dans l'application que je développe
2 - je suis tjrs en train de developper cette partie donc, il est fort probable que certaines parties soient aberantes ou deviennent inutiles par la suite.
3 - si vous avez des remarques, faites en sorte qu'elles soit constructives, je prend le temps de partager mes travaux, ce n'est pas pour me faire pourrir sur un detail

vous pouvez lire mon post sur la 'gestion' d'un ensemble Set Of si necessaire pour comprendre certaine parties.

but:
offrir a mon appli une gestion de droits d'utilisateurs, suffisament souple pour pas me faire chier dans le futur si j'ajoute de nouvelles fiches necessitant des droits d'utilisateurs spécifiques. chaque droits utilisateurs devant etre stoqués dans une base de donnée.

bien que la mise en place semble lourde, l'utilisation au final me semble assez simple et la mise a jour pour l'ajout de nouvelles parties tout aussi simple.

definition des droits utilisables:
dans la pluipart des cas, les actions de l'utilisateur sont les suivantes:
ajout,modification,suppression.

mais il arrive que pour certaines parties (gestion de contrats par exemple) il soit ammené a 'renouveller' ou (pour une gestion d'appels clients) a 'cloturer' ou 'traiter'.
on a donc une liste de droits 'généraux" suivants:
ajouter, modifier, supprimer, cloturer, traiter, renouveller.

ce qui me donne:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
...
type
 TDroitsGeneraux = (dgAjout, dgModification, dgSuppression, dgCloture, dgTraitement, dgRenouvellement);
 TRestrictions = set of TDroitsGeneraux;

ps: on rajoute au passage un type TRestrictions qui est un ensemble de TDroitsGeneraux pour stoquer les droits applicables a une partie restreinte de l'application.

viens ensuite la partie gerant une partie restreinte.
TRestrictedPart donne le modele de restriction a l'application, elle lui fournit un identifiant unique (a la charge du developpeur), un nom court, un nom long et une liste de restrictions applicables (pour la construction dynamique des fiches d'attribution des droits par exemple).

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
  TRestrictedPart = class
    private
      FGUID : integer;
      FShortName : string;
      FName : string;
      FRestrictions : TRestrictions;
    public
      constructor Create(iGUID : integer; sShortName : string; sName : string ; eRestrictions : TRestrictions);
    published
      property GUID : integer read FGUID;
      property ShortName : string read FShortName;
      property Name : string read FName;
      property Restrictions : TRestrictions read FRestrictions;
    end;

pour l'instant les propriétés sont en lecture seule, initialisées a la création
(rien de bien compliquer ds le constructeur donc)

ensuite il me faut quelque chose pour contenir toute les definitions des parties restreintes, comme ça tout est stoqué dans un meme objet c'est plus simple a gerer apres.

j'ai donc creer une class TRestrictedZone sur le modele suivant:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
  TRestrictedZone = class
    private
      FRestrictionList : TObjectList;
    function GetRestrictedPartIndex(index: integer): TRestrictedPart;
    function GetCount: integer;
    public
      constructor Create;
      procedure Add(RestrictedPart : TRestrictedPart); //ajout d'une partie restreinte
      function RestrictedPartByShortName(shortname : string): TRestrictedPart; //recuperer un partie restreinte par son nom court
 
      property Restrict[index : integer] : TRestrictedPart read GetRestrictedPartIndex; //acces au restrictedparts
    published
      property Count : integer read GetCount; //nombre d'elements restrictedpart dans le tobjectlist
    end;

comme vous pouvez le voir la classe contient un containeur d'objet
on va donc le remplir a la creation de l'objet:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
procedure TRestrictedZone.Add(RestrictedPart: TRestrictedPart);
begin
  FRestrictionList.Add(RestrictedPart);
end;
 
constructor TRestrictedZone.Create;
begin
  FRestrictionList := TObjectList.Create(True);
  self.Add(TRestrictedPart.create(1,  'RESTRICT_APPELS','Gestion des appels',
                                      [dgAjout, dgModification, dgSuppression, dgCloture, dgTraitement])); // par exemple
//la , la partie de restriction des appels permet une gestion des droits sur l'ajout, la modification, la cloture, et le traitement d'un appel. pas de renouvellement donc
  self.Add(TRestrictedPart.create(2,  'RESTRICT_CONTRATS','Gestion des contrats',
                                      [dgAjout, dgModification, dgSuppression, dgRenouvellement]));
//idem pour la gestion des contrats, on peut gerer l'ajout, la modification la suppression, le renouvellement, mais pas la cloture ni le traitement.
...
//etc pour tte les parties restreintes.
end;

bon ok c'est bien beau tout ça, mais ou ça nous mene ?
pour l'instant on a mis en place les bases
mais il nous manque de koi stoquer les droits utilisateurs, de quoi transcrire ces droits en quelque chose de stockable dans une base de donnée
et une ptit manager pour faire tt le travail a notre place.

pour ce qui est du manager, j'ai ecrit une methode faisant la transcription entre un element de TDroitsGeneraux et une chaine de caracteres qui va me servir pour la creation dynamique de mes fiches de saisie des droits d'un utilisateur.
en plus elle me renvoi l'element le plus petit de ma liste de droits et le plus grand (comprendre le premier et le dernier) pour le parcour des ensembles de droits.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
type 
...
    TDroitsManager = class
      public
        //methodes statiques
        function DroitToString(droit : TDroitsGeneraux):string;
        function DroitToIdent(droit : TDroitsGeneraux; var ident : string): boolean;
        function Lowest: TDroitsGeneraux;
        function Highest: TDroitsGeneraux;
      end;
 
...
const
 
  MAP_DROITSGENERAUX : array[0..5] of TIdentMapEntry =
  (
    (Value : ord(dgAjout);          Name : 'Ajouter'),
    (Value : ord(dgModification);   Name : 'Modifier'),
    (Value : ord(dgSuppression);    Name : 'Supprimer'),
    (Value : ord(dgCloture);        Name : 'Cloturer'),
    (Value : ord(dgTraitement);     Name : 'Traiter'),
    (Value : ord(dgRenouvellement); Name : 'Renouveller')
  );
...
 
{ TDroitsManager }
 
function TDroitsManager.DroitToIdent(droit: TDroitsGeneraux;
  var ident: string): boolean;
begin
  result := IntToIdent(ord(Droit),ident,MAP_DROITSGENERAUX);
end;
 
function TDroitsManager.DroitToString(droit: TDroitsGeneraux): string;
begin
  if not(DroitToIdent(droit,result)) then
    FmtStr(Result, '%s%.8x', [HexDisplayPrefix, ord(droit)]);
end;
 
function TDroitsManager.Highest: TDroitsGeneraux;
begin
  result := high(TDroitsGeneraux);
end;
 
function TDroitsManager.Lowest: TDroitsGeneraux;
begin
  result := low(TDroitsGeneraux);
end;

voila, avec ça, j'peux creer sur une fiche autant de feuilles que de zones restreintes, et sur chaque feuilles, autant de checkbox que de droits attribuables.
le tout modifiable a souhait
en effet si je veux rajouter un droit de base, il me faut juste modifier TDroitsGeneraux et MAP_DROITSGENERAUX

si je veux ajouter une zone restreinte, il me faut juste ajouter une ligne
FRestrictionList.add(....); ds le Create de TRestrictedZone.

un ptit bout de code pour donner un exemple de creation dynamique d'une fiche pour la saisie des droits d'un utilisateur:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
procedure TForm1.Button1Click(Sender: TObject);
var
  toto : TRestrictedZone;
  cb : TCheckBox;
  lbl : TLabel;
  i : integer;
  offset : integer;
  j : TDroitsGeneraux;
  manager : TDroitsManager;
begin
 
  toto := TRestrictedZone.Create;
  offset := 0;
  for i := 0 to toto.Count -1 do
  begin
    lbl := TLabel.Create(self);
    lbl.Parent := self;
    lbl.Top := offset*20+10;
    lbl.left := 10;
    lbl.Caption := toto.Restrict[i].name;
    lbl.Name := toto.Restrict[i].ShortName;
    lbl.ClientWidth := self.Canvas.TextWidth(lbl.caption)+20;
    for j := manager.Lowest to manager.highest do
    if j in toto.Restrict[i].Restrictions then
    begin
 
      inc(offset);
      cb := TCheckBox.Create(self);
      cb.Parent := self;
      cb.Top := (20*offset+10);
      cb.Left := 10;
      cb.Caption := manager.DroitToString(j);
      cb.ClientWidth := self.Canvas.TextWidth(cb.caption)+20;
      cb.Name := format('%s_%s',[toto.Restrict[i].ShortName,manager.DroitToString(j)]);
    end;
    inc(offset);
  end;
  toto.Free;
end;

en gros, on parcour toutes les zones restreintes de toto, et on cree un TLabel lui correspondant, ensuite pour chaque droits applicables de la zone restreinte en cour, on cree une checkbox correspondant au droit .

voila rien de bien compliquer pour l'instant
reste plus qu'a implementer les parties necessaire a la gestion des droits d'un utilisateur dans une classe TUtilisateur par exemple
avec sauvegarde ds une base de donnée

et a mettre une verification au points le necessitant dans l'application.
voila, pour l'instant c'est un premier jet, ya surement des points obscure, que je me ferais le plaisir d'expliquer si on me le demande

Remerciements :
(dans le desordre)
Higgins, qi130, Laurent Dardenne,
Pedro204, Bob Deuxfleurs, octal,
thewho, et tt les autres.

stay tuned pour la suite
Elrick.

[ALEX77]

As-tu pensé à l'utilisation des TActions ?

Chaque TAction contient les propriétés suivantes :
-Caption
-Hint
-Tag

Dans le Caption on met le titre de la commande (qui apparait dans un menu, un bouton etc...) dans le hint la description qui sert à la bulle d'aide.

L'idée est la suivante : créer une liste chargée à partir d'un fichier qui contient les noms des actions autorisées. Le tout est affiché dans un TListView ou autre avec les colonnes suivantes :
-Description (utiliser TAction.Hint)
-case à cocher pour autoriser ou non l'action

On doit d'abord énumérer les TActions de la fiche principale pour les lister dans le TListView qui rescence les autorisations pour les différentes actions. Puis à partir de là, on charge le fichier et on examine chaque ligne : chacune contient un nom d'action autorisée que l'on coche à true dans le TListView.

Voilà pour moi comment je vois les choses.