Discussion :

[Bruno13]

Bonjour à tous,

note: ce message a déjà été posté dans un autre forum mais hélas sans réponse pour l'instant, alors je me permets de la réposer ici.

je voudrais ajouter dans mon programme un gestionnaire de droit utilisateur.

Pour cela j'ai pensé tout d'abord à créer ma Class, assez simple.
Mais avant de me lancer dans l'aventure du dev, j'aimerai avoir vos avis et savoir s'il n'existe pas déjà une Class qui existe ?

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
  TUserRightClass = class(TObject)
  private { Déclarations privées }
    FName    : String;
    FLogin   : String;
    FPwd     : String;
    FLevel   : Integer;
  protected { Déclarations protégées }
  public { Déclarations publiques }
    property Name: string read FName write FName;
    property Login: string read FLogin write FLogin;
    property Pwd: string read FPwd write FPwd;
    property Level: Integer read FLevel write FLevel;
  end;

Bon ok admettons que cette structure suffise, la suite pour le passage de mon programme de Mono-Utilisateur à Multi-Utilisateurs me soulève un tas de questions.

Tout d'abord quelques mots de mon programme.
C'est assez simple dans les grandes lignes :
- j'ai différents projets
- chaque projet contient des fiches descriptives de documents textes importés
- chaque fiche contient des champs remplies automatiquement lors de l'importation comme le titre, les auteurs, la date, etc...

MAIS chaque fiche possède aussi des champs que l'utilisateur peut remplir comme la pertinence de la fiche (une note sur 20), un commentaire, une catégorie, et quelques autres champs.

A l'heure actuelle, j'ai donc une Class TFiches avec ceci :

Code :

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

1
2
3
4
5
6
7
....
    FId         : Integer; // Auto
    FTitle      : string;  // Auto
    FAbstract   : string;  // Auto
    FComments   : string;  // User
    FPert       : Integer; // User
....

Et comme vous pouvez le voir je ne peux pas affecter un commentaire (ou une pertinence) en différenciant les utilisateurs.

Comment est-ce vous vous y prendriez pour faire la modif de la class ?

J'ai pensé à ajouter
FUserComment : TUserRightList; // TUSerRightList est une liste d'objet TUserRightClass.

Mais là je n'ai pas la propriété "FComments" dans TUserRightClass et je ne peut pas ajouter dans cette class tous les champs (pertincence, catégorie, etc...) qui sont dédiés aux différents utilisateurs.

Je sèche un peu là sur la méthode à utiliser.
Faut-il créer une Class intermédiaire ?

Je ne peux hélas pas repartir de zéro (ce qui serait à mon avis la meilleur chose) car je dois assurer la compatibilité avec les projets anciennement créés.

Toute idée sera la bienvenue,

PS : un projet ne peut être ouvert que par une personne à la fois, oufff au moins ça dans le cahier des charges :-) et ça c'est déjà réglé !

Bruno

[anapurna]

salut

je serait toi je ferait une class

Code :

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

1
2
3
4
TUserComment
    FComments   : string;  // User
    Fuser           : TUserRightClass;
end;

ensuite Une class

Code :

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

TListUserComment

pour gerer la liste des commentaires associer

@+ Phil

[Bruno13]

Salut Anapurna,

Effectivement c'est une idée, cela implique que je dois créer pour tous les champs "User" une Classes et sa ListClass asocciée.

Penses-tu que cela soit, comment dire, "propre" et/ou "optimiser" ?
D'un autre côté, le programme à l'origine n'avait pas été créer pour être du Multi-User

[Bruno13]

je pense à une chose, et pourquoi pas créer une classe :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
  TUserClass(TObject)
  private
    FUser          : TUserRightClass;
    FComment    : String;
    FPertinence  : Integer;
    FCategory    : String;
  protected { Déclarations protégées }
  public { Déclarations publiques }
    property User: TUserRightClass read FUser write FUser;
    property Comment: string read FComment write FComment;
    property Pertinence: Integer read FPertinence write FPertinence;
    property Category: String read FCategory write FCategory;
  end;

non ?

[Montor]

Ta class a air un record

Code :

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

1
2
3
4
5
6
  TUserClass =record
    User: TUserRightClass ;
    Comment: string ;
    Pertinence: Integer ;
    Category: String;
  end;

[Bruno13]

Effectivement on peut faire avec un Record mais j'ai tellement l'habitude de faire avec les Classes que je n'ai même pas fait attention.

Y-a-t-il un intérêt d'utiliser un Record au lieu d'une Classe ?

[Dr.Who]

pourquoi ne pas utiliser une base de donnée ?

[Bruno13]

pas le droit chez les clients.

[anapurna]

salut

de toutes les facon la base de donnée n'est que le support sur lequelle tu vient chercher tes donnée
que ce soit des fichiers ou une base l'analyse ne devrais pas changer pour autant

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 TUserClass(TObject)
  private
    FUser          : TUserRightClass;
    FComment    : String;
    FPertinence  : Integer;
    FCategory    : String;
  protected { Déclarations protégées }
  public { Déclarations publiques }
    property User: TUserRightClass read FUser write FUser;
    property Comment: string read FComment write FComment;
    property Pertinence: Integer read FPertinence write FPertinence;
    property Category: String read FCategory write FCategory;
  end;

