Discussion :

[kewine]

Bonjour a tous,

j'ai une petite application de gestion de compte
et j'aimerai l'a structurer est ce que c'est la bonne pratique ?

dans unite1 j'ai ma classe
dans unite2 j'appelle cette class


merci de votre aide.

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
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
 
unit Unit1;
 
interface
 
uses
   SysUtils, Classes, UIB,Dialogs;
type
 TUtilisateur = class
 UIB_DB: TUIBDataBase;
   private
     FNum: Integer;
     FNom: String;
     FPrenom: string;
     FAge: Integer;
     procedure SetNum(const AValue: Integer);
     procedure SetNom(const AValue: String);
     procedure SetPrenom(const AValue: String);
     procedure SetAge(const AValue: Integer);
   public
     constructor Create; virtual;
     destructor  Destroy; override;
     property Num: Integer read FNum write SetNum;
     property Nom: string read FNom write SetNom;
     property Prenom: string read FPrenom write SetPrenom;
     property Age: Integer read FAge write SetAge;
 
     procedure Voir;
     procedure Ajouter;
     procedure Modifier;
     procedure Supprimer;
   end;
implementation
 
{ TUtilisateur }
procedure TUtilisateur.SetNum(const AValue: Integer);
begin
  if FNum=AValue then exit;
    FNum:=AValue;
end;
 
procedure TUtilisateur.SetNom(const AValue: String);
begin
  if FNom=AValue then exit;
    FNom:=AValue;
end;
procedure TUtilisateur.SetPrenom(const AValue: String);
begin
  if FPrenom=AValue then exit;
    FPrenom:=AValue;
end;
 
procedure TUtilisateur.SetAge(const AValue: integer);
begin
  if FAge=AValue then exit;
    FAge:=AValue;
end;
 
 
 
 
 
procedure TUtilisateur.Voir;
var
  Query: TUIBQuery;
  Transaction: TUIBTransaction;
