Relation entre plusieurs QDialog

**noureddine1967** · 27/10/2023, 18h09

Bonjour,

Je suis sur un petit projet de gestion et de consultation où j'utilise plusieurs QDialog pour afficher les différents modules de l'application.
Cependant, il y a deux modules seulement, que je souhaite que seul un administrateur peut y accéder via un nom utilisateur et mot de passe : Configuration et Importation

Voici les trois QDialog avec les scripts :

Nom : dialog1.jpg
Affichages : 167
Taille : 61,6 Ko

Nom : dialog1.jpg
Affichages : 167
Taille : 61,6 Ko

Nom : dialog2.jpg
Affichages : 152
Taille : 17,6 Ko

Nom : dialog3.jpg
Affichages : 149
Taille : 17,7 Ko

La QDialog1

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
 
class Fenetre(QMainWindow):
 
    def __init__(self, parent=None):
        super(Fenetre, self).__init__(parent)
 
        self.ui = Ui_Fenetre_c2trl_v2()
        self.ui.setupUi(self)
 
    # -----------------------Bouttons outils--------------------------------------------------------------
 
        self.ui.tb_tableau_bord.clicked.connect(self.afficher_tb)
        self.ui.tb_evolution_ventes.clicked.connect(self.afficher_evol)
        self.ui.tb_Analyses.clicked.connect(self.afficher_analyses)
        self.ui.tb_liste_clients.clicked.connect(self.afficher_clients)
        self.ui.tb_importation.clicked.connect(self.afficher_imporations)
 
    # ----------------------------------------------------------------------------------------------------
 
    def afficher_tb(self):
        self.Dialog_tb = Dialogtb()
        self.Dialog_tb.show()
        self.Dialog_tb.exec_()
 
    # ----------------------------------------------------------------------------------------------------
    def afficher_evol(self):
        self.Dialog_evol = Dialogevol()
        self.Dialog_evol.show()
        self.Dialog_evol.exec_()
 
    # ----------------------------------------------------------------------------------------------------
    def afficher_analyses(self):
        self.Dialog_analyses = Dialoganalyses()
        self.Dialog_analyses.show()
        self.Dialog_analyses.exec_()
 
    # ----------------------------------------------------------------------------------------------------
 
    def afficher_clients(self):
        self.Dialog_clients = Dialogclients()
        self.Dialog_clients.show()
        self.Dialog_clients.exec_()
 
        # ----------------------------------------------------------------------------------------------------
 
    def afficher_imporations(self):
        self.Dialog_imporation = Dialogimporation()
        self.Dialog_imporation.show()
        self.Dialog_imporation.exec_()
 
    # ----------------------------------------------------------------------------------------------------
    def sortir(self):
        reponse = QtWidgets.QMessageBox.question(self, "Vous voulez fermer l\'application ?",
                                                 buttons=QtWidgets.QMessageBox.Yes |
                                                 QtWidgets.QMessageBox.No |
                                                 QtWidgets.QMessageBox.Cancel,
                                                 defaultButton=QtWidgets.QMessageBox.NoButton)
        if reponse == QtWidgets.QMessageBox.Yes:
            self.close()
 
# ------------------------------------------------------------------------------------------------------
 
 
if __name__ == "__main__":
    app = QtWidgets.QApplication(sys.argv)
 
    QtCore.qInstallMessageHandler(messagederreur)
    fenetre = Fenetre()
    fenetre.show()
    sys.exit(app.exec_())

La QDialog 2

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
 
 
import mysql.connector
from PyQt5 import Qt
from PyQt5 import QtWidgets
from PyQt5.QtCore import Qt
from PyQt5.QtWidgets import (QDialog, QButtonGroup)
from PyQt5.QtWidgets import (QMessageBox, QFileDialog)
 
import reading_config_file as param
from UI.import_ui import Ui_Dialog_importation
from autorisation import Dialogautorisation
 
 
 