la pertinance est associer au commantaire je suppose ainsi que la categorie
en fait des le depart tu aurais du avoir une class

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
   TComment = Class()
     FId              : Integer
     FComment    : String;
     FPertinence  : Integer;
     FCategory    : String;
  protected { Déclarations protégées }
  public { Déclarations publiques }
    property Id: Integer read FId write FId;
    property Comment: string read FComment write FComment;
    property Pertinence: Integer read FPertinence write FPertinence;
    property Category: String read FCategory write FCategory;
 end;

la question qui se pose est est que deux utilisateur different peuvent avoir la meme commentaire si oui alors il faut dissocier le commentaire du user sinon

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
   TUserClass = Class()
     FId             : Integer;  
     FUser          : TUserRightClass;
     FComment    : TComment;
  protected { Déclarations protégées }
  public { Déclarations publiques }
    property Id: Integer read FId write FId;
    property Comment: TComment read FComment write FComment;
    property User: TUserRightClass read FUser write FUser;
 end;

comme tu peut le remarquer j'aime bien mettre des identifiant unique dans mes enregistrement/class/table cela permet de modifier a posteriorie sans avoir a tous modifier dans les differents liason possible avec le reste de ton application

@+ Phil


@+ Phil

[Montor]

pas le droit chez les clients.

et comment les autre utilisateur puisse accéder aux projets?

[Bruno13]

Concernant les 3 champs Pertinence, Cat, et Comment, ceux sont 3 choses totalement différentes donc bien que cela fonctionne aussi avec ton exemple, je pense que je vais garder la première solution et ne pas créer un TComment.

Mes premiers essais sont plutôt concluant à l'heure actuelle, j'ai juste, encore et toujours avec FastMM des TUserRightClass non lébérés à la fin.

Mais c'est un autre problème....


Concernant l'Id, yep entièrement d'accord avec toi

[Bruno13]

et comment les autre utilisateur puisse accéder aux projets?

Il n'y a en fait aucune connexion entre les différents ordinateurs possédant le programme. Donc ce sont des fichiers ZIP qui sont envoyés avec les projets.

Barbare je sais mais on est sur plusieurs pays et parfois sans connexion Web

[Bruno13]

TUserRightClass non lébérés

j'ai oublié le Desctructor donc résolu !

[Montor]

Le forum n'est pas un grand atout dans ce cas la puisque tu connais le langage personne ne veut court-circuiter les neurones pour toi ...Coder il faut passer au code...eviter le sentiment etre débordé tu rique d'entrer dans une phase ou on veut terminer le projet sans s'inquièter pour la qualité de code...c'est de l'illusion réussi du primier coup ...
désolé pour intervenir comme ca
c'est pour ne pas etre dans une situation similaire que j'avait cree ce projet pour eviter a chaque fois la creation d'une nouvelle application repeter les meme operation...une applis qui est toujour fexible ,peronalisable accepte plusieurs type de fiches reutilisable non conventionelle la ou la base de donnée fixe le nombre de champs
je fait des test sur cette applis apres je peux creer une autre
voici un exemple
Ajouter dans unite UConst
xUserManage = 11 ;

Ajouter NouvelleForm dans les uses unite UInit
ajouter cette ligne Reg(xUserManage,TUserManage);

creer une nouvelle fiche UserManage avec 7 TEdit et un boutton voici le code enregistrer sous le nom NouvelleForm.pas
Assigner l'evenement on click pour boutton1

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
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
unit NouvelleForm;
 
interface
 
uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls, ComCtrls, Buttons, ImgList, ToolWin,BasicForm,Bibcommon,
  ActnList, ExtCtrls,ClassesUtils,SerialisedStrForm,NewClasses;
 
type
  TUserManage = class(TSerialisedForm)
    Edit1: TEdit;
    Edit2: TEdit;
    Edit3: TEdit;
    Edit4: TEdit;
    Edit5: TEdit;
    Edit6: TEdit;
    Edit7: TEdit;
    Button1: TButton;
    procedure FormCreate(Sender: TObject);
    procedure FormDestroy(Sender: TObject);
    procedure Button1Click(Sender: TObject);
  private
    FUserClass :TUserClass;
  public
    class function Infos():TUFData;override;
    procedure BeforeSave(Sender: TObject);override;
    procedure BeforeOpen(Sender: TObject);override;
    procedure AfterOpen(Sender: TObject);override;
    procedure ReadSelected();override;
    procedure OnSend(var AData :TBibData);
  end;
 
var
  UserManage: TUserManage;
 
implementation
 
uses Main,Utils,UFiles;
 
{$R *.dfm}
function EditStrToint(AC:TEdit):integer;
begin
    if not Assigned(AC) then Exit;
    try
      result:=StrtoInt(AC.Text);
    except
      AC.SetFocus();
      raise;
    end;
