Discussion :

[ShaiLeTroll]

Au préalable à la création de la Forme il faudrait déjà que les boutons soient tous désactivés

Justement non, le LEFT JOIN retourne tous les boutons certains avec leur Groupe et certain avec un NULL assimilé à un Zéro et pour cela il faut écrire une jointure de type LEFT JOIN
Si un bouton est absent de la table BUTTONS c'est qu'il n'est pas soumis aux droits donc implicitement actif, seul les boutons limités d'accès peuvent être mis dans BUTTONS mais pour une vision à long terme, autant tous les mettre, cela fonctionnera aussi bien, juste qu'il y aura plus de données dans les tables et il est donc impératif que Enabled soit affecté systématique à partir des tous les boutons de la table BUTTONS
D'ailleurs, le test peut être inversé, on sait que l'on interdit le NULL donc suffit de tester IsNull au lieu du AsLargeInt

Code :

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

1
2
3
4
       variableButton:= TButton(FindComponent(FDQuery1.FieldByName('ButtonName').AsString));
       if variableButton is TButton then
         variableButton.Enabled := not FDQuery1.FieldByName('ID_GROUPE').IsNull;
       FDQuery1.Next;

Après la structure des tables n'est pas parfaite, je n'aurais pas mis le groupe dans la table USERS mais dans une table USER_GROUP lié par le GroupID à DROITS_BOUTON cela permet ainsi qu'un utilisateur puisse appartenir à plusieurs groupes.
N'oublier pas ensuite l'écran d'administration des droits, il faut bien que l'admin puisse voir toutes les FORMS et tous les BUTTONS de l'application, leur nom mais aussi un commentaire
Cet écran d'administration lancé en mode développeur lui permettrait de déclarer de nouveau bouton (voir si l'on est courageux, un petit scan des DFM)


On pourrait prendre le partie inverse de lancer une requête pour vérifier chaque bouton mais évidemment, nous voyons tous la lourdeur à l'exécution

[ShaiLeTroll]

La dernière question reste pour moi:
Comment créer le nombre binaire grâce aux permission qui ont été donnés aux boutons Dans le cas où j'utilise la méthode du Paul TOTH

Cette question a déjà eu la réponse,
Vous devriez commencer par faire l'écran d'administration, recensez les FORMS et BUTTONS,
Il faut d'abord que chaque bouton ait son numéro de 1 à 80 (voire 1 à 256)
soit par table comme dans la solution à jointure
soit via une énumération (forcé là dès le début à 32 octets, ça évitera de se poser des questions) et un tableau par exemple Buttons_DESC
Vous verrez une fois que l'écran d'administration sera écrit, la gestion des droits par fenêtre vous semblera d'une très grande simplicité

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
 
type
  TBoutons = (bbouton1, bbouton2, bbouton4, bbouton5, ..., bboutonFin = 256); // une autre méthode avec SizeOf mais on va faire simple pour commencer // https://www.developpez.net/forums/d310303/environnements-developpement/delphi/recuperer-1-element-d-set-of/#post1930229
  TDroits = set of TBoutons; // 256 bits donc 32 octets, c'est le max d'un ensemble