def autorise(self):
 
    self.login_dialog = Dialogautorisation()
    self.login_dialog.show()
    self.login_dialog.exec_()  # Afficher la boîte de dialogue et attendre la réponse.
 
    if self.login_dialog.login_successful:
        print("L'utilisateur s'est connecté avec succès.")
    else:
        print("L'utilisateur a annulé la connexion.")
        self.close()
        self.reject()
 
 
class Dialogimporation(QDialog):
 
    def __init__(self):
        super().__init__()
 
        autorise(self) # lancer la boite de dialogue si accès autorisé la Dialogimportation s'ouvre sinon vers la sortie
 
        self.login_dialog = None
        self.ui = Ui_Dialog_importation()
        self.ui.setupUi(self)
 
        self.login_dialog = None
        .....

Et la QDialog 3 :

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
 
class Dialogautorisation(QDialog):
 
    def __init__(self):
        super().__init__()
 
        self.ui = Ui_Dialog_admin()
        self.ui.setupUi(self)
 
        self.ui.toolButton_valid.clicked.connect(self.accepter)
        self.ui.toolButton_cancel.clicked.connect(self.annuler)
 
        self.cnx = None
        self.cur = None
 
        self.login_successful = False
 
    def accepter(self):
 
        username = self.ui.lineEdit_user_name.text()
        userpassword = self.ui.lineEdit_password.text()
 
        # Vérifie si les champs sont vides
 
        if not username or not userpassword:
            QMessageBox.warning(self, 'Erreur', 'Veuillez remplir tous les champs.')
            return
 
        self.cnx = mysql.connector.connect(host=param.host,
                                           database=param.database,
                                           user=param.user,
                                           password=param.password,
                                           port=param.port)
        self.cur = self.cnx.cursor()
 
        self.cur.execute('SELECT * '
                         'FROM users '
                         'WHERE user_name = "' + username + '" AND password = "' + userpassword + '" ')
 
        if self.cur.fetchone():
            self.login_successful = True
            self.accept()
 
        else:
            self.login_successful = False
            QMessageBox.warning(self, 'Échec', 'Nom utilisateur ou mot de passe erroné !!!')
            self.cur.close()
            self.cnx.close()
            self.reject()
 
    def annuler(self):
        result = QMessageBox.question(self, 'Confirmation', 'Voulez-vous vraiment annuler ?',
                                      QMessageBox.Yes | QMessageBox.No)
        if result == QMessageBox.Yes:
            if self.cnx is not None:
                self.cnx.close()
                self.reject()

Tout le processus marche très bien si je clique sur le bouton importation la Qdialog autorisation s'affiche et quand je saisie user_name et password ça fonctionne et la QDialog importation s'affiche le plus normal du monde
Le problème que j'ai remarqué c'est dans je clique sur le bouton annuler pour sortir complètement de la QDialog autorisation sa ne sort pas
et le pire quand je ferme manuellement la QDialog autorisation il m'affiche la QDiaog importation !!!

Est ce que j'ai oublié quelque chose ? ou bien j'ai mal écrit mon code.

**Sve@r** · 27/10/2023, 18h29

Bonjour
Je lis le code un peu en diagonale. De ce que je vois, le souci se situe sur les lignes self.cnx.close() et self.reject() de la fonction annuler().
Mais il y a ces mêmes lignes quand l'utilisateur entre un mauvais mot de passe. Donc s'il entre un mauvais mot de passe, ça devrait poser le même souci non ? Qu'en est-il alors dans ce cas ?
Il faut aussi m'expliquer pourquoi tu testes if self.cnx is not None dans annuler() et surtout pourquoi tu conditionnes le reject() du QDialog à cette condition. Parce que ça signifie que si cnx est None, le QDialog ne fait rien.