end;
 
class function TUserManage.Infos():TUFData;
begin
  with result do
  begin
     UClass:=TUserManage;
     UName :='User info' ;
     UOperations:=[omBrowse];
     UType      :=btTopic;
     UIconIndex :=21;
  end;
end;
 
procedure TUserManage.ReadSelected();
begin
  with  Ex.Topic do
  begin
   { }
  end;
end;
 
procedure TUserManage.BeforeOpen(Sender: TObject);
begin
   { }
end;
 
procedure TUserManage.AfterOpen(Sender: TObject);
begin
   Edit1.Text:= FUserClass.User.Name;
   Edit2.Text:= FUserClass.User.Login;
   Edit3.Text:= FUserClass.User.Pwd;
   Edit4.Text:= Inttostr(FUserClass.User.Level);
 
   Edit5.Text:= FUserClass.Fields.Comment;
   Edit6.Text:= FUserClass.Fields.Category;
   Edit7.Text:= Inttostr(FUserClass.Fields.Pertinence);
end;
 
procedure TUserManage.BeforeSave(Sender: TObject);
begin              
   FUserClass.User.Name :=Edit1.Text ;
   FUserClass.User.Login:= Edit2.Text;
   FUserClass.User.Pwd  := Edit3.Text;
   FUserClass.User.Level:= EditStrToint(Edit4);
 
   FUserClass.Fields.Comment    := Edit5.Text ;
   FUserClass.Fields.Category   := Edit6.Text;
   FUserClass.Fields.Pertinence := EditStrToint(Edit7);
end;
 
procedure TUserManage.OnSend(var AData :TBibData);
begin
   if Trim(FUserClass.User.Name)='' then Abort;
    AData.BibTitle  := Trim(FUserClass.User.Name);
end;
 
procedure TUserManage.FormCreate(Sender: TObject);
begin
     FUserClass :=TUserClass.Create();
     FUserClass.Owner := GlobalStrGenerator;
     Self.OnEdit:= OnSend;
end;
 
procedure TUserManage.FormDestroy(Sender: TObject);
begin
   FUserClass.Free();
end;
 
procedure TUserManage.Button1Click(Sender: TObject);
begin
   Validate();
   Modalresult:=mrOk;
end;
 
end.

pour desfinir tes class
NewClasses.pas

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
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
unit NewClasses;
 
interface
 
uses
  SysUtils,Classes,Userialize;
 const
 {verifier si les valeur n'existe pas sur ClassesUtils}
    USERRIGHTCONST = 20;
    USERCLASSCONST = 21;
 
type
 
  TUserRightClass =class(TStrFields)
  public
    constructor Create();
    property Name  :string index 0 read Get_Str write Set_Str;
    property Login :string index 1 read Get_Str write Set_Str;
    property Pwd   :string index 2 read Get_Str write Set_Str;
    property Level :integer index 3 read Get_int write Set_int;
  end;
 
  TUserClassFields =class(TStrFields)
  public
    constructor Create();
    property Comment: string index 0 read Get_Str write Set_Str;
    property Pertinence:integer index 1 read Get_int write Set_int;
    property Category: string index 2 read Get_Str write Set_Str;
  end;
 
  TUserClass=class(TStrFields)
  private
    FUser        : TUserRightClass;
    FFields      : TUserClassFields;
    {enregistrement et chargement des champs}
    FStrGenerator: TStrGenerator;
    procedure Set_StrGenerator(AGn: TStrGenerator);
  protected 
  public
    constructor Create();
    destructor Destroy();override;
    property User  : TUserRightClass read FUser write FUser;
    property Fields:TUserClassFields read FFields;
    property Owner :TStrGenerator read FStrGenerator write Set_StrGenerator;
  end;
 
implementation
 
{================================================================
                           TUserRightClass                      +
================================================================}
constructor TUserRightClass.Create();
begin
   inherited Create(USERRIGHTCONST,4);
end;
{================================================================
                           TUserClassFields                     +
================================================================}
constructor TUserClassFields.Create();
begin
   inherited Create(USERCLASSCONST,3);
end;
{================================================================
                           TUserClass                           +
================================================================}
constructor TUserClass.Create();
begin
    FUser   :=TUserRightClass.Create();
    FFields :=TUserClassFields.Create();;
end;
 
destructor TUserClass.Destroy();
begin
    FUser.Free();
    FFields.Free();
    inherited;
end;
 
procedure TUserClass.Set_StrGenerator(AGn: TStrGenerator);
begin
   if Assigned(AGn) then
   begin
       FStrGenerator := AGn;
       FFields.Owner := AGn;
       FUser.Owner   := AGn;
   end;
end;
end.

Tu trouvras la fiche 'User info' sur le popMenu

[Bruno13]

Bonjour Montor,

Merci pour ce dernier message ! Je vais voir un peu ce que tu as écrit.

Merci bcp !!!

Amicalement,
Bruno