Amélioration constructeur user + gestion des roles

Auth/authentication.py

@@ -27,20 +27,20 @@ class Auth():
         user_psswd = None
 
         #On va récupérer les infos en BDD
-        quer = "SELECT Nom FROM utilisateur"
         link = dbo.DBLink()
-        result = link.query("SELECT Nom, MdP FROM utilisateur WHERE Identifiant = %s", [self.input_id, ])
+        result = link.query("SELECT IDUtil, Nom, MdP FROM utilisateur WHERE Identifiant = %s", [self.input_id, ])
 
-        for Nom, MdP in result:
+        for id_user, nom, mdp in result:
-            user_id = Nom
+            user_id = id_user
-            user_psswd = MdP
+            user_id = nom
+            user_psswd = mdp
 
         #Si l'user ID a été trouvé
         #On compare le mot de passe entré à celui récupéré en BDD, si ça matche, on renvoie True
         if user_id != None:
             if self.input_psswd.hexdigest() == user_psswd:
                 Auth.access = True
-                Auth.current_user = user_id
+                Auth.current_user_id = id_user
                 print("Accès autorisé")
             else:
                 print("Accès refusé : Le mot de passe est incorrect")

Users/Model.py

@@ -5,23 +5,40 @@ import DB.dbLink as db
 class User:
     """Modèle utilisateur. Contient un objet utilisateur"""
 
-    def __init__(self, id):
+    def __init__(self, id='', nom='', prenom='', identifiant='', mdp='', cout='', idfonc='', fonction='', pole='', roles=dict()):
-        """Constructeur créant utilisateur à partir d'un ID"""
+        """Constructeur initialisant utilisateur à partir d'un ID ou des données indiquées"""
-        self.identifiant = id
-        self.roles = list();
 
-        #On va chercher l'user en base de données
+        #On load l'user depuis la BDD si demandé avec un ID
-        link = db.DBLink()
+        if id != '':
-        query = "SELECT u.IDUtil AS id_bdd, u.Nom AS nom, u.Prénom AS prenom, u.Identifiant AS identifiant, u.MdP AS mdp, u.SalaireBrut AS cout, u.IDFonc AS id_fonc, f.Intitulé AS fonction, p.Libelle AS pole \
+            self._id_table = id
-                FROM utilisateur AS u \
+            #On va chercher l'user en base de données
-                JOIN fonction AS f ON f.IDFonc = u.IDFonc \
+            link = db.DBLink()
-                JOIN pole AS p ON p.IDPole = p.IDPole \
+            query = "SELECT u.IDUtil AS id_bdd, u.Nom AS nom, u.Prénom AS prenom, u.Identifiant AS identifiant, u.MdP AS mdp, u.SalaireBrut AS cout, u.IDFonc AS id_fonc, f.Intitulé AS fonction, p.Libelle AS pole \
-                WHERE u.identifiant = %s"
+                    FROM utilisateur AS u \
-        result = link.query(query, [self.identifiant, ])
+                    JOIN fonction AS f ON f.IDFonc = u.IDFonc \
+                    JOIN pole AS p ON p.IDPole = p.IDPole \
+                    WHERE u.IDUtil = %s"
+            result = link.query(query, [self._id_table, ])
 
-        #On remplit l'objet à partir des éléments récupérés en BDD
+            #On hydrate l'objet à partir des éléments récupérés en BDD
-        for id_bdd, nom, prenom, identifiant, mdp, cout, id_fonc, fonction, pole in result:
+            for id_bdd, nom, prenom, identifiant, mdp, cout, id_fonc, fonction, pole in result:
-            self._id_table = id_bdd
+                self._id_table = id_bdd
+                self.fonction = fonction
+                self.pole = pole
+                self.nom = nom
+                self.prenom = prenom
+                self.identifiant = identifiant
+                self._mdp = mdp
+                self.cout = cout
+                self.id_fonc = id_fonc
+
+            #Récupération de la liste des roles
+            self.roles = dict()
+            self.get_roles()
+
+        #Sinon, on hydrate à partir des champs renseignés en paramètre
+        else :
+            self.id_fonc = idfonc
             self.fonction = fonction
             self.pole = pole
             self.nom = nom