Petit détail: pas besoin de sélectionner une info en bdd pour juste tester si l'info a été sélectionnée. Tu peux utiliser count(*) qui va bien plus vite. Il y a même, sous postgres, l'instruction "perform" qui permet de faire "comme un select" mais qui renvoie juste un flag indiquant si le select a marché ou pas (mais existe-t-il sous MySQL...?)

Et enfin il semble que le mot de passe soit stocké en clair en bdd ce qui est une grosse faille de sécurité. La méthode sécurisée est de stocker son hash puis tester si le hash du mot entré correspond au hash du mot stocké. Surtout que généralement les bdd possèdent une fonction "hash()" qui peut faire le job.

**noureddine1967** · 27/10/2023, 19h52

Bonjour Sve@r et merci pour votre gentillesse,

Je lis le code un peu en diagonale. De ce que je vois, le souci se situe sur les lignes self.cnx.close() et self.reject() de la fonction annuler().
Mais il y a ces mêmes lignes quand l'utilisateur entre un mauvais mot de passe. Donc s'il entre un mauvais mot de passe, ça devrait poser le même souci non ? Qu'en est-il alors dans ce cas ?
Il faut aussi m'expliquer pourquoi tu testes if self.cnx is not None dans annuler() et surtout pourquoi tu conditionnes le reject() du QDialog à cette condition. Parce que ça signifie que si cnx est None, le QDialog ne fait rien.

Vous avez raison, j'ai pas remarqué ce bug

Petit détail: pas besoin de sélectionner une info en bdd pour juste tester si l'info a été sélectionnée. Tu peux utiliser count(*) qui va bien plus vite. Il y a même, sous postgres, l'instruction "perform" qui permet de faire "comme un select" mais qui renvoie juste un flag indiquant si le select a marché ou pas (mais existe-t-il sous MySQL...?)

Je vais chercher

Et enfin il semble que le mot de passe soit stocké en clair en bdd ce qui est une grosse faille de sécurité. La méthode sécurisée est de stocker son hash puis tester si le hash du mot entré correspond au hash du mot stocké. Surtout que généralement les bdd possèdent une fonction "hash()" qui peut faire le job.

Pour le moment, je suis entrain de voir comment les QDialog communique et après je pencherais sur la sécurité de la DBB

Pour le moment j'ai éliminé le problème d'accès en cas de mot de passe erroné et j'ai apporter les corrections sur les anomalies que vous avez signalées :

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
# -*- coding: utf-8 -*-
# La page Dialog autorisation d'accès aux modules configuration et imporation
 
import mysql.connector
from PyQt5.QtWidgets import (QDialog)
from PyQt5.QtWidgets import (QMessageBox)
 
import reading_config_file as param
from UI.admin_ui import Ui_Dialog_admin
 
 
class Dialogautorisation(QDialog):
 
    def __init__(self):
        super().__init__()
 
        self.ui = Ui_Dialog_admin()
        self.ui.setupUi(self)
 
        self.ui.toolButton_valid.clicked.connect(self.accepter)
        self.ui.toolButton_cancel.clicked.connect(self.annuler)
 
        self.cnx = None
        self.cur = None
 
    def accepter(self):
 
        username = self.ui.lineEdit_user_name.text()
        userpassword = self.ui.lineEdit_password.text()
 
        if not username or not userpassword:
            QMessageBox.warning(self, 'Erreur', 'Veuillez remplir tous les champs.')
            return
 
        self.cnx = mysql.connector.connect(host=param.host,
                                           database=param.database,
                                           user=param.user,
                                           password=param.password,
                                           port=param.port)
        self.cur = self.cnx.cursor()
 
        self.cur.execute('SELECT user_name, password '
                         'FROM users '
                         'WHERE user_name = "' + username + '" AND password = "' + userpassword + '" ')
 
        permis = self.cur.fetchone()
 
        if permis is None:
            QMessageBox.warning(self, 'Échec', 'Nom utilisateur ou mot de passe erroné !!!')
        else:
            self.accept()
 
    def annuler(self):
        result = QMessageBox.question(self, 'Confirmation', 'Voulez-vous vraiment annuler ?',
                                      QMessageBox.Yes | QMessageBox.No)
        if result == QMessageBox.Yes:
            self.close()

