Comment travailler avec des classes

Version imprimable

Bonjour,

Je travaille depuis peu avec un serveur nodejs et je goute donc aux joies des systèmes asynchrones.
J'ai mis quelques pages en place et la je pense attaquer la plus ~~chiante~~ lourde. J'ai codé la partie d'enregistrement d'objet, pour info mon objet ressemble à :

Code:

1
2
3
4
5
6
7
8
9
{ adresse: [],
  interlocuteur: [],
  appel: [],
  client:
   { activated: 1,
     login: '',
     password: '' },
  contrat: [],
  equipement: [] }

Je me suis amusé avec une imbrication "async.parallel([" de part la nécéssité d'avoir les id d'engistrement de sous objet, pour l'enregistrement des autres. Par exemple, avoir l'id client pour enregistrer son adresse dans une table spécifique.
Maintenant je vais attaquer la partie "update" de l'objet, autant j'ai trouvé fastidieux l'engistrement, que la mise à jour avec la même méthode de codage me semble "grade".

Les questions que je me pose :
- j'ai pensé depuis un moment de coder en objet avec des class sans jamais prendre le temps, serait ce plus pratique ?
- quels types de structure de basse mettre en place ?

Dans la pratique, la première étape concerne les informations de base client : login, pass, idSociete ( compte client rattaché à un compte société), pour ensuite enregistrer la ou les adresses.
Je viens de tester quelque chose, mais je retombe dans la même problématique :

Code:

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
  class Client {
    constructor() {
      this.client = {}
      this.errorMessage = [];
      this.warningMessage = [];
    }
    profilClean(client) {
      this._id =  client?parseInt(client.id)||0:0;
      this._login = lib.cleanVar(client.login, ['lower']) || '';
      this._password = lib.cleanVar(client.password) || '';
      this._activated = parseInt(client.activated)===1?1:0;
      this._comment = lib.cleanVar(client.comment) || '';
    }
    recordUser() {
      var _this = this;
      connection.query(mysql.format(req_sel1,[_this._login]), function(err, rows) {
        if (err) {
          if (lib.isDevEnv()) 
            console.log(err);
          else      
            lib.sendMailErrorCode({"title": "Échec lors de la recherche du login : " + _this._login, "message": __lineFunction }, __lineFunction); 
          return false;
        }  else if (rows.length==0) {
          connection.query(mysql.format(req_client_ins2,[req.session.user.idSociete, _this._comment, _this._activated]), function(err, rows) {
            if (err||rows.affectedRows==0) {
              if (lib.isDevEnv()) 
                console.log(err);
              else      
                lib.sendMailErrorCode({"title": "Échec lors de l\'enregistrement du client' : " + _this._login, "message": __lineFunction }, __lineFunction); 
              return false;
            } else {
              _this._id = rows.insertId;
              return true;
            }
          })
        } else if (rows.length>0) {
          var row = rows[0];
          if (row.id==_this.id&&row.idSociete==req.session.user.idSociete) {
            connection.query(mysql.format(req_user_upd4,[_this._comment, _this._activated, _this._id, req.session.user.idSociete]), function(err, rows) {
              if (err) {
                if (lib.isDevEnv()) 
                  console.log(err);
                else      
                  lib.sendMailErrorCode({"title": "Échec lors de la mise à jour du client : " + _this._login, "message": __lineFunction }, __lineFunction); 
                return false;
              }  else if (rows.affectedRows==0) {  
                _this._errorMessage.push('Échec de la modification de la fichier client : ' + _this._login);
                return false;
              } else return true;
            })
          } else {
            _this._errorMessage.push("L'adresse email '" + _this._login + "' est déjà utilisée.");
            return false;
          }
        }
      })
    }
 
    recordAdress() {
      /*...*/
    }
  }
 
  var client = new Client();
  client.profilClean(data.client)
  client.recordUser();

Quand recordUser renvoie vrai, comment chainer proprement avec recordAddress ?

22/01/2019, 00h13
Marco46

Citation:

Envoyé par Slayes

- j'ai pensé depuis un moment de coder en objet avec des class sans jamais prendre le temps, serait ce plus pratique ?

Uniquement pour définir le modèle. Utilises les getter / setter pour formater les données en entrée / sortie de ta classe, la fonction profilClean n'a pas lieu d'être.

errorMessage et warningMessage n'ont rien à faire en tant que propriété d'une instance de Client, ça doit être à l'extérieur de ton modèle.

Citation:

Envoyé par Slayes

- quels types de structure de basse mettre en place ?

De même les I/O (donc les appels à la base de données et le logging) n'ont rien à faire dans le modèle. Limite la classe Client à un container des données d'un client en mémoire. Les appels à la BDD et le log des warning et erreurs doivent être de la responsabilité d'autres modules.

La fonction recordUser doit donc se trouver dans un autre fichier. La fonction doit donc prendre en paramètre une instance de ta classe Client à enregistrer en BDD et elle doit retourner une promesse.
22/01/2019, 07h34
Slayes

Merci pour votre réponse, si j'ai bien compris les classes n'ont pour objectif que le stockage, formattages I/O de données ?
Sans vouloir abuser, auriez vous un exemple de structure de code?

Une classe c'est un moule à objet. Ça sert à les structurer. C'est un concept relativement inutile en JavaScript mais qui prend du sens avec un superset comme TypeScript. Je dis relativement inutile parce que ya quand même les getters / setters qui sont sympas.

Concrètement, il n'y a aucune différence entre :
Code:

1 2 3 4 5 const client = { id: 1, name: 'toto' };
et
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 class Client { constructor(id, name) { this.id = id; this.name = name; } } module.exports = Client; // dans ton appelant : const client = new Client(1, 'toto');
Pour ce qui est de l'enregistrement du user tu fais simplement un module qui exporte la fonction :
Code:

1 2 3 4 5 6 function recordUser(client) { // impl qui retourne une promesse } module.exports = recordUser;
Dans ton appelant (disons index.js pour faire simple) tu auras :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 const Client = require('./client'); const recordUser = require('./record-user'); const client = new Client(1, 'toto'); recordUser(client) .then((res)=>{ // traitement en cas de succès }) .catch((e)=>{ // traitement en cas d'erreur }); // ou avec async / await try { const res = await recordUser(client); } catch(e) { // traitement en cas d'erreur }
J'écris ça à l'arrache sans EDI faut pas le prendre au pied de la lettre mais c'est l'idée générale.

22/01/2019, 10h51
Slayes

Impec merci ;) je vais remettre tout cela en ordre.