Comment geré au mieux ma classe PHP avec son Manager

L'auteur de ce sujet a trouvé une solution à son problème.
Auteur du sujet

Bonjour,

je viens demander votre aide, car malgré que sa fasse longtemps que je code en PHP je n'ai jamais trop su accrocher au class. Souvent je me dis que je peux m'en passer et finalement sa deviens lourdingue, alors je me dis qu'il faut que je m'y mette.

J'ai donc ici une classe pour géré les inscriptions (Je ne sais d'ailleurs pas si le mieux serait d'avoir une classe Users qui englobe tout ou non ?)

Mon 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
 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
<?php
  /**
   * Project: PanelDev
   * License: GPL3.0 All ©All right reserved
   * User: WinXaito
   */

  class Register{
      private $_username;
      private $_email;
      private $_password;
      private $_confirmPassword;

      public function __construct($username, $email, $password, $confirmPassword){
          $this->setUsername($username);
          $this->setEmail($email);
          $this->setPassword($password);
          $this->setConfirmPassword($confirmPassword);
      }

      public function setUsername($username){
          $this->_username = $username;
      }
      public function setEmail($email){
          $this->_email = $email;
      }
      public function setPassword($password){
          $this->_password = $password;
      }
      public function setConfirmPassword($confirmPassword){
          $this->_confirmPassword = $confirmPassword;
      }

      public function getUsername(){
          return $this->_username;
      }
      public function getEmail(){
          return $this->_email;
      }
      public function getPassword(){
          return $this->_password;
      }
      public function getConfirmPassword(){
          return $this->_confirmPassword;
      }

      public function checkUsername(){
          //Appel de <get()> dans le Manager ?
      }
      public function checkPassword(){
          if(strlen($this->_password) >= 6){
              if($this->_password == $this->_confirmPassword)
                  return true;
              else
                  return false;
          }else{
              return false;
          }
      }
      public function checkEmail(){
          return filter_var($this->_email, FILTER_VALIDATE_EMAIL);
      }
  }

  class RegisterManager{
      private $_db;

      public function __construct($db){
          $this->setDb($db);
      }

      public function setDb($db){
          $this->_db = $db;
      }

      public function get($username){
          $q = $this->_db->prepare("
              SELECT *
              From users
              WHERE username = ?
          ");
          $q->execute(array(
              $username,
          ));

          return $q->fetch();
      }
      public function add(Register $register){
          $q = $this->_db->prepare("
              INSERT INTO users
              (name, password, email, grade)
              VALUES
              (:name, :password, :email, 1)
          ");
          $q->execute(array(
              'name' => $register->getUsername(),
              'password' => sha1($register->getPassword()),
              'email' => $register->getEmail(),
          ));
      }
  
}

Voilà donc comme indiquer en commentaire à la ligne 48, il faudrait que je fasse un appel de la classe RegisterManager, mais je ne sais pas si je m'y prend bien.

C'est potentiellement l'une des premières classe, donc je veux bien vos avis pour savoir si je suis sur la bonne voie ou pas du tout.

Merci à vous

+0 -0
Staff

Cette réponse a aidé l'auteur du sujet

Bonjour,

en fait en soit, je pense que ton principal problème c'est qu'il te manque une classe pour que le schéma logique prenne forme.

Voici comment j'aurai vu les choses :

  • Une classe Register qui est une classe métier, c'est à dire qu'elle va vraiment contenir le métier d'enregistrer un utilisateur ou de générer les erreurs quand ça ne peut pas se passer comme il faut.
  • une classe AuthenticatedUser qui possède les getters/setters et une méthode checkpassword
  • la classe AuthenticatedUserManager qui est juste un autre nom pour ton manager actuel.

à partir de là dans ta classe Register tu as en gros ceci:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
<?php
class Register{
     private $authenticatedUser;
     private $manager;
     public function __construct($user, $manager){
          $this->authenticatedUser = $user;
          $this->manager = $manager;
     }
     public function processCheking(){
          // vérifie que l'objet $user est complet
          // que le mot de passe correspond à la politique de sécurité
          // et que les clefs uniques (name, email) sont bien respectées
          // c'est ici que tu vas faire ton 
      }
     public function processRegistration(){
          $this->manager->add($this->user);
          // puis envoie du mail si ça te fait plaisir
          // etc.
     }
}
+0 -0

Cette réponse a aidé l'auteur du sujet

Dans le désordre :

  • Je sais pas ce que tu veux dire par Register mais puisque tu parle clairement d'un utilisateur, utilise User. :p
  • Tous les getters et setters, c'est inutile.
  • (strlen($this->_password) >= 6) && ($this->_password == $this->_confirmPassword), beaucoup plus court.
  • Il faut mettre la fonction check dans le manager, ce n'est pas le role de l'utilisateur.
  • Il faut préciser le grade initial.

 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
<?php
  class User{
      private $_username;
      private $_email;
      private $_password;
      private $_confirmPassword;

      public function __construct($username, $email, $password, $confirmPassword){
          $this->_username = $username;
          $this->_email = $email;
          $this->_password = $password;
          $this->_confirmPassword = $confirmPassword;
      }

      public function checkPassword(){
          return (strlen($this->_password) >= 6) && ($this->_password == $this->_confirmPassword);
      }

      public function checkEmail(){
          return filter_var($this->_email, FILTER_VALIDATE_EMAIL);
      }

      public function toDb(){
        return array(
          'name' => $this->_username,
          'password' => sha1($this->_password),
          'email' => $this->_email,
          )
      }
  }

  class UserManager{
      private $_db;

      public function __construct($db){
          $this->_db = $db;
      }

      public function get($username){
          $q = $this->_db->prepare("
              SELECT *
              From users
              WHERE username = ?
          ");
          $q->execute(array(
              $username,
          ));
          return $q->fetch();
      }

      public function add(User $user){
          $q = $this->_db->prepare("
              INSERT INTO users
              (name, password, email, grade)
              VALUES
              (:name, :password, :email, ".INITIAL_GRADE.")
          ");
          $q->execute($user->toDb());
      }

}
?>

En plus, je ferait en sorte que la fonction UserManager::get renvoie un User.

+0 -0
Auteur du sujet

Voici donc ma classe:

 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
<?php
  class Register{
      private $_user;
      private $_manager;
      private $_error;

      public function __construct($user, $manager){
          $this->_user = $user;
          $this->_manager = $manager;
      }

      public function processChecking(){
          $this->_error .= "Une erreur est apparu";
      }
      public function processRegistration(){
          if(!empty($this->_error))
              $this->_manager->add($this->_user);
      }
      public function getError(){
          return $this->_error;
      }
  }

  class RegisterUser{
      private $_username;
      private $_password;
      private $_email;
      private $_confirmPassword;

      public function __construct($username, $password, $email, $confirmPassword){
          $this->_username = $username;
          $this->_password = $password;
          $this->_email = $email;
          $this->_confirmPassword = $confirmPassword;
      }

      public function getUsername(){
          return $this->_username;
      }
  }

  class RegisterManager{
      private $_db;

      public function __construct($db){
          $this->_db = $db;
      }

      public function add(RegisterUser $user){
          echo "Add user: ".$user->getUsername();
      }
  }

Et l'utilisation de la classe:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
<?php
  require 'models/authenticate/register.class.php';
  require 'models/bdd.php';

  $registerUser = new RegisterUser('WinXaito', '1234', 'kevin@winlap.ch', '1234');
  $registerManager = new RegisterManager($bdd);
  $register = new Register($registerUser, $registerManager);

  $register->processChecking();
  $register->processRegistration();

  $error = $register->getError();
  echo $error;

Maintenant je ne sais pas si j'ai soit rien compris du tout ou alors mal mis en application ou si c'est bon :p

Merci

Édité par WinXaito

+0 -0

Pour chipoter si tu veux utiliser le type-hinting, j'aurai également précisé le type de classes attendues dans le constructeur de ta classe Register, car c'est elle qui reçoit directement les instances de ton application, et non pas la classe RegisterManager :

1
public function __construct(\RegisterUser $user,\RegisterManager $manager){

Salut,

aussi pour chipoter, j'aurais mit les classes RegisterUser, RegisterManager et Register dans le namespace Register. Aussi, j'aurait suivi une norme type PSR-*, ce qui aurait signifié :

  • une classe par fichier ;
  • { à la ligne d'après ;
  • etc.
1
2
3
# <3 phpcs
phpcs --standard=PSR2 --ignore=vendor/ --colors .
phpcbf --standard=PSR2 --ignore=vendor/ --colors .

It goes against the grain of modern education to teach children to program. What fun is there in making plans, acquiring discipline in organizing thoughts, devoting attention to detail and learning to be self-critical? – Perlis

+1 -0
Vous devez être connecté pour pouvoir poster un message.
Connexion

Pas encore inscrit ?

Créez un compte en une minute pour profiter pleinement de toutes les fonctionnalités de Zeste de Savoir. Ici, tout est gratuit et sans publicité.
Créer un compte