Mais le problème d'accès à la QDialog importation persiste en cas de clique sur bouton annuler ; franchement je ne vois pas le problème où est !!!

**Sve@r** · 27/10/2023, 20h30

Envoyé par noureddine1967

Mais le problème d'accès à la QDialog importation persiste en cas de clique sur bouton annuler ; franchement je ne vois pas le problème où est !!!

Me semble qu'il faut quand-même un reject sur annuler()...

J'aurais mieux vu la fin de "accepter()" ainsi

Code python :

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

1
2
3
if permis is not None: self.accept()
QMessageBox.warning(self, 'Échec', 'Nom utilisateur ou mot de passe erroné !!!')
self.reject()

Et la fonction annuler ainsi

Code python :

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

1
2
3
4
def annuler(self):
	if QMessageBox.question(self, 'Confirmation', 'Voulez-vous vraiment annuler ?',
                                      QMessageBox.Yes | QMessageBox.No) != QMessageBox.Yes: return
	self.reject()

**noureddine1967** · 29/10/2023, 10h00

Bonjour Sve@r,

Excusez moi pour le retard de vous répondre.
J'ai effectué les suggestions que vous m'avez proposer, c'est le même constat

**Sve@r** · 29/10/2023, 10h40

Envoyé par noureddine1967

c'est le même constat

Chez-moi ça marche !!!

Code python :

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
#!/usr/bin/env python3
# coding: utf-8
 
from PyQt5.QtCore import *
from PyQt5.QtGui import *
from PyQt5.QtWidgets import *
import sys
 
# L'objet pour gérer mon appli
class myAppli(QApplication):
	# Constructeur
	def __init__(self, *args, **kwargs):
		# Appel méthode objet hérité
		super().__init__(*args, **kwargs)
 
		# Le widget principal
		self.__mainWidget=myMainWindow()
	# __init__()
 
	# Lancement boucle de traitement des évènements Qt
	def exec_(self):
		# Affichage du widget principal
		self.__mainWidget.show()
 
		# Appel méthode objet hérité
		return super().exec_()
	# exec_()
# class myAppli
 
# L'objet pour gérer ma fenêtre principale
class myMainWindow(QMainWindow):
	# Constructeur
	def __init__(self, *args, **kwargs):
		# Appel méthode objet hérité
		super().__init__(*args, **kwargs)
 
		# La fenêtre sera détruite à sa fermeture
		self.setAttribute(Qt.WA_DeleteOnClose)
 
		# Le widget associé au mainWindow
		self.setCentralWidget(QWidget(parent=self))
 
		# Le bouton
		btn=QPushButton("Clients", parent=self.centralWidget(), clicked=self.__slotClient)
		quitter=QPushButton("Quitter", parent=self.centralWidget(), clicked=self.close)
 
		# Le gestionnaire de positionnement principal
		mainLayout=QVBoxLayout(self.centralWidget())
		mainLayout.addWidget(btn, stretch=0)
		mainLayout.addStretch(1)
		mainLayout.addWidget(quitter, stretch=0)
	# __init__()
 
	# Le slot appel du client
        @pyqtSlot()
	def __slotClient(self):
		# Boite de connexion
		print("client")
		self.__xxx=myConnect(login="Hello", pwd="Word")
		res=self.__xxx.exec_()
		print("entrée ok" if res else "entrée refusée")
	# __slotClient
# class myMainWindow
 