@@ -29,31 +46,26 @@ class User:
             self.identifiant = identifiant
             self._mdp = mdp
             self.cout = cout
-            self.id_fonc = id_fonc
+            self.roles = roles
-
-        #Récupération de la liste des roles
-        self.getRoles()
-
-
-    def hydrate(self, nom, prenom, identifiant, mdp, cout, idfonc, fonction, pole):
-        """Hydratation de l'objet"""
-        self.id_fonc = idfonc
-        self.fonction = fonction
-        self.pole = pole
-        self.nom = nom
-        self.prenom = prenom
-        self.identifiant = identifiant
-        self._mdp = mdp
-        self.cout = cout
 
     def register(self):
         """Enregistrement de l'utilisateur"""
         link = db.DBLink()
+        #Enregistrement des données utilisateur
         query = "INSERT INTO utilisateur \
                 (IDFonc, Nom, Prénom, Identifiant, MdP, SalaireBrut) \
                 VALUES (%s, %s, %s, %s, %s, %s)"
         link.commit(query, [self.id_fonc, self.nom, self.prenom, self.identifiant, self._mdp, self.cout])
+        #Chargement de l'id ainsi créé
+        query = "SELECT IDUtil \
+                FROM utilisateur \
+                WHERE identifiant = %s"
+        result = link.query(query, [self.identifiant, ])
 
+        for IDUtil, in result:
+            self._id_table = IDUtil
+        #Enregistrement des roles
+        self.update_roles()
 
     def update(self):
         """Mise à jour de l'utilisateur"""
@@ -66,18 +78,19 @@ class User:
     def delete(self):
         """supprimer l'utilisateur courant"""
         link = db.DBLink()
-        query = "DELETE \
-                FROM utilisateur \
-                WHERE IDUtil = %s"
-        link.commit(query, [self._id_table, ])
 
         query = "DELETE \
                 FROM roleattribution \
                 WHERE IDUtil = %s"
         link.commit(query, [self._id_table, ])
 
+        query = "DELETE \
+                FROM utilisateur \
+                WHERE IDUtil = %s"
+        link.commit(query, [self._id_table, ])
 
-    def getRoles(self):
+
+    def get_roles(self):
         """liste des roles de l'utilisateur"""
         link = db.DBLink()
         query = "SELECT a.IDRole AS id_role, r.Libellé AS role \
@@ -87,4 +100,21 @@ class User:
         result = link.query(query, [self._id_table, ])
 
         for id_role, role in result:
-            self.roles.append((id_role, role))
+            self.roles[role] = id_role
+
+    def update_roles(self):
+        """enregistrement/mise à jour des roles de l'uitlisateur"""
+        link = db.DBLink()
+
+        #On commence par supprimer les roles actuels s'ils existent
+        query = "DELETE \
+                FROM roleattribution \
+                WHERE IDUtil = %s"
+        link.commit(query, [self._id_table, ])
+
+        #Puis on enregistre les nouveaux
+        for rol_id in self.roles.values():
+            query = "INSERT INTO roleattribution \
+                        (IDUtil, IDRole) \
+                        VALUES(%s, %s)"
+            link.commit(query, [self._id_table, rol_id])

main.py

@@ -12,7 +12,7 @@ login.fenetre.mainloop()
 #On lance le programme
 while auth.Auth.access == True:
     print("programme en cours")
-    user = U.User(auth.Auth.current_user)
+    user = U.User(auth.Auth.current_user_id)
     print("Bonjour", user.nom, user.prenom, "vous êtes dans la boucle")
 
     os.system("pause")