begin
  Transaction := TUIBTransaction.Create(Nil);
  Transaction.DataBase := UIB_DB;
  Query := TUIBQuery.Create(Nil);
  Query.Transaction := Transaction;
  try
    Query.SQL.Add('SELECT NOM,PRENOM,AGE FROM UTILISATEUR WHERE NUM= :NUM');
    Query.Params.ByNameAsInteger['NUM'] := FNum;
    Query.Open();
    FNom := Query.Fields.ByNameAsString['NOM'];
    FPrenom := Query.Fields.ByNameAsString['PRENOM'];
    FAge := Query.Fields.ByNameAsInteger['AGE'];
    Query.Close(etmCommit);
  except
    on E: Exception do
    begin
      Transaction.RollBack;
      ShowMessage('Erreur ' + #13#10 + E.message);
    end;
  end;
  Transaction.Free;
  Query.Free;
end;
 
procedure TUtilisateur.Ajouter;
var
  Query: TUIBQuery;
  Transaction: TUIBTransaction;
begin
  Transaction := TUIBTransaction.Create(Nil);
  Transaction.DataBase := UIB_DB;
  Query := TUIBQuery.Create(Nil);
  Query.Transaction := Transaction;
  try
    Query.SQL.Add(
      'NSERT INTO UTILISATEUR (NOM,PRENOM,AGE)VALUES(:NOM,:PRENOM,:AGE)');
    Query.Params.ByNameAsString[''] := FNom;
    Query.Params.ByNameAsString[''] := FPrenom;
    Query.Params.ByNameAsInteger['AGE'] := FAge;
    Query.ExecSQL;
    Transaction.Commit;
  except
    on E: Exception do
    begin
      Transaction.RollBack;
      ShowMessage('Erreur ' + #13#10 + E.message);
    end;
  end;
  Transaction.Free;
  Query.Free;
end;
 
constructor TUtilisateur.Create;
begin
  UIB_DB:= TUIBDataBase.Create(Nil);
  UIB_DB.Params.Add('sql_dialect=3');
  UIB_DB.Params.Add('lc_ctype=UTF8');
  UIB_DB.DatabaseName := 'c:\projet1\projet.FDB';
  UIB_DB.UserName     := 'SYSDBA';
  UIB_DB.PassWord     := 'masterkey';
  UIB_DB.LibraryName  := 'C:\Program Files\Firebird\Firebird_2_1\bin\fbclient.dll';
  UIB_DB.Connected:= True;
end;
 
destructor TUtilisateur.Destroy;
begin
  UIB_DB.Free;
  inherited;
end;
 
procedure TUtilisateur.Modifier;
var
  Query: TUIBQuery;
  Transaction: TUIBTransaction;
begin
  Transaction := TUIBTransaction.Create(Nil);
  Transaction.DataBase := UIB_DB;
  Query := TUIBQuery.Create(Nil);
  Query.Transaction := Transaction;
  try
    Query.SQL.Add(
      'UPDATE UTILISATEUR SET NOM =:NOM,PRENOM = :PRENOM ,AGE = :AGE WHERE NUM = :NUM');
    Query.Params.ByNameAsInteger['NUM'] := FNum;
    Query.Params.ByNameAsString['NOM'] := FNom;
    Query.Params.ByNameAsString['PRENOM'] := FPrenom;
    Query.Params.ByNameAsInteger['AGE'] := FAge;
    Query.ExecSQL;
    Transaction.Commit;
  except
    on E: Exception do
    begin
      Transaction.RollBack;
      ShowMessage('Erreur ' + #13#10 + E.message);
    end;
  end;
  Transaction.Free;
  Query.Free;
end;
 
procedure TUtilisateur.Supprimer;
var
  Query: TUIBQuery;
  Transaction: TUIBTransaction;
begin
  Transaction := TUIBTransaction.Create(Nil);
  Transaction.DataBase := UIB_DB;
  Query := TUIBQuery.Create(Nil);
  Query.Transaction := Transaction;
  try
    Query.SQL.Add('DELETE FROM UTILISATEUR WHERE NUM = :NUM');
    Query.Params.ByNameAsInteger['NUM'] := FNum;
    Query.ExecSQL;
    Transaction.Commit;
  except
    on E: Exception do
    begin
      Transaction.RollBack;
      ShowMessage('Erreur ' + #13#10 + E.message);
    end;
  end;
  Transaction.Free;
  Query.Free;
end;
 
end.

unite2

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
 
unit Unit2;
 
interface
 
uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs,Unit1, StdCtrls;
 
type
  TForm2 = class(TForm)
    edNumero: TEdit;
    edNom: TEdit;
    edPrenom: TEdit;
    btnAjouter: TButton;
    lbl1: TLabel;
    lbl2: TLabel;
    lbl3: TLabel;
    edAge: TEdit;
    lbl4: TLabel;
    btnModifier: TButton;
    btnVoir: TButton;
    btnSupprimer: TButton;
    procedure FormCreate(Sender: TObject);
    procedure FormDestroy(Sender: TObject);
    procedure btnAjouterClick(Sender: TObject);
    procedure btnVoirClick(Sender: TObject);
    procedure btnModifierClick(Sender: TObject);
    procedure btnSupprimerClick(Sender: TObject);
  private
    { Déclarations privées }
  public
    { Déclarations publiques }
  end;
 
var
  Form2: TForm2;
  Utilisateur : TUtilisateur;
implementation
 
 
 
{$R *.dfm}
 
procedure TForm2.btnAjouterClick(Sender: TObject);
begin
  Utilisateur.Nom:= edNom.Text;
  Utilisateur.Prenom:= edPrenom.Text;
  Utilisateur.Age:= StrToInt(edAGe.Text);
  Utilisateur.Ajouter;
end;
 
procedure TForm2.btnModifierClick(Sender: TObject);
begin
  Utilisateur.Nom:= edNom.Text;
  Utilisateur.Prenom:= edPrenom.Text;
  Utilisateur.Age:= StrToInt(edAGe.Text);
  Utilisateur.Modifier;
end;
 
procedure TForm2.btnSupprimerClick(Sender: TObject);
begin
  Utilisateur.Num:= StrToInt(edNumero.Text);
  Utilisateur.Supprimer;
end;
 
procedure TForm2.btnVoirClick(Sender: TObject);
begin
  Utilisateur.Num := StrToInt(edNumero.Text);
  Utilisateur.Voir;
  edNom.Text:= Utilisateur.Nom;
  edPrenom.Text:= Utilisateur.Prenom;
  edAge.Text:= IntToStr(Utilisateur.Age);
end;
 
procedure TForm2.FormCreate(Sender: TObject);
begin
  Utilisateur := TUtilisateur.Create;
end;
 
procedure TForm2.FormDestroy(Sender: TObject);
begin
  Utilisateur.Free;
end;
 
end.

[Dr.Who]

suggestion d'amélioration :

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
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
 
unit UUsers;
 
interface
 
uses
   SysUtils, Classes, UIB, Dialogs;
 
type
  TUtilisateur = class
  private
    FNum    : Integer;
    FNom    : String;
    FPrenom : string;
    FAge    : Integer;
    FUIBDB  : TUIBDataBase;
    FUIBQR  : TUIBQuery;
    FUIBTS  : TUIBTransaction;
  protected
    property UIBDB : TUIBDataBase read FUIBDB;
    property UIBQR : TUIBQuery read FUIBQR;
    property UIBTS : TUIBTransaction read FUIBTS;
    procedure CallErrorMsg(aMessage: string);
  public
    property Num    : Integer read FNum    write FNum;
    property Nom    : string  read FNom    write FNom;
    property Prenom : string  read FPrenom write FPrenom;
    property Age    : Integer read FAge    write FAge;
 
    procedure Voir;
    procedure Ajouter;
    procedure Modifier;
    procedure Supprimer(const aNeedConfirmation: boolean = false);
  public
    constructor Create(aDBFile, aDBLibrary: string); virtual;
    destructor  Destroy; override;
  end;
 
implementation
 
{ TUtilisateur }
 
procedure TUtilisateur.CallErrorMsg(aMessage: string);
begin
  FUIBTS.RollBack;
  MessageDlg(E.Message, mtError, [mbOK], 0);
end;
 
constructor TUtilisateur.Create(aDBFile, aDBLibrary, aUserName, aPassWord: string);
begin
  assert(fileExists(aDBFile), 'Oops! Fichier de données non trouvé.');
  assert(fileExists(aDBLibrary), 'Epic Fail : Moteur de base de donnée absent.');
 
  FNum    := -1;
  FNom    := '';
  FPrenom := '';
  FAge    := -1;
 
  FUIBDB := TUIBDataBase.Create(Nil);
  FUIBDB.Params.Add('sql_dialect=3');
  FUIBDB.Params.Add('lc_ctype=UTF8');
  FUIBDB.DatabaseName := aDBFile;
  FUIBDB.UserName     := aUserName;
  FUIBDB.PassWord     := aPassWord;
  FUIBDB.LibraryName  := aDBLib;
  FUIBDB.Connected    := True;
 
  FUIBTS := TUIBTransaction.Create(nil);
  FUIBTS.DataBase := FUIBDB;
 
  FUIBQR := TUIBQuery.Create(nil);
  FUIBQR.Transaction := FUIBTS;
end;
 
destructor TUtilisateur.Destroy;
begin
  FUIBQR.Free;
  FUIBTS.Free;
  FUIBDB.Free;
  inherited;
end;
 
procedure TUtilisateur.Voir;
begin
  try
    FUIBQR.SQL.Add('SELECT NOM,PRENOM,AGE FROM UTILISATEUR WHERE NUM=:NUM');
    FUIBQR.Params.ByNameAsInteger['NUM'] := FNum;
    FUIBQR.Open;
    FNom    := FUIBQR.Fields.ByNameAsString['NOM'];
    FPrenom := FUIBQR.Fields.ByNameAsString['PRENOM'];
    FAge    := FUIBQR.Fields.ByNameAsInteger['AGE'];
    FUIBQR.Close(etmCommit);
  except
    on E: Exception do
      CallErrorMsg(E.Message);
  end;
end;
 
procedure TUtilisateur.Ajouter(const aNeedConfirmation: boolean = false);
begin
  if aNeedConfirmation then
    if MessageDlg('Confirmer l''ajout de cet utilisateur ?', mtConfirmation, [mbYes, mbNo], 0) <> mrYes then
      exit;
  try
    FUIBQR.SQL.Add('INSERT INTO UTILISATEUR (NOM,PRENOM,AGE) VALUES(:NOM,:PRENOM,:AGE)');
    FUIBQR.Params.ByNameAsString['NOM']    := FNom;
    FUIBQR.Params.ByNameAsString['PRENOM'] := FPrenom;
    FUIBQR.Params.ByNameAsInteger['AGE']   := FAge;
    FUIBQR.ExecSQL;
    FUIBTS.Commit;
  except
    on E: Exception do
      CallErrorMsg(E.Message);
  end;
end;
 
 
procedure TUtilisateur.Modifier(const aNeedConfirmation: boolean = false);
begin
  if aNeedConfirmation then
    if MessageDlg('Confirmer la modification de cet utilisateur ?', mtConfirmation, [mbYes, mbNo], 0) <> mrYes then
      exit;
 
  try
    FUIBQR.SQL.Add('UPDATE UTILISATEUR SET NOM=:NOM, PRENOM=:PRENOM, AGE=:AGE WHERE NUM=:NUM');
    FUIBQR.Params.ByNameAsInteger['NUM']   := FNum;
    FUIBQR.Params.ByNameAsString['NOM']    := FNom;
    FUIBQR.Params.ByNameAsString['PRENOM'] := FPrenom;
    FUIBQR.Params.ByNameAsInteger['AGE']   := FAge;
    FUIBQR.ExecSQL;
    FUIBTS.Commit;
  except
    on E: Exception do
      CallErrorMsg(E.Message);
  end;
end;
 
procedure TUtilisateur.Supprimer(const aNeedConfirmation: boolean = false);
begin
  if aNeedConfirmation then
    if MessageDlg('Voulez vous supprimer cet utilisateur ?', mtConfirmation, [mbYes, mbNo], 0) <> mrYes then
      exit;
 
  try
    FUIBQR.SQL.Add('DELETE FROM UTILISATEUR WHERE NUM=:NUM');
    FUIBQR.Params.ByNameAsInteger['NUM'] := FNum;
    FUIBQR.ExecSQL;
    FUIBTS.Commit;
  except
    on E: Exception do
      CallErrorMsg(E.Message);
  end;
end;
 
end.

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
unit Unit46;
 
interface
 
uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, UUsers, StdCtrls;
 
type
  TForm2 = class(TForm)
    edNumero: TEdit;
    edNom: TEdit;
    edPrenom: TEdit;
    btnAjouter: TButton;
    lbl1: TLabel;
    lbl2: TLabel;
    lbl3: TLabel;
    edAge: TEdit;
    lbl4: TLabel;
    btnModifier: TButton;
    btnVoir: TButton;
    btnSupprimer: TButton;
    procedure FormCreate(Sender: TObject);
    procedure FormDestroy(Sender: TObject);
    procedure btnAjouterClick(Sender: TObject);
    procedure btnVoirClick(Sender: TObject);
    procedure btnModifierClick(Sender: TObject);
    procedure btnSupprimerClick(Sender: TObject);
  private
    fUtilisateur : UUsers.TUtilisateur;
  public
    { Déclarations publiques }
  end;
 
var
  Form2: TForm2;
 
implementation
 
{$R *.dfm}
 
procedure TForm2.FormCreate(Sender: TObject);
begin
  fUtilisateur := TUtilisateur.Create;
end;
 
procedure TForm2.FormDestroy(Sender: TObject);
begin
  fUtilisateur.Free;
end;
 
procedure TForm2.btnAjouterClick(Sender: TObject);
var E: integer;
begin
  if not TryStrToInt(edAge.Text, E) then
    MessageDlg('Age saisi invalide !', mtWarning, [mbOk], 0)
  else
  begin
    fUtilisateur.Nom    := edNom.Text;
    fUtilisateur.Prenom := edPrenom.Text;
    fUtilisateur.Age    := E;
    fUtilisateur.Ajouter{(optionsConfirmAdd.Checked)};
  end;
end;
 
procedure TForm2.btnModifierClick(Sender: TObject);
var E: integer;
begin
  if not TryStrToInt(edAge.Text, E) then
    MessageDlg('Age saisi invalide !', mtWarning, [mbOk], 0)
  else
  begin
    fUtilisateur.Nom    := edNom.Text;
    fUtilisateur.Prenom := edPrenom.Text;
    fUtilisateur.Age    := E;
    fUtilisateur.Modifier{(optionsConfirmUpdate.Checked)};
  end;
end;
 
procedure TForm2.btnSupprimerClick(Sender: TObject);
var E: integer;
begin
  if not TryStrToInt(edNumero.Text, E) then
    MessageDlg('Numero utilisateur invalide !', mtWarning, [mbOk], 0)
  else
  begin
    fUtilisateur.Num := E;
    fUtilisateur.Supprimer{(optionsConfirmDelete.Checked)};
  end;
end;
 
procedure TForm2.btnVoirClick(Sender: TObject);
var E: integer;
begin
  if not TryStrToInt(edNumero.Text, E) then
    MessageDlg('Numero utilisateur invalide !', mtWarning, [mbOk], 0)
  else
  begin
    fUtilisateur.Num := E;
    fUtilisateur.Voir;
    edNom.Text    := fUtilisateur.Nom;
    edPrenom.Text := fUtilisateur.Prenom;
    edAge.Text    := IntToStr(fUtilisateur.Age);
  end;
end;
 
end.

[evarisnea]

une suggestion par rapport à la proposition de Dr.Who : mettre la propriété Database en lecture écriture, ou passer un objet Database au constructeur de la classe, de telle manière que ce soit le code manipulant la classe qui définit cette propriété. ainsi si l'on instancie plusieurs fois la classe, l'on n'a qu'une seule connexion à la base de données.

[popo]

Je ne trouve pas ça très propre !

Le titre du sujet est "Structurer un projet POO"

Ici, déclarez une class utilisateur qui gère lui même sa connexion à la base de données et qui fait lui même des requêtes !
Le résultat vous faîtes des tonnes de requêtes pour pas grand chose et ce n'est pas réutilisable pour un autre programme !

Selon moi, la class "TUtilisateur" doit simplement gérer l'utilisateur et rien d'autre. Après il faut une classe "TListeUtilisateurs" contenant une liste d'utilisateur et qui gerera les opérations courantes (ajout, suppression, modification).
Ici il n'est toujours pas question de connexion à la base de données sinon se ne sera pas réutilisable. Il faut déclarer des méthodes virtuelles qui seront utilisées dans une "TListeUtilisateurPerso" classe dérivée de TListeUtilisateur et qui elle fera les traitements avec la base de données.
De cette manière on ne touche jamais à l'utilisateur ni à la liste, il suffit simplement d'implémenter une class dérivées qui gérera la façon dont sont réupérées les données. Si demain tu utilise des fichier ini il te suffira simplement de redéfinir la methode dérivée qui va chercher les données.

[kewine]

Bonjour à tous,


Dr.Who merci pour ton code.

evarisnea Ok je corrige

popo j'ai suivi tes conseils mais par contre je bloque dans la partie
ListeUtilisateur

merci encore à tous pour votre aide.

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
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
249
250
251
252
253
254
 
unit GestionCompte;
 
interface
 
uses
   SysUtils, Classes,Controls,Dialogs, UIB,ContNRS;
 
type
 
TGestion   = class
  private
     FUIBDB  : TUIBDataBase;
     FUIBQR  : TUIBQuery;
     FUIBTS  : TUIBTransaction;
  protected
     property UIBDB : TUIBDataBase read FUIBDB;
     property UIBQR : TUIBQuery read FUIBQR;
     property UIBTS : TUIBTransaction read FUIBTS;
  public
    constructor Create(aDBFile, aDBLibrary, aUserName, aPassWord: string); virtual;
    destructor  Destroy; override;
end;
 
 TUtilisateur = class
   private
     FNum: Integer;
     FNom: String;
     FPrenom: string;
     FAge: Integer;
  public
    property Num    : Integer read FNum    write FNum;
    property Nom    : string  read FNom    write FNom;
    property Prenom : string  read FPrenom write FPrenom;
    property Age    : Integer read FAge    write FAge;
 
  public
    constructor Create; virtual;
    destructor  Destroy; override;
  end;
 
TListeUtilisateur = class
  private
    FUtilisateur : TUtilisateur;
    FLUtilisateur :TObjectList;
  public
    property Utilisateur    : TUtilisateur read  FUtilisateur  write  FUtilisateur;
    property LUtilisateur  : TObjectList  read  FLUtilisateur write FLUtilisateur;
    procedure Voir;
    procedure Ajouter;   virtual; abstract;
    procedure Modifier;  virtual; abstract;
    procedure Supprimer; virtual; abstract;
  public
    constructor Create; virtual;
    destructor  Destroy; override;
end;
 
 
TListeUtilisateurCustom = class   (TListeUtilisateur)
  private
   FGestion :TGestion;
  public
    property Gestion : TGestion read FGestion write FGestion ;
 
    procedure CallErrorMsg(aMessage: string);
    procedure Voir;
    procedure Ajouter(const aNeedConfirmation: boolean = false); override;
    procedure Modifier(const aNeedConfirmation: boolean = false); override;
    procedure Supprimer(const aNeedConfirmation: boolean = false); override;
  public
    constructor Create; virtual;
    destructor  Destroy; override;
end;
 
 
implementation
 
{ TGestion }
 
procedure TListeUtilisateurCustom.CallErrorMsg(aMessage: string);
begin
  Gestion.FUIBTS.RollBack;
  //MessageDlg(E.Message, mtError, [mbOK], 0);
end;
 
constructor TGestion.Create(aDBFile, aDBLibrary, aUserName, aPassWord: string);
begin
  assert(fileExists(aDBFile), 'Oops! Fichier de données non trouvé.');
  assert(fileExists(aDBLibrary), 'Epic Fail : Moteur de base de donnée absent.');
 
  FUIBDB := TUIBDataBase.Create(Nil);
  FUIBDB.Params.Add('sql_dialect=3');
  FUIBDB.Params.Add('lc_ctype=UTF8');
  FUIBDB.DatabaseName := aDBFile;
  FUIBDB.UserName     := aUserName;
  FUIBDB.PassWord     := aPassWord;
  FUIBDB.LibraryName  := aDBFile;
  FUIBDB.Connected    := True;
 
  FUIBTS := TUIBTransaction.Create(nil);
  FUIBTS.DataBase := FUIBDB;
 
  FUIBQR := TUIBQuery.Create(nil);
  FUIBQR.Transaction := FUIBTS;
end;
 
destructor TGestion.Destroy;
begin
  FUIBQR.Free;
  FUIBTS.Free;
  FUIBDB.Free;
  inherited;
end;
 
 
{ TUtilisateur }
 
constructor TUtilisateur.Create;
begin
  FNum    := -1;
  FNom    := '';
  FPrenom := '';
  FAge    := -1;
end;
 
destructor TUtilisateur.Destroy;
begin
  inherited;
end;
 
procedure TListeUtilisateurCustom.Voir;
begin
  try
    Gestion.FUIBQR.SQL.Add('SELECT NOM,PRENOM,AGE FROM UTILISATEUR WHERE NUM=:NUM');
    Gestion.FUIBQR.Params.ByNameAsInteger['NUM'] := Utilisateur.FNum;
    Gestion.FUIBQR.Open;
    Utilisateur.FNom    :=  Gestion.FUIBQR.Fields.ByNameAsString['NOM'];
    Utilisateur.FPrenom :=  Gestion.FUIBQR.Fields.ByNameAsString['PRENOM'];
    Utilisateur.FAge    :=  Gestion.FUIBQR.Fields.ByNameAsInteger['AGE'];
    Gestion.FUIBQR.Close(etmCommit);
  except
    on E: Exception do
       CallErrorMsg(E.Message);
  end;
end;
 
procedure TListeUtilisateurCustom.Ajouter(const aNeedConfirmation: boolean = false);
begin
  if aNeedConfirmation then
    if MessageDlg('Confirmer l''ajout de cet utilisateur ?', mtConfirmation, [mbYes, mbNo], 0) <> mrYes then
      exit;
  try
    Gestion.FUIBQR.SQL.Add('INSERT INTO UTILISATEUR (NOM,PRENOM,AGE) VALUES(:NOM,:PRENOM,:AGE)');
    Gestion.FUIBQR.Params.ByNameAsString['NOM']    := Utilisateur.FNom;
    Gestion.FUIBQR.Params.ByNameAsString['PRENOM'] := Utilisateur.FPrenom;
    Gestion.FUIBQR.Params.ByNameAsInteger['AGE']   := Utilisateur.FAge;
    Gestion.FUIBQR.ExecSQL;
    Gestion.FUIBTS.Commit;
  except
    on E: Exception do
      CallErrorMsg(E.Message);
  end;
end;
 
 
constructor TListeUtilisateurCustom.Create;
begin
  FGestion := TGestion.Create(nil);
 
end;
 
destructor TListeUtilisateurCustom.Destroy;
begin
  Gestion.Free;
  inherited;
end;
 
procedure TListeUtilisateurCustom.Modifier(const aNeedConfirmation: boolean = false);
begin
  if aNeedConfirmation then
    if MessageDlg('Confirmer la modification de cet utilisateur ?', mtConfirmation, [mbYes, mbNo], 0) <> mrYes then
      exit;
 
  try
    Gestion.FUIBQR.SQL.Add('UPDATE UTILISATEUR SET NOM=:NOM, PRENOM=:PRENOM, AGE=:AGE WHERE NUM=:NUM');
    Gestion.FUIBQR.Params.ByNameAsInteger['NUM']   := Utilisateur.FNum;
    Gestion.FUIBQR.Params.ByNameAsString['NOM']    := Utilisateur.FNom;
    Gestion.FUIBQR.Params.ByNameAsString['PRENOM'] := Utilisateur.FPrenom;
    Gestion.FUIBQR.Params.ByNameAsInteger['AGE']   := Utilisateur.FAge;
    Gestion.FUIBQR.ExecSQL;
    Gestion.FUIBTS.Commit;
  except
    on E: Exception do
      CallErrorMsg(E.Message);
  end;
end;
 
procedure TListeUtilisateurCustom.Supprimer(const aNeedConfirmation: boolean = false);
begin
  if aNeedConfirmation then
    if MessageDlg('Voulez vous supprimer cet utilisateur ?', mtConfirmation, [mbYes, mbNo], 0) <> mrYes then
      exit;
 
  try
    Gestion.FUIBQR.SQL.Add('DELETE FROM UTILISATEUR WHERE NUM=:NUM');
    Gestion.FUIBQR.Params.ByNameAsInteger['NUM'] := Utilisateur.FNum;
    Gestion.FUIBQR.ExecSQL;
    Gestion.FUIBTS.Commit;
  except
    on E: Exception do
      CallErrorMsg(E.Message);
  end;
end;
 
 
 
 
 
{ TListeUtilisateur }
 
procedure TListeUtilisateur.Ajouter;
begin
  Utilisateur := TUtilisateur.Create;
  Utilisateur.Nom    := 'EGAR';
  Utilisateur.Prenom := 'KEWIN';
  Utilisateur.Age    := 42;
  LUtilisateur.add(Utilisateur);
  Utilisateur.Free;
end;
 
constructor TListeUtilisateur.Create;
begin
  FUtilisateur := TListeUtilisateur.Create;
end;
 
destructor TListeUtilisateur.Destroy;
begin
  FLUtilisateur.Free;
  inherited;
end;
 
procedure TListeUtilisateur.Modifier(const aNeedConfirmation: boolean);
begin
  Utilisateur := TUtilisateur.Create;
  Utilisateur.Nom    := 'EGAR';
  Utilisateur.Prenom := 'KEWIN';
  Utilisateur.Age    := 42;
  LUtilisateur.Add(Utilisateur);
  Utilisateur.Free;
end;
 
 
 
end.

[ShaiLeTroll]

Pour faire une couche objet métier, il y a InstantObjects par exemple, cela gère déjà les collections, les relations ... par contre, c'est directement dépendant d'un Provider DB

@popo, Pourquoi Utilisateurs devraient ré-utilisables ? les objets métiers sont liés à une application, entre deux logiciels, leur contenu, la façon des les manipuler, les règles de gestion seront différentes ... c'est un étrange concept que tu énonces !

Je suis d'accord avec le principe d'avoir un élément intermédiaire entre la couche objet et la couche stockage (XML, DB, Ini, Fichier Binaire, Fichier DFM, ...), cela permet en plus de pouvoir passer de l'un à l'autre en RunTime, utile pour des applications en mode déconnecté ou embarqué pour ensuite faire l'intégration sur le serveur.

Il serait bon de gérer la connexion par un singleton et les instanciations de Transaction et Query par des Factory !
Personnellement, le SQL à sa place dans la Classe Utilisateur, par contre, j'ai tendance à les mettre dans des constantes, ainsi on regroupe les SQL ensemble (juste après implementation), sans devoir les chercher partout dans le .pas

Les Requêtes Paramètrées, c'est un très bon choix !
Le SELECT pourrait être préparé (instance de l'objet à conserver) cela améliore les performances (ben on en reparlera lorsque tu devras gérer quelques centaines d'utilisateurs ou écrire des batch)


Je trouve le aNeedConfirmation dans les méthodes des objets métiers très maladroit, cela doit rester dans la partie présentation !

[popo]

kewine, l'objet TListeUtilisateur est sensé contenir une liste d'utilisateur. Ici FUtilisateur est inutile. Par contre il te faut une propriété "Utilisateurs[Index]" pour aller chercher un utilisateur en particulier.

@popo, Pourquoi Utilisateurs devraient ré-utilisables ? les objets métiers sont liés à une application, entre deux logiciels, leur contenu, la façon des les manipuler, les règles de gestion seront différentes ... c'est un étrange concept que tu énonces !

Un utilisateur à toujours les mêmes données de bases à savoir au minium un identifiant et un mot de passe. Leur contenu, la façon des les manipuler et les règles de gestion sont ensuite définies dans les classes qui en héritent. Je ne vois pas en quoi cela va à l'encontre de la POO. Je suis d'accord que pour le cas d'un utilisateur, c'est dommage de créer une classe uniquement pour un login et un mot de passe, c'est surtout le fait de mettre l'utilsateur et la connexion à la DB qui m'a offusqué.

Je trouve le aNeedConfirmation dans les méthodes des objets métiers très maladroit, cela doit rester dans la partie présentation !

Tout à fait d'accord, il ne faut pas mélanger les données, les traitements et l'affichage. Cela doit restrer trois choses distinctes !