# L'objet pour gérer ma fenêtre de connexion
class myConnect(QDialog):
	# Constructeur
	def __init__(self, login, pwd, *args, **kwargs):
		# Appel méthode objet hérité
		super().__init__(*args, **kwargs)
 
		# La fenêtre sera détruite à sa fermeture
		self.setAttribute(Qt.WA_DeleteOnClose)
 
		# La fenêtre est modale
		self.setModal(True)
 
		# Login et mot de passe
		self.__param=(login, pwd)
 
		# La zone login
		loginLabel=QLabel("login", parent=self)
		self.__loginText=QLineEdit(login, parent=self)
		loginLayout=QHBoxLayout()
		loginLayout.addWidget(loginLabel, stretch=0)
		loginLayout.addWidget(self.__loginText, stretch=1)
 
		# La zone pwd
		pwdLabel=QLabel("password", parent=self)
		self.__pwdText=QLineEdit(pwd, parent=self)
		pwdLayout=QHBoxLayout()
		pwdLayout.addWidget(pwdLabel, stretch=0)
		pwdLayout.addWidget(self.__pwdText, stretch=1)
 
		# Les boutons
		valid=QPushButton("Valider", parent=self, clicked=self.__slotCheck)
		annul=QPushButton("Annuler", parent=self, clicked=self.close)
		actionLayout=QHBoxLayout()
		actionLayout.addStretch(1)
		actionLayout.addWidget(valid, stretch=0)
		actionLayout.addWidget(annul, stretch=0)
		actionLayout.addStretch(1)
 
		# Le gestionnaire de positionnement principal
		mainLayout=QVBoxLayout(self)
		mainLayout.addLayout(loginLayout, stretch=0)
		mainLayout.addLayout(pwdLayout, stretch=0)
		mainLayout.addLayout(actionLayout, stretch=0)
		mainLayout.addStretch(1)
	# __init__()
 
	# Evènement fermeture fenêtre (méthode surchargée)
	def closeEvent(self, event):
		print(
			"%s => %s.closeEvent(%s)" % (
				self.sender().__class__.__name__,
				self.__class__.__name__,
				"%s (%s)" % (event.__class__.__name__, type(event)),
			)
		)
 
		# Confirmation quitter
		if QMessageBox.question(
			self,
			"Confirmation",
			"Confirmez-vous vouloir quitter ?",
			QMessageBox.Yes|QMessageBox.No,
		) != QMessageBox.Yes:
			# Refus de l'évènement (refus de la fermeture)
			event.ignore()
 
			# La fonction s'arrête là
			return
		# if
		self.reject()
	# closeEvent()
 
	# Check mot de passe
        @pyqtSlot()
	def __slotCheck(self):
		if (self.__loginText.text(), self.__pwdText.text()) == self.__param:
			QMessageBox.information(
				self,
				"Accepté",
				"Entrée ok",
				QMessageBox.Ok,
			)
			self.accept()
		else:
			QMessageBox.warning(
				self,
				"Refusé",
				"Entrée refusée",
				QMessageBox.Ok,
			)
			self.reject()
		# if
	# __slotCheck()
# class myConnect
 
if __name__ == "__main__":
	sys.exit(myAppli(sys.argv).exec_())

**papajoker** · 29/10/2023, 11h19

bonjour

si tu as écrit texto le code plus haut #4, c'est normal ! Dans ton code tu ne testes JAMAIS si un de tes dialogues retourne OK ou "non". Donc le code de Sve@r qui n'utilise que self.reject() et self.accept() ne sert à rien

Même chose pour ton code d'origine: pas possible de le comprendre sans perdre mes cheveux car il semble utiliser partout ces 2 méthodes et semble aussi les ignorer partout ...

Note:
- Tu sembles ne vouloir rien garder de la connexion. Donc il faut toujours la fermer (ok ou annuler)
- utilisation de self.variable inutiles
- faut-il tester que le user est bien un administrateur ? pas fait dans la requete
- Pas bon de retourner l'id de l'administrateur ? généralement on le passe après dans les taches pour un suivi (c'est TOTO qui a supprimé machin, est mieux que : un admin a supprimé machin)

Relation entre plusieurs QDialog

PyQt Python

Vue hybride

Discussions similaires

Partager

Partager