const
  Buttons_DESC: array[TBoutons] of record 
    FormTitle: string;
    BoutonCaption: string;
  end =
    (
      ((*bbouton1*) FormTitle: 'Première Fenêtre'; BoutonCaption: 'Premier Bouton'),
      ((*bbouton2*) FormTitle: 'Première Fenêtre'; BoutonCaption: 'Premier Bouton'),
      ((*bbouton3*) FormTitle: 'Seconde Fenêtre'; BoutonCaption: 'Ajouter'),
      ((*bbouton4*) FormTitle: 'Seconde Fenêtre'; BoutonCaption: 'Modifier'),
      ((*bbouton5*) FormTitle: 'Seconde Fenêtre'; BoutonCaption: 'Supprimer'),
      ... 256 éléments au total avec un bourrage,
      ((*bouton254*) FormTitle: ''; BoutonCaption: ''),
      ((*bouton255*) FormTitle: ''; BoutonCaption: ''),
      ((*boutonFin*) FormTitle: ''; BoutonCaption: ''(*Si l''on atteint ce stade, faudra tout repenser*)),

L'écran d'administration, il faut un champ pour choisir l'utilisateur, un champ pour lui affecter un groupe
il faut aussi une List avec CheckBox pour cocher pour le groupe les droits // http://docwiki.embarcadero.com/Libra....TCheckListBox
La liste utilisera Buttons_DESC pour se remplir

la lecture rien de plus simple

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
 
var
  bouton: TBoutons ;
  Droits: TDroits ;
begin
  Droits := LoadDroitsFromQuery(FDQuery1): TDroits; // FDQuery1 liste les droits d'un groupe
  for bouton := Low(bouton) to High(bouton) do // voir aussi la syntaxe for in 
  begin
    if Buttons_DESC[bouton].FormTitle = '' then
      Exit; // Ouais un peu moche mais bon
 
    CheckListBox.Items.Add(Format('%s : %s', [Buttons_DESC[bouton].FormTitle, Buttons_DESC[bouton].BoutonCaption]);
    CheckListBox.Checked[Ord(bouton)] := bouton in Droits;
  end;
end;

l'écriture c'est pas plus difficile

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
var
  bouton: TBoutons ;
  Droits: TDroits ;
begin
  Droits := [];
  for bouton := Low(bouton) to TBoutons(CheckListBox.Items.Count - 1) do // voir aussi la syntaxe for in 
    if CheckListBox.Checked[Ord(bouton)] then
     Include(Droits, bouton);
 
  BindDroitsIntoQuery(FDQuery1, Droits);
  FDQuery1.Execute // c'est un 'UPDATE DROITSBOUTON  SET BOUTON = :pDROITS  WHERE GROUP = :pGroupID';
end;

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
procedure BindDroitsIntoQuery(AQuery: TFDQuery; ADroits: TDroits);
begin
  with AQuery.ParamByName('pDROITS') do
  begin
    DataType := ftBlob;
    AsStream := TMemoryStream.Create();  // FireDAC takes ownership of the stream object // http://docwiki.embarcadero.com/RADStudio/Sydney/en/Support_for_Blob_Streaming_in_FireDAC
    AsStream.Write(ADroits, SizeOf(ADroits));
    AsStream.Seek(0, soBeginning); // a voir si c'est nécessaire ou pas, je ne connais pas FireBird ni FireDAC 
  end;
end;

Pour le chargement via un petit BLOB ou un champ de BIT si ça existe dans FireBird

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
 
function LoadDroitsFromQuery(AQuery: TFDQuery): TDroits;
begin
  with AQuery.FieldByName('DROITS') as TBlobField do
  begin
    S := TMemoryStream.Create();
    try
      SaveToStream(S);
      S.Seek(0, soBeginning); // pas obligatoire avec le Move mais le Read c'est plus propre
 
      // Move(PByte(S.Memory)^, Result, SizeOf(Result)); // http://docwiki.embarcadero.com/Libraries/Sydney/en/System.Move
      S.Read(Result, SizeOf(Result)); // ni vu ni connu le binaire dans le set, c'est simplissime
    finally
      S.Free()
    end;
  end; 
end;

ensuite dans chaque fenêtre, faut juste gérer les droits spécifiques

Avec l'exemple de Buttons_DESC
// Première Fenêtre

Code :

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

1
2
3
4
5
6
7
8
9
10
 
var
  Droits: TDroits;
begin
   ...
  Droits := LoadDroitsFromQuery(FDQuery1);// FDQuery1 liste les droits d'un utilisateur
  btnModifierEnabled := bbouton1 in Droits ;
  btnSecond.Enabled := bbouton2 in Droits ;
 
end;

// Seconde Fenêtre

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
var
  Droits: TDroits;
begin
   ...
  Droits := LoadDroitsFromQuery(FDQuery1);
  btnAjouter.Enabled := bbouton3 in Droits ;
  btnSecond.Enabled := bbouton4 in Droits ;
  btnSupprimer.Enabled := bbouton5 in Droits ;
 
end;

[SergioMaster]

Je vous ai déjà indiqué comment moi je ferais.

Chaque bouton aura une valeur de tag défini, plus facile qu'un ordre qui peut changer.
Ensuite j'utiliserai les soit les 2ⁿ soit les (1 SHL n)
exemple pour mettre les boutons 1, 2 et 4 (tags égal aux numéros des composants) soit les valeurs 1,2,8
DROIT:=2^1-1 AND 2^2-1 AND 2^4-1; // soit 2⁰ AND 2¹ AND 2³
// soit 1 AND 2 AND 8
donc 11

le test hors BDD


le code (volontairement j'ai décomposé les calculs)

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
uses System.Math;
{$R *.dfm}
 
procedure TForm3.Button6Click(Sender: TObject);
var bit,i : Integer;
    Droit,ValeurBit : Int64;
begin
 Droit:=StrToInt64(Droits.Text);
 for i:=0 to ComponentCount - 1
   do begin
      if Components[i] is TButton  then
       begin
         bit:=TButton(Components[i]).Tag;
         if Bit>0 then   // bit = 0 boutons toujours visibles
          begin
           valeurBit:=Round(Power(2,bit-1));
           TButton(Components[i]).Enabled:=(Droit AND Valeurbit)<>0;   // 
          end;
       end;
   end;
end;

maintenant l'explication posée on peut remplacer ce round(Power(2,bit-1) par un joli (1 shl bit-1) et faire un code plus propre


@ShaileTroll c'est vrai, mais j'ai toujours un doute sur le SQL proposé (ou est l'alias gp ?)

[ShaiLeTroll]

Chaque bouton aura une valeur de tag défini, plus facile qu'un ordre qui peut changer.

Ce qui me gène dans cette méthode, même si je l'ai aussi proposé via Components[], c'est qu'il n'y a pas de registre des numéros de bouton, pour savoir combien il faut mettre comme Tag pour un nouveau bouton, faudrait explorer tous les fiches et boutons du projet, au pire un registre peut être maintenu en commentaire mais la présence soit d'une Table Thésaurus BUTTONS ou une Enumération, nous avons des éléments techniques qui assurent la maintenance
Rien que l'écran d'administration, sans registre des tag, il n'est pas possible de le faire, et modifier les bits à la main en SQL, euh ça c'est juste pénible.
Pour ce qui est d'un "ordre qui peut changer", il est évident qu'il ne faut jamais modifié l'ordre de l'énumération sinon c'est la cata, un commentaire pour alerter cela semble pertinent, dans la RTL, VCL ... le coup du ": array[TEnumeration] of" est un classique absolu qui implique que l'énumération est agrandi mais pas modifié dans l'ordre
Alors qu'avec une Table Thésaurus BUTTONS, l'impact est lors d'un refactoring de code si l'on change le nom de la fenêtre ou du bouton, ce qui est une action qui ne peut pas être involontaire contrairement à une mauvaise manipulation sur l'énumération

J'avais blindé un code contre la modification erronée de l'énumération via un tableau pour être sur que lors de la maintenance qu'il n'y ait pas de régression, tous les codes étaient d'ailleurs drivé par l'énumération, suffisait de modifier 7 emplacements au lieu de plus de 50 dans la version d'un collègue qui n'avait jamais pu aboutir les RTTI, et les 7 emplacements étaient détectable à la compilation pour la plupart, 2 était par Assertions ... alors pour les 50 fallait juste connaître le code par cœur pour ajouter un élément
Du coup, je pense "Maintenance" dans ma conception qui n'est pas forcément spontanée.

Je dis cela pas pour rien, je l'ai vécu et expérimenté comme d'ailleurs lorsqu'il a fallu augmenter la complexité du niveau de droit façon CRUD et du coup comme je l'ai proposé, l'astuce est d'avoir un champ DROIT par Form (en vrai Entity, une forme pouvant contenir plusieurs Entity), ainsi la gestion du numéro est localisé à une forme, c'est déjà plus simple pour l'évolution
En CRUD, la gestion n'est pas forcément au niveau du bouton mais à un ensemble de fonctionnalité de l'écran Detail/Listing (de ou des Entity) mais tout ça est un autre sujet

@ShaileTroll c'est vrai, mais j'ai toujours un doute sur le SQL proposé (ou est l'alias gp ?)

en fait, comme je l'ai fait remarqué gp doit être remplacé par db car avec la structure de table actuel la jointure sur la table GROUPS n'est pas utile puis USER contient le GROUP_IP que l'on peut lier à celui de DROITS_BOUTON, c'est un reste d'une requête intermédiaire que j'avais écrit entre deux versions du post, il semblait évident qu'il fallait corriger cela ... j'avais prévenu d'ailleurs qu'il fallait le faire ... l'idée n'est pas non plus de faire le travail de delphi2019 mais de lui faire explorer une solution et de la comprendre

[delphi2019]

comment corriger le LEFT JOIN dont le but est de retourner tous les boutons de la Form en cours avec un Groupe Assigné (donc Actif) ou un NULL dans Groupe (donc Inactif) ???
Veuillez m'aider. Je n'ai pas pu résoudre cette question

[SergioMaster]

Je répondrais par cette image, vue il y a quelques jours sur LinkedIn

[delphi2019]

Je vois que la requête est correcte, que manque-t-il ?

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
  with FDQuery1 do
     begin
      Close;
      SQL.Clear;
      SQL.Add(' SELECT b.ButtonName, u.ID_GROUPE');
      SQL.Add(' FROM BOUTONS b');
      SQL.Add(' LEFT JOIN DROITS_BOUTON db ON db.ID_Button = b.ID_Button');
      SQL.Add(' LEFT JOIN USERS u ON u.ID_GROUPE = gp.ID_GROUPE AND u.NOM := pNOM');
      SQL.Add(' WHERE b.FormName = :pFormName');
      ParamByName('pFormName').value:=Self.ClassName;
      ParamByName('pNOM').value:=FormAuthentification.EditUserName.Text;
      open;
    end;

[ShaiLeTroll]

Je vois que la requête est correcte, que manque-t-il ?

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
  with FDQuery1 do
     begin
      Close;
      SQL.Clear;
      SQL.Add(' SELECT b.ButtonName, u.ID_GROUPE');
      SQL.Add(' FROM BOUTONS b');
      SQL.Add(' LEFT JOIN DROITS_BOUTON db ON db.ID_Button = b.ID_Button');
      SQL.Add(' LEFT JOIN USERS u ON u.ID_GROUPE = gp.ID_GROUPE AND u.NOM := pNOM');
      SQL.Add(' WHERE b.FormName = :pFormName');
      ParamByName('pFormName').value:=Self.ClassName;
      ParamByName('pNOM').value:=FormAuthentification.EditUserName.Text;
      open;
    end;

Si la base de données est correctement rempli (ça c'est surement ce qui coince), en dehors ce qui a été dit deux fois :

en fait, comme je l'ai fait remarqué gp doit être remplacé par db car avec la structure de table actuel la jointure sur la table GROUPS n'est pas utile puis USER contient le GROUP_IP que l'on peut lier à celui de DROITS_BOUTON, c'est un reste d'une requête intermédiaire que j'avais écrit entre deux versions du post, il semblait évident qu'il fallait corriger cela ... j'avais prévenu d'ailleurs qu'il fallait le faire ... l'idée n'est pas non plus de faire le travail de delphi2019 mais de lui faire explorer une solution et de la comprendre

Si vous fournissez votre script entier, création de table + remplissage, nous pourrons plus facilement vous aider



PS : Excellent Diagramme de Sergio ,
celui que j'utilisais le plus pendant une période c'est le "FROM A LEFT JOIN B WHERE B IS NULL" à la place d'un "NOT IN" bien plus lent

[delphi2019]

merci

[SergioMaster]

Bonjour,

Je vois que cela a été marqué comme résolu sans pour autant fournir le comment, du coup cela ne profite pas à la communauté d'où mon .
Je plains le lecteur qui se trouvera, un jour, dans la même situation.
Deux solutions ont été proposées structure horizontale ou structure verticale. A priori c'est la structure verticale qui a remporté la décision.
Mais le reste est flou, même le dernier SQL indiqué est toujours, selon moi , erronné

Code SQL :

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

1
2
3
FROM BOUTONS b');
      SQL.Add(' LEFT JOIN DROITS_BOUTON db ON db.ID_Button = b.ID_Button');
      SQL.Add(' LEFT JOIN USERS u ON u.ID_GROUPE = gp.ID_GROUPE AND u.NOM := pNOM');

L'alias de table gp n'existe pas ! Ne mettez pas ça sur une erreur de copier/coller, nous l'avons indiqué deux ou trois fois.

Et enfin, il n'y a même pas d'indication du code que la requête nourrie, soit comment vous gérez les boutons dans votre code.

Je ré-itère donc mon vous faites appel à la communauté, il serait bon en retour de partager l'expérience

[delphi2019]

SergioMaster C'est vrai ce que tu as dit