Ajout du système pour mandater et mise en page des documents

27 files changed, 1102 insertions, 985 deletions

diff --git a/src/core/__init__.py b/src/app/__init__.py
index e69de29..e69de29 100644
--- a/src/core/__init__.py
+++ b/src/app/__init__.py
diff --git a/src/app/mainHome.py b/src/app/mainHome.py
new file mode 100644
index 0000000..a366c66
--- /dev/null
+++ b/src/app/mainHome.py
@@ -0,0 +1,155 @@
+
+from PyQt5.QtWidgets import (
+    QGroupBox,   QPushButton,
+    QComboBox,   QLineEdit,
+    QHBoxLayout, QWidget,
+    QVBoxLayout, QLabel,
+    QMessageBox
+)
+from src.app import (
+    mainLogin,  mainRegister,
+    mainMenuBar, windowRecherche,
+    mainLogout
+)
+from src.database.dbsearch import DbSearch
+
+
+def core_search_id(mainWindow: object, jobId: int) -> None:
+    """"""
+    dbsearch:     object = DbSearch(mainWindow)
+    resRecherche: list   = dbsearch.get_all_pro_by_jobid(jobId)
+    if resRecherche:
+        core_search_main(mainWindow, resRecherche)
+    else:
+        QMessageBox.information(
+            mainWindow,
+            "Résultat",
+            "Aucun résultat."
+        )
+
+
+def core_search_name(mainWindow: object, name: str) -> None:
+    """"""
+    dbsearch:     object = DbSearch(mainWindow)
+    resRecherche: tuple  = dbsearch.get_pro_info_by_lastname(name)
+    if resRecherche:
+        core_search_main(mainWindow, resRecherche)
+    else:
+        QMessageBox.information(
+            mainWindow,
+            "Résultat",
+            "Aucun résultat."
+        )
+
+
+def core_search_main(mainWindow: object, resRecherche: tuple) -> None:
+    """"""
+    dbsearch: object = DbSearch(mainWindow)
+    results:  list   = []
+    for i in resRecherche:
+        proInfo: dict = {}
+        proInfo["id"] = i[0]
+        resJobs = dbsearch.get_pro_job_by_proid(proInfo["id"])
+        proInfo["text"] = list(i[1:])
+        proInfo["text"].insert(2, ", ".join([j[2] for j in resJobs]))
+        proInfo["text"] = " - ".join(proInfo["text"])
+        results.append(proInfo)
+
+    windowRecherche.window_main(mainWindow, results)
+
+
+def window_main(mainWindow, reloadMenu = False) -> None:
+    """"""
+    if reloadMenu:
+        mainMenuBar.menu_init(mainWindow)
+
+    dbsearch: object = DbSearch(mainWindow)
+    #
+    if not mainWindow.userConnected:
+        connState: object = QLabel("Non connecté.")
+    else:
+        connState: object = QLabel(
+            f"Connecté: {mainWindow.userEmail} - {mainWindow.userStatus}"
+        )
+
+    if not mainWindow.userConnected:
+        btnConnexion: object = QPushButton("Connexion")
+        btnConnexion.clicked.connect(lambda: mainLogin.window_main(mainWindow))
+    else:
+        btnDeconnexion: object = QPushButton("Déconnexion")
+        btnDeconnexion.clicked.connect(lambda: [
+            mainLogout.core_logout(mainWindow),
+            window_main(mainWindow, True)
+            ]
+        )
+
+    btnInscription: object = QPushButton("Inscription")
+    btnInscription.clicked.connect(lambda: mainRegister.window_main(mainWindow))
+    #
+    layUser: object = QHBoxLayout()
+    layUser.addStretch()
+    layUser.addWidget(btnInscription)
+    if not mainWindow.userConnected:
+        layUser.addWidget(btnConnexion)
+    else:
+        layUser.addWidget(btnDeconnexion)
+
+    grpUser: object = QGroupBox("Gestion de l'utilisateur")
+    grpUser.setLayout(layUser)
+    #
+    labRechercheNom:   object = QLabel("Par nom")
+    inputRechercheNom: object = QLineEdit(maxLength=128)
+    btnRechercheNom:   object = QPushButton("Rechercher")
+    btnRechercheNom.clicked.connect(
+        lambda:
+            core_search_name(
+                mainWindow,
+                inputRechercheNom.text()
+            )
+    )
+    labRechercheCat: object = QLabel("Par emploi")
+    cmbRechercheCat: object = QComboBox()
+    alljobs:         list   = dbsearch.get_job_all()
+    for i in alljobs:
+        cmbRechercheCat.addItem("{0}".format(i[2]), i[0])
+    btnRechercheCat: object = QPushButton("Rechercher")
+    btnRechercheCat.clicked.connect(
+        lambda:
+            core_search_id(
+                mainWindow,
+                cmbRechercheCat.currentData()
+            )
+    )
+    #
+    layRechercheNom: object = QVBoxLayout()
+    layRechercheNom.addWidget(labRechercheNom)
+    layRechercheNom.addWidget(inputRechercheNom)
+    layRechercheNom.addWidget(btnRechercheNom)
+    layRechercheCat: object = QVBoxLayout()
+    layRechercheCat.addWidget(labRechercheCat)
+    layRechercheCat.addWidget(cmbRechercheCat)
+    layRechercheCat.addWidget(btnRechercheCat)
+    #
+    layRecherche: object = QHBoxLayout()
+    layRecherche.addStretch()
+    layRecherche.addLayout(layRechercheNom)
+    layRecherche.addStretch()
+    layRecherche.addLayout(layRechercheCat)
+    layRecherche.addStretch()
+    #
+    grpRecherche: object = QGroupBox("Recherche")
+    grpRecherche.setLayout(layRecherche)
+    #
+    layMain: object = QVBoxLayout()
+    layMain.addWidget(connState)
+    layMain.addWidget(grpUser)
+    layMain.addStretch()
+    layMain.addWidget(grpRecherche)
+    layMain.addStretch()
+    #
+    if hasattr(mainWindow, "mainWidget"):
+        mainWindow.mainWidget.deleteLater()
+
+    mainWindow.mainWidget = QWidget()
+    mainWindow.mainWidget.setLayout(layMain)
+    mainWindow.setCentralWidget(mainWindow.mainWidget)
diff --git a/src/app/mainLogin.py b/src/app/mainLogin.py
new file mode 100644
index 0000000..617df73
--- /dev/null
+++ b/src/app/mainLogin.py
@@ -0,0 +1,113 @@
+
+from PyQt5.QtWidgets import (
+    QPushButton, QHBoxLayout,
+    QGroupBox,   QLabel,
+    QLineEdit,   QWidget,
+    QVBoxLayout, QGridLayout,
+    QMessageBox
+)
+from src.app import mainHome, mainRegister
+from src.database.dbuser   import DbUser
+from src.database.dbsearch import DbSearch
+
+
+def core_login(mainWindow: object, email: str, password: str) -> None:
+    """"""
+    dbuser:   object = DbUser(mainWindow)
+    dbsearch: object = DbSearch(mainWindow)
+    if dbuser.check_exist_email(email):
+        userId = dbuser.check_user_credential(email, password)
+        if userId:
+            userAccount = dbsearch.get_user_account_by_userid(userId)[0]
+            QMessageBox.information(
+                mainWindow,
+                "Connexion",
+                "Vous êtes connecté"
+            )
+            mainWindow.userConnected = True
+            mainWindow.userId        = userId
+            mainWindow.userEmail     = userAccount[1]
+            mainWindow.userInscrDate = userAccount[2]
+            if userAccount[3] == 0:
+                mainWindow.userStatus = "Admin"
+            elif userAccount[3] == 1:
+                mainWindow.userStatus = "Pro"
+            elif userAccount[3] == 2:
+                mainWindow.userStatus = "Client"
+            mainHome.window_main(mainWindow, True)
+        else:
+            QMessageBox.warning(
+                mainWindow,
+                "Connexion",
+                "Mauvaise combinaison mail & mot de passe"
+            )
+    else:
+        QMessageBox.warning(
+            mainWindow,
+            "Connexion",
+            "Mauvais email"
+        )
+
+
+def window_main(mainWindow: object) -> None:
+    """"""
+    if not mainWindow.userConnected:
+        connState: object = QLabel("Non connecté.")
+    else:
+        connState: object = QLabel(
+            f"Connecté: {mainWindow.userEmail} - {mainWindow.userStatus}"
+        )
+
+    btnAccueil: object = QPushButton("Accueil")
+    btnAccueil.clicked.connect(lambda: mainHome.window_main(mainWindow))
+    btnInscription: object = QPushButton("Inscription")
+    btnInscription.clicked.connect(lambda: mainRegister.window_main(mainWindow))
+    #
+    layUser: object = QHBoxLayout()
+    layUser.addWidget(btnAccueil)
+    layUser.addStretch()
+    layUser.addWidget(btnInscription)
+    grpUtilisateur: object = QGroupBox("Gestion de l'utilisateur")
+    grpUtilisateur.setLayout(layUser)
+    #
+    labMail:     object = QLabel("Email")
+    inpMail:     object = QLineEdit(maxLength=128)
+    labPassword: object = QLabel("Mot de passe")
+    inpPassword: object = QLineEdit(maxLength=128)
+    inpPassword.setEchoMode(QLineEdit.Password)
+    btnConnexion:  object = QPushButton("Connexion")
+    btnConnexion.clicked.connect(
+        lambda:
+            core_login(
+                mainWindow,
+                inpMail.text(),
+                inpPassword.text()
+            )
+    )
+    #
+    layGrid: object = QGridLayout()
+    layGrid.addWidget(labMail,      0, 0)
+    layGrid.addWidget(inpMail,      0, 1)
+    layGrid.addWidget(labPassword,  1, 0)
+    layGrid.addWidget(inpPassword,  1, 1)
+    layGrid.addWidget(btnConnexion, 2, 1)
+    #
+    layLogin: object = QHBoxLayout()
+    layLogin.addStretch()
+    layLogin.addLayout(layGrid)
+    layLogin.addStretch()
+    #
+    grpLogin: object = QGroupBox("Connexion")
+    grpLogin.setLayout(layLogin)
+    #
+    layMain: object = QVBoxLayout()
+    layMain.addWidget(connState)
+    layMain.addWidget(grpUtilisateur)
+    layMain.addStretch()
+    layMain.addWidget(grpLogin)
+    layMain.addStretch()
+    #
+    mainWindow.mainWidget.deleteLater()
+    mainWindow.mainWidget = QWidget()
+    mainWindow.mainWidget.setLayout(layMain)
+    mainWindow.setCentralWidget(mainWindow.mainWidget)
diff --git a/src/app/mainLogout.py b/src/app/mainLogout.py
new file mode 100644
index 0000000..4df4273
--- /dev/null
+++ b/src/app/mainLogout.py
@@ -0,0 +1,18 @@
+
+from PyQt5.QtWidgets  import QMessageBox
+
+
+def core_logout(mainWindow: object) -> None:
+    """"""
+    if mainWindow.userConnected == True:
+        mainWindow.userConnected = False
+        mainWindow.userId        = ""
+        mainWindow.userEmail     = ""
+        mainWindow.userInscrDate = ""
+        mainWindow.userStatus    = ""
+
+    QMessageBox.information(
+        mainWindow,
+        "Déconnection",
+        "Vous êtes déconnecté."
+    )
diff --git a/src/gui/globalMenu.py b/src/app/mainMenuBar.py
index 4625a54..3ab0090 100644
--- a/src/gui/globalMenu.py
+++ b/src/app/mainMenuBar.py
@@ -1,11 +1,16 @@
 
 from os.path import join
 from pathlib import Path
-from PyQt5.QtGui import QIcon
+from PyQt5.QtGui     import QIcon
 from PyQt5.QtWidgets import QAction
-from src.gui import windowAPropos, windowAdmin, windowUserInfo, windowMissions
+from src.app import (
+    windowAPropos,  windowAdmin,
+    windowUserInfo, windowMissions
+)
 
-def init(mainWindow):
+
+def menu_init(mainWindow: object) -> None:
+    """"""
     logo: str = join(Path(__file__).parent, "ressources", "icon.ico")
     mainWindow.setWindowIcon(QIcon(logo))
     mainWindow.setWindowTitle("Alphajob")
@@ -16,9 +21,9 @@ def init(mainWindow):
         btnEmplois:  object = QAction("Gestion des emplois", mainWindow)
         btnUsers:    object = QAction("Gestion des Utilisateurs", mainWindow)
         btnMissions: object = QAction("Gestion des missions", mainWindow)
-        btnEmplois.triggered.connect(lambda: windowAdmin.admin_emplois(mainWindow))
-        btnUsers.triggered.connect(lambda: windowAdmin.admin_users(mainWindow))
-        btnMissions.triggered.connect(lambda: windowAdmin.admin_missions(mainWindow))
+        btnEmplois.triggered.connect(lambda: windowAdmin.window_admin_emplois(mainWindow))
+        btnUsers.triggered.connect(lambda: windowAdmin.window_admin_users(mainWindow))
+        btnMissions.triggered.connect(lambda: windowAdmin.window_admin_missions(mainWindow))
         menuAdmin.addAction(btnEmplois)
         menuAdmin.addAction(btnUsers)
         menuAdmin.addAction(btnMissions)
@@ -27,22 +32,21 @@ def init(mainWindow):
         # Infos
         menuUserInfos: object = menu.addMenu("Mes infos")
         btnMesInfos:   object = QAction("Gérer ses infos", mainWindow)
-        btnMesInfos.triggered.connect(lambda: windowUserInfo.modif_infos(mainWindow))
+        btnMesInfos.triggered.connect(lambda: windowUserInfo.window_main(mainWindow))
         menuUserInfos.addAction(btnMesInfos)
         # Missions
         menuMissions:        object = menu.addMenu("Mes missions")
         btnPendingMission:   object = QAction("Missions en attente", mainWindow)
         btnOngoignMission:   object = QAction("Missions en cours", mainWindow)
         btnCompletedMission: object = QAction("Missions en terminées", mainWindow)
-        btnPendingMission.triggered.connect(lambda: windowMissions.main(mainWindow, "pending"))
-        btnOngoignMission.triggered.connect(lambda: windowMissions.main(mainWindow, "ongoing"))
-        btnCompletedMission.triggered.connect(lambda: windowMissions.main(mainWindow, "completed"))
+        btnPendingMission.triggered.connect(lambda: windowMissions.window_main(mainWindow, "pending"))
+        btnOngoignMission.triggered.connect(lambda: windowMissions.window_main(mainWindow, "ongoing"))
+        btnCompletedMission.triggered.connect(lambda: windowMissions.window_main(mainWindow, "completed"))
         menuMissions.addAction(btnPendingMission)
         menuMissions.addAction(btnOngoignMission)
         menuMissions.addAction(btnCompletedMission)
 
-
     menuOptions: object = menu.addMenu("Options")
     btnApropos:  object = QAction("A propos", mainWindow)
-    btnApropos.triggered.connect(lambda: windowAPropos.main(mainWindow))
+    btnApropos.triggered.connect(lambda: windowAPropos.window_main(mainWindow))
     menuOptions.addAction(btnApropos)
diff --git a/src/app/mainRegister.py b/src/app/mainRegister.py
new file mode 100644
index 0000000..ce9486f
--- /dev/null
+++ b/src/app/mainRegister.py
@@ -0,0 +1,177 @@
+
+import re
+from PyQt5.QtWidgets import (
+    QPushButton, QHBoxLayout,
+    QGroupBox,   QLabel,
+    QLineEdit,   QWidget,
+    QVBoxLayout, QComboBox,
+    QGridLayout, QMessageBox
+)
+from src.app import mainLogin, mainHome, mainLogout
+from src.database.dbuser import DbUser
+
+
+def core_register(mainWindow: object, email: str, password: str, userStatus: str) -> None:
+    """"""
+    dbuser:     object = DbUser(mainWindow)
+    regNumb:    str    = "[0-9]"
+    regUpper:   str    = "[A-Z]"
+    regSpecial: str    = "[`!@#$%^&*()_+\-=\[\]{};':\"\\|,.<>\/?~µ°€£]"
+    regEmail:   str    = "^[a-z0-9._-]+@[a-z0-9-]+\.[a-z]+"
+    # Si vide
+    if not email:
+        QMessageBox.warning(
+            mainWindow,
+            "Email invalide",
+            "Veuillez renseigner un email"
+        )
+        return
+
+    if not password:
+        QMessageBox.warning(
+            mainWindow,
+            "Mot de passe invalide",
+            "Veuillez renseigner un mot de passe"
+        )
+        return
+
+    if userStatus == None:
+        QMessageBox.warning(
+            mainWindow,
+            "Mauvais rôle",
+            "Veuillez selectionner un rôle"
+        )
+        return
+
+    # les regex
+    if not re.fullmatch(regEmail, email):
+        QMessageBox.warning(
+            mainWindow,
+            "Email invalid",
+            "Email non conforme"
+        )
+        return
+
+    if len(password) < 8\
+            or not re.search(regNumb, password)\
+            or not re.search(regUpper, password)\
+            or not re.search(regSpecial, password):
+        QMessageBox.warning(
+            mainWindow,
+            "Mot de passe invalide",
+            ("Le mot de passe doit avoir:\n"
+            "-Au moins 8 characters\n"
+            "-Une majuscule\n"
+            "-Un chiffre\n"
+            "-Un character spécial")
+        )
+        return
+
+    # si email deja présent
+    if dbuser.check_exist_email(email):
+        QMessageBox.warning(
+            mainWindow,
+            "Email invalid",
+            "Email déja utilisé"
+        )
+        return
+
+    succes: int = dbuser.register_user(email, password, userStatus)
+    if succes:
+        QMessageBox.information(
+            mainWindow,
+            "Inscription",
+            "Inscription réussie!"
+        )
+        mainHome.window_main(mainWindow)
+    else:
+        QMessageBox.warning(
+            mainWindow,
+            "Erreur bdd",
+            "Erreur lors de l'inscritpion"
+        )
+
+
+def window_main(mainWindow: object) -> None:
+    """"""
+    if not mainWindow.userConnected:
+        connexionState: object = QLabel("Non connecté.")
+    else:
+        connexionState: object = QLabel(
+            f"Connecté: {mainWindow.userEmail} - {mainWindow.userStatus}"
+        )
+
+    btnAccueil: object = QPushButton("Accueil")
+    btnAccueil.clicked.connect(lambda: mainHome.window_main(mainWindow))
+    #
+    if not mainWindow.userConnected:
+        btnConnexion:   object = QPushButton("Connexion")
+        btnConnexion.clicked.connect(lambda: mainLogin.window_main(mainWindow))
+    else:
+        btnDeconnexion: object = QPushButton("Déconnexion")
+        btnDeconnexion.clicked.connect(
+            lambda: [
+                mainLogout.core_logout(mainWindow),
+                mainHome.window_main(mainWindow, True)
+            ]
+        )
+
+    layoutUser: object = QHBoxLayout()
+    layoutUser.addWidget(btnAccueil)
+    layoutUser.addStretch()
+    if not mainWindow.userConnected:
+        layoutUser.addWidget(btnConnexion)
+    else:
+        layoutUser.addWidget(btnDeconnexion)
+
+    grpUtilisateur: object = QGroupBox("Gestion de l'utilisateur")
+    grpUtilisateur.setLayout(layoutUser)
+    #
+    labMail:       object = QLabel("Email")
+    leditMail:     object = QLineEdit(maxLength=128)
+    labPassword:   object = QLabel("Mot de passe")
+    leditPassword: object = QLineEdit(maxLength=128)
+    leditPassword.setEchoMode(QLineEdit.Password)
+    labStatus:   object = QLabel("Rôle")
+    comboStatus: object = QComboBox()
+    comboStatus.addItem("Admin", 0)
+    comboStatus.addItem("Pro", 1)
+    comboStatus.addItem("Client", 2)
+    #
+    btnRegister: object = QPushButton("S'inscrire")
+    btnRegister.clicked.connect(
+        lambda: core_register(
+            mainWindow,
+            leditMail.text(),
+            leditPassword.text(),
+            comboStatus.currentData()
+        )
+    )
+    #
+    LayoutInfoConnexion:  object = QGridLayout()
+    LayoutInfoConnexion.addWidget(labMail, 0, 0)
+    LayoutInfoConnexion.addWidget(leditMail, 0, 1)
+    LayoutInfoConnexion.addWidget(labPassword, 1, 0)
+    LayoutInfoConnexion.addWidget(leditPassword, 1, 1)
+    LayoutInfoConnexion.addWidget(labStatus, 2, 0)
+    LayoutInfoConnexion.addWidget(comboStatus, 2, 1)
+    LayoutInfoConnexion.addWidget(btnRegister, 3, 1)
+    #
+    layoutGroupConnexion: object = QHBoxLayout()
+    layoutGroupConnexion.addStretch()
+    layoutGroupConnexion.addLayout(LayoutInfoConnexion)
+    layoutGroupConnexion.addStretch()
+    grpConnexion: object = QGroupBox("Inscription")
+    grpConnexion.setLayout(layoutGroupConnexion)
+    #
+    layoutMain:   object = QVBoxLayout()
+    layoutMain.addWidget(connexionState)
+    layoutMain.addWidget(grpUtilisateur)
+    layoutMain.addStretch()
+    layoutMain.addWidget(grpConnexion)
+    layoutMain.addStretch()
+    #
+    mainWindow.mainWidget.deleteLater()
+    mainWindow.mainWidget = QWidget()
+    mainWindow.mainWidget.setLayout(layoutMain)
+    mainWindow.setCentralWidget(mainWindow.mainWidget)
diff --git a/src/gui/ressources/icon.ico b/src/app/ressources/icon.ico
index 7c550a3..7c550a3 100644
--- a/src/gui/ressources/icon.ico
+++ b/src/app/ressources/icon.ico
diff --git a/src/gui/windowAPropos.py b/src/app/windowAPropos.py
index 9ecdfda..2450e03 100644
--- a/src/gui/windowAPropos.py
+++ b/src/app/windowAPropos.py
@@ -2,13 +2,14 @@
 from PyQt5.QtWidgets import QMessageBox
 
 
-def main(mainWindow):
+def window_main(mainWindow: object) -> None:
+    """"""
     QMessageBox.information(
         mainWindow,
         "A propos",
-        "Logiciel pour mon dossier professionnel.\
-        <br>Version: %s\
+        f"Logiciel pour mon dossier professionnel.\
+        <br>Version: {mainWindow.VERSION}\
         <br>Auteur: Debulois Quentin\
         <br>Code source: \
-        <a href='https://git.debulois.fr/'>git.debulois.fr/</a>" % mainWindow.VERSION
+        <a href='https://git.debulois.fr/'>git.debulois.fr/</a>"
     )
diff --git a/src/app/windowAdmin.py b/src/app/windowAdmin.py
new file mode 100644
index 0000000..af27e54
--- /dev/null
+++ b/src/app/windowAdmin.py
@@ -0,0 +1,268 @@
+
+from PyQt5.QtWidgets import (
+    QDialog, QGroupBox, QLabel,
+    QLineEdit,   QVBoxLayout,
+    QHBoxLayout, QGridLayout,
+    QPushButton, QComboBox,
+    QMessageBox
+)
+from src.database.dbadmin   import DbAdmin
+from src.database.dbsearch  import DbSearch
+from src.database.dbmission import DbMission
+
+
+def core_ajout_emploi(mainWindow: object, nomEn: str, nomFr: str) -> int:
+    """"""
+    dbadmin: object = DbAdmin(mainWindow)
+    success: int    = dbadmin.register_job_category(nomEn, nomFr)
+    if success:
+        QMessageBox.information(
+            mainWindow,
+            "Ajout d'un emploi",
+            "Emploi ajouté!"
+        )
+        return 1
+    else:
+        QMessageBox.warning(
+            mainWindow,
+            "Ajout d'un emploi",
+            "Impossible d'ajouter cet emploi"
+        )
+        return 0
+
+
+def core_suppr_emploi(mainWindow: object, jobId: int) -> int:
+    """"""
+    dbadmin: object = DbAdmin(mainWindow)
+    success: int    = dbadmin.del_job_category_by_jobid(jobId)
+    if success:
+        QMessageBox.information(
+            mainWindow,
+            "Suppresion d'un emploi",
+            "Emploi supprimé!"
+        )
+        return 1
+    else:
+        QMessageBox.warning(
+            mainWindow,
+            "Suppresion d'un emploi",
+            "Impossible de supprimer cet emploi"
+        )
+        return 0
+
+
+def core_suppr_user(mainWindow: object, userId: int) -> int:
+    """"""
+    dbadmin: object = DbAdmin(mainWindow)
+    success: int    = dbadmin.del_user_by_userid(userId)
+    if success:
+        QMessageBox.information(
+            mainWindow,
+            "Suppresion d'un utilisateur",
+            "Utilisateur supprimé!"
+        )
+        return 1
+    else:
+        QMessageBox.warning(
+            mainWindow,
+            "Suppresion d'un utilisateur",
+            "Impossible de supprimer cet utilisateur"
+        )
+        return 0
+
+
+def core_suppr_mission(mainWindow: object, missionId: int) -> int:
+    """"""
+    dbadmin: object = DbAdmin(mainWindow)
+    success: int    = dbadmin.del_mission_by_missionid(missionId)
+    if success:
+        QMessageBox.information(
+            mainWindow,
+            "Suppresion d'une mission",
+            "Mission supprimé!"
+        )
+        return 1
+    else:
+        QMessageBox.warning(
+            mainWindow,
+            "Suppresion d'une mission",
+            "Impossible de supprimer cette mission"
+        )
+        return 0
+
+
+class window_admin_emplois():
+    """"""
+    def cmb_populate(self, mainWindow: object , cmb: object) -> None:
+        """"""
+        # Instanciation DB
+        dbsearch: object = DbSearch(mainWindow)
+        allJobs:  object = dbsearch.get_job_all()
+        cmb.clear()
+        for i in allJobs:
+            cmb.addItem(f"{i[2]}", i[0])
+
+
+    def __init__(self, mainWindow: object) -> None:
+        """"""
+        # Fenêtre
+        dial: object = QDialog(parent=mainWindow)
+        dial.setWindowTitle("Admin - Emplois")
+
+        # Widgets Ajout
+        labAjoutEn: object = QLabel("Nom en Anglais")
+        inpAjoutEn: object = QLineEdit(maxLength=128)
+        labAjoutFr: object = QLabel("Nom en Français")
+        inpAjoutFr: object = QLineEdit(maxLength=128)
+        btnAjout:   object = QPushButton("Enregistrer")
+        btnAjout.clicked.connect(
+            lambda: [
+                core_ajout_emploi(
+                    mainWindow,
+                    inpAjoutEn.text(),
+                    inpAjoutFr.text()
+                ),
+                self.cmb_populate(mainWindow, cmbSuppr)
+            ]
+        )
+        # Layout Ajout
+        layAjout: object = QGridLayout()
+        layAjout.addWidget(labAjoutEn, 0, 0)
+        layAjout.addWidget(inpAjoutEn, 0, 1)
+        layAjout.addWidget(labAjoutFr, 1, 0)
+        layAjout.addWidget(inpAjoutFr, 1, 1)
+        layAjout.addWidget(btnAjout,   2, 1)
+        # Grp Ajout
+        grpAjout: object = QGroupBox("Ajout d'un emploi")
+        grpAjout.setLayout(layAjout)
+
+        # Widgets Suppr
+        labSuppr: object = QLabel("Emploi à supprimmer")
+        cmbSuppr: object = QComboBox()
+        self.cmb_populate(mainWindow, cmbSuppr)
+        btnSuppr: object = QPushButton("Supprimer")
+        btnSuppr.clicked.connect(
+            lambda: [
+                core_suppr_emploi(
+                    mainWindow,
+                    cmbSuppr.currentData()
+                ),
+                self.cmb_populate(mainWindow, cmbSuppr)
+            ]
+        )
+        # Layouts Suppr
+        laySuppr: object = QGridLayout()
+        laySuppr.addWidget(labSuppr, 0, 0)
+        laySuppr.addWidget(cmbSuppr, 0, 1)
+        laySuppr.addWidget(btnSuppr, 1, 1)
+        # Grp Suppr
+        grpSuppr: object = QGroupBox("Suppression d'un emploi")
+        grpSuppr.setLayout(laySuppr)
+
+        # Layout Main & show
+        layMain: object = QVBoxLayout()
+        layMain.addWidget(grpAjout)
+        layMain.addWidget(grpSuppr)
+        dial.setLayout(layMain)
+        dial.show()
+
+
+def window_admin_users(mainWindow: object) -> None:
+    """"""
+    # Instanciation DB
+    dbadmin:  object = DbAdmin(mainWindow)
+    allUsers: object = dbadmin.get_all_users_account()
+    # Fenêtre
+    dial: object = QDialog(parent=mainWindow)
+    dial.setWindowTitle("Admin - Utilisateurs")
+    # Widgets Users
+    labCmdUser: object = QLabel("Id à supprimer")
+    inpCmdUser: object = QLineEdit(maxLength=128)
+    btnSuppr:   object = QPushButton("Supprimer")
+    btnSuppr.clicked.connect(
+        lambda: [
+            core_suppr_user(
+                mainWindow,
+                inpCmdUser.text()
+            ),
+            dial.close()
+        ]
+    )
+    labUsers: list = []
+    for i in allUsers:
+        labUsers.append(QLabel(f"ID:{i[0]} Mail:{i[1]} Inscr.{i[4]} Status:{i[5]}"))
+    # Layouts Users
+    layCmd: object = QHBoxLayout()
+    layCmd.addStretch()
+    layCmd.addWidget(labCmdUser)
+    layCmd.addWidget(inpCmdUser)
+    layCmd.addWidget(btnSuppr)
+    layCmd.addStretch()
+    layUsers: object = QVBoxLayout()
+    for i in range(len(labUsers)):
+        layUsers.addWidget(labUsers[i])
+    laySuppr: object = QVBoxLayout()
+    laySuppr.addLayout(layCmd)
+    laySuppr.addLayout(layUsers)
+    # Grp Users
+    grpUser: object = QGroupBox("Suppression d'un utilisateur")
+    grpUser.setLayout(laySuppr)
+    # Layout Main & Show
+    layMain: object = QVBoxLayout()
+    layMain.addWidget(grpUser)
+    dial.setLayout(layMain)
+    dial.show()
+
+
+def window_admin_missions(mainWindow: object):
+    """"""
+    # Instanciation DB
+    dbmission: object = DbMission(mainWindow)
+    dbsearch:  object = DbSearch(mainWindow)
+    # Fenêtre
+    dial: object = QDialog(parent=mainWindow)
+    dial.setWindowTitle("Admin - Missions")
+    # Widgets Users
+    labCmdMission: object = QLabel("Id à supprimer")
+    inpCmdMission: object = QLineEdit()
+    btnSuppr:      object = QPushButton("Supprimer")
+    btnSuppr.clicked.connect(
+        lambda: [
+            core_suppr_mission(
+                mainWindow,
+                inpCmdMission.text()
+            ),
+            dial.close()
+        ]
+    )
+    allMissions: object = dbmission.get_all_missions()
+    labMissions: list = []
+    for i in allMissions:
+        jobName = dbsearch.get_job_by_jobid(i[10])[0][2]
+        labMissions.append(
+            QLabel(
+                f"ID:{i[0]} date:{i[1].strftime('%m/%d/%Y')} Emploi:{jobName} sujet:{i[2]} clientId:{i[8]} proId:{i[9]}"
+            )
+        )
+    # Layouts Missions
+    layCmd: object = QHBoxLayout()
+    layCmd.addStretch()
+    layCmd.addWidget(labCmdMission)
+    layCmd.addWidget(inpCmdMission)
+    layCmd.addWidget(btnSuppr)
+    layCmd.addStretch()
+    layMissions: object = QVBoxLayout()
+    for i in range(len(labMissions)):
+        layMissions.addWidget(labMissions[i])
+
+    laySuppr: object = QVBoxLayout()
+    laySuppr.addLayout(layCmd)
+    laySuppr.addLayout(layMissions)
+    # Grp Missions
+    grpMission: object = QGroupBox("Suppression d'une mission")
+    grpMission.setLayout(laySuppr)
+    # Layout Main & Show
+    layMain: object = QVBoxLayout()
+    layMain.addWidget(grpMission)
+    dial.setLayout(layMain)
+    dial.show()
diff --git a/src/gui/windowMissions.py b/src/app/windowMissions.py
index d6fe57b..5878c8a 100644
--- a/src/gui/windowMissions.py
+++ b/src/app/windowMissions.py
@@ -8,58 +8,60 @@ from PyQt5.QtWidgets import (
 from src.database.dbmission import DbMission
 
 
-def review_mission(dial: object, dbmission: object, missionId: int) -> None:
-    dialReview = QDialog(parent=dial)
-
-    lineNote = QHBoxLayout()
-    labNote = QLabel("Note: ")
-    cmbNote = QComboBox()
+def core_review(dial: object, dbmission: object, missionId: int) -> None:
+    """"""
+    dialReview: object = QDialog(parent=dial)
+    #
+    lineNote: object = QHBoxLayout()
+    labNote:  object = QLabel("Note: ")
+    cmbNote:  object = QComboBox()
     for i in range(6):
         cmbNote.addItem(str(i), i)
     lineNote.addWidget(labNote)
     lineNote.addStretch()
     lineNote.addWidget(cmbNote)
-
-    lineReview = QHBoxLayout()
-    labReview = QLabel("Avis: ")
-    inpReview = QLineEdit()
+    #
+    lineReview: object = QHBoxLayout()
+    labReview:  object = QLabel("Avis: ")
+    inpReview:  object = QLineEdit(maxLength=256)
     lineReview.addWidget(labReview)
     lineReview.addStretch()
     lineReview.addWidget(inpReview)
-
-    lineBtn = QHBoxLayout()
-    btnValider = QPushButton("Valider")
+    #
+    lineBtn:    object = QHBoxLayout()
+    btnValider: object = QPushButton("Valider")
     btnValider.clicked.connect(
-        lambda:
-            [dbmission.review_mission(missionId, inpReview.text(), cmbNote.currentData()),
+        lambda: [
+            dbmission.review_mission(missionId, inpReview.text(), cmbNote.currentData()),
             dbmission.validate_mission_client_by_missionid(missionId),
             QMessageBox.information(
                 dial,
                 "Mission",
                 "La mission a été validée"
             ),
-            dialReview.close()]
+            dialReview.close()
+        ]
     )
     lineBtn.addStretch()
     lineBtn.addWidget(btnValider)
     lineBtn.addStretch()
-
-
-    layReview = QVBoxLayout()
+    #
+    layReview: object = QVBoxLayout()
     layReview.addLayout(lineNote)
     layReview.addLayout(lineReview)
     layReview.addLayout(lineBtn)
-
-    grpMain = QGroupBox("Donnez votre avis")
+    #
+    grpMain: object = QGroupBox("Donnez votre avis")
     grpMain.setLayout(layReview)
-    layMain = QVBoxLayout()
+    layMain: object = QVBoxLayout()
     layMain.addWidget(grpMain)
-
+    #
     dialReview.setLayout(layMain)
     dialReview.show()
 
 
-def validate_mission(mainWindow: object, dial: object, missionId: int, status: str) -> None:
+def core_validate(mainWindow: object, dial: object, missionId: int, status: str) -> None:
+    """"""
     dbmission: object = DbMission(mainWindow)
     if status == "acceptedByPro":
         dbmission.accept_mission_by_missionid(missionId)
@@ -76,12 +78,13 @@ def validate_mission(mainWindow: object, dial: object, missionId: int, status: s
             "La mission a été validée"
         )
     elif status == "validatedByClient":
-        review_mission(dial, dbmission, missionId)
+        core_review(dial, dbmission, missionId)
 
     dial.close()
 
 
-def get_missions_status(mainWindow: object, status: str) -> list:
+def core_get_missions_by_status(mainWindow: object, status: str) -> list:
+    """"""
     dbmission: object = DbMission(mainWindow)
     if mainWindow.userStatus == "Pro":
         missionsAll: list = dbmission.get_mission_by_proid(mainWindow.userId)
@@ -89,65 +92,65 @@ def get_missions_status(mainWindow: object, status: str) -> list:
         missionsAll: list = dbmission.get_mission_by_clientid(mainWindow.userId)
 
     if status == "pending":
-        missionsPending = [list(i) for i in missionsAll if i[5] == None]
+        missionsPending: list = [list(i) for i in missionsAll if i[5] == None]
         return missionsPending
     elif status == "ongoing":
-        missionsOngoing = [list(i) for i in missionsAll if i[5] != None and (i[6] == None or i[7] == None)]
+        missionsOngoing: list = [list(i) for i in missionsAll if i[5] != None and (i[6] == None or i[7] == None)]
         return missionsOngoing
     elif status == "completed":
-        missionsCompleted = [list(i) for i in missionsAll if (i[6] != None and i[7] != None)]
+        missionsCompleted: list = [list(i) for i in missionsAll if (i[6] != None and i[7] != None)]
         return missionsCompleted
 
 
-def main(mainWindow: object, status: str) -> None:
-    missions: list = get_missions_status(mainWindow, status)
-    dial: object = QDialog(parent = mainWindow)
-
-    linesMission: list = []
+def window_main(mainWindow: object, status: str) -> None:
+    """"""
+    dial:         object = QDialog(parent=mainWindow)
+    missions:     list   = core_get_missions_by_status(mainWindow, status)
+    linesMission: list   = []
     for mission in missions:
-        line = QHBoxLayout()
-        labMission = QLabel(" - ".join([str(i) for i in mission[1:] if i != None]))
+        line:       object = QHBoxLayout()
+        labMission: object = QLabel(" - ".join([str(i) for i in mission[1:] if i != None]))
         line.addWidget(labMission)
         if status == "pending" and mainWindow.userStatus == "Pro":
-            btnValidate = QPushButton("Valider")
+            btnValidate: object = QPushButton("Valider")
             btnValidate.clicked.connect(
                 lambda checked, missionId=mission[0]:
-                    validate_mission(mainWindow, dial, missionId, "acceptedByPro")
+                    core_validate(mainWindow, dial, missionId, "acceptedByPro")
             )
             line.addStretch()
             line.addWidget(btnValidate)
         elif status == "ongoing" and mainWindow.userStatus == "Pro" and mission[7] == None:
-            btnValidate = QPushButton("Valider")
+            btnValidate: object = QPushButton("Valider")
             btnValidate.clicked.connect(
                 lambda checked, missionId=mission[0]:
-                    validate_mission(mainWindow, dial, missionId, "validatedByPro")
+                    core_validate(mainWindow, dial, missionId, "validatedByPro")
             )
             line.addStretch()
             line.addWidget(btnValidate)
         elif status == "ongoing" and mainWindow.userStatus == "Client" and mission[6] == None:
-            btnValidate = QPushButton("Valider")
+            btnValidate: object = QPushButton("Valider")
             btnValidate.clicked.connect(
                 lambda checked, missionId=mission[0]:
-                    validate_mission(mainWindow, dial, missionId, "validatedByClient")
+                    core_validate(mainWindow, dial, missionId, "validatedByClient")
             )
             line.addStretch()
             line.addWidget(btnValidate)
 
         linesMission.append(line)
 
-    layMission = QVBoxLayout()
+    layMission: object = QVBoxLayout()
     for i in linesMission:
         layMission.addLayout(i)
 
     if status == "pending":
-        grpMain = QGroupBox("Missions en attente")
+        grpMain: object = QGroupBox("Missions en attente")
     elif status == "ongoing":
-        grpMain = QGroupBox("Missions en cours")
+        grpMain: object = QGroupBox("Missions en cours")
     elif status == "completed":
-        grpMain = QGroupBox("Missions terminées")
+        grpMain: object = QGroupBox("Missions terminées")
 
     grpMain.setLayout(layMission)
-    layMain = QVBoxLayout()
+    layMain: object = QVBoxLayout()
     layMain.addWidget(grpMain)
     dial.setLayout(layMain)
     dial.show()
diff --git a/src/app/windowRecherche.py b/src/app/windowRecherche.py
new file mode 100644
index 0000000..b2305e1
--- /dev/null
+++ b/src/app/windowRecherche.py
@@ -0,0 +1,150 @@
+
+# https://docs.python.org/3/faq/programming.html#why-do-lambdas-defined-in-a-loop-with-different-values-all-return-the-same-result
+# https://stackoverflow.com/questions/53751106/create-lambda-functions-in-a-loop-for-pyqt5-signals?noredirect=1
+
+from PyQt5.QtWidgets import (
+    QDialog,     QVBoxLayout,
+    QHBoxLayout, QLabel,
+    QPushButton, QGroupBox,
+    QComboBox,   QLineEdit,
+    QMessageBox
+)
+from src.database.dbsearch  import DbSearch
+from src.database.dbmission import DbMission
+
+
+def core_mandater(mainWindow: object, dial: object, proId: int) -> None:
+    """"""
+    dbmission: object = DbMission(mainWindow)
+    dbsearch:  object = DbSearch(mainWindow)
+    proJobs:   list   = dbsearch.get_pro_job_by_proid(proId)
+
+    dial: object = QDialog(dial)
+
+    labInpMandate: object = QLabel("Sujet de la mission:")
+    inpMandate:    object = QLineEdit(maxLength=128)
+    layInpMandate: object = QHBoxLayout()
+    layInpMandate.addWidget(labInpMandate)
+    layInpMandate.addStretch()
+    layInpMandate.addWidget(inpMandate)
+
+    labCmbMandate: object = QLabel("Profession concernée:")
+    cmbMandate:    object = QComboBox()
+    layCmbMandate: object = QHBoxLayout()
+    for i in proJobs:
+        cmbMandate.addItem(f"{i[2]}", i[0])
+    layCmbMandate.addWidget(labCmbMandate)
+    layCmbMandate.addStretch()
+    layCmbMandate.addWidget(cmbMandate)
+
+    btnMandate = QPushButton("Mandater")
+    btnMandate.clicked.connect(
+        lambda: [
+            dbmission.register_mission(
+                inpMandate.text(),
+                mainWindow.userId,
+                proId,
+                cmbMandate.currentData()
+            ),
+            QMessageBox.information(
+                dial,
+                "Mandater une mission",
+                "Votre mission à bien été mandatée"
+            ),
+            dial.close()
+        ]
+    )
+    layBtnMandate: object = QHBoxLayout()
+    layBtnMandate.addStretch()
+    layBtnMandate.addWidget(btnMandate)
+    layBtnMandate.addStretch()
+
+    layGrp: object = QVBoxLayout()
+    layGrp.addLayout(layInpMandate)
+    layGrp.addLayout(layCmbMandate)
+    layGrp.addLayout(layBtnMandate)
+
+    grpMandate: object = QGroupBox()
+    grpMandate.setLayout(layGrp)
+
+    layMain: object = QVBoxLayout()
+    layMain.addWidget(grpMandate)
+
+    dial.setLayout(layMain)
+    dial.show()
+
+
+def core_more_infos(mainWindow: object, dial: object, proId: int) -> None:
+    """"""
+    dial:         object = QDialog(dial)
+    search:       object = DbSearch(mainWindow)
+    resRecherche: list   = search.get_user_info_by_userid(proId)[0][1:]
+    labelsText:   list   = [
+        "Nom",
+        "Prénom",
+        "Diplôme",
+        "Capacités",
+        "Description",
+        "Téléphone",
+        "Adresse",
+        "Code postale",
+        "Ville",
+    ]
+
+    layProInfo = QVBoxLayout()
+    for i in range(len(resRecherche)):
+        line: object = QHBoxLayout()
+        line.addWidget(QLabel(f"{labelsText[i]}: {resRecherche[i]}"))
+        layProInfo.addLayout(line)
+
+    if mainWindow.userStatus == "Client":
+        layBtnMandate: object = QHBoxLayout()
+        btnMandate:    object = QPushButton("Mandater")
+        btnMandate.clicked.connect(
+            lambda:
+                core_mandater(mainWindow, dial, proId)
+        )
+        layBtnMandate.addStretch()
+        layBtnMandate.addWidget(btnMandate)
+        layBtnMandate.addStretch()
+        layProInfo.addLayout(layBtnMandate)
+
+    grpProInfo: object = QGroupBox()
+    grpProInfo.setLayout(layProInfo)
+
+    layMain:    object = QVBoxLayout()
+    layMain.addWidget(grpProInfo)
+
+    dial.setLayout(layMain)
+    dial.show()
+
+
+def window_main(mainWindow: object, results: list) -> None:
+    """"""
+    dial: object = QDialog(parent=mainWindow)
+    dial.setWindowTitle("Recherche")
+    layoutsResult: list = []
+    for i in results:
+        layoutLine = QHBoxLayout()
+        color = results.index(i) % 2
+        if color:
+            colored = QLabel(i["text"])
+            colored.setStyleSheet("background-color: rgb(230,200,200); border-radius: 3px")
+            layoutLine.addWidget(colored)
+        else:
+            layoutLine.addWidget(QLabel(i["text"]))
+        btnInfos = QPushButton("Infos")
+        btnInfos.clicked.connect(
+            lambda checked, proId=i["id"]:
+                core_more_infos(mainWindow, dial, proId)
+        )
+        layoutLine.addStretch()
+        layoutLine.addWidget(btnInfos)
+        layoutsResult.append(layoutLine)
+
+    layoutMain = QVBoxLayout()
+    for layout in layoutsResult:
+        layoutMain.addLayout(layout)
+
+    dial.setLayout(layoutMain)
+    dial.show()
diff --git a/src/gui/windowUserInfo.py b/src/app/windowUserInfo.py
index e0a9b08..4455dde 100644
--- a/src/gui/windowUserInfo.py
+++ b/src/app/windowUserInfo.py
@@ -1,23 +1,28 @@
 
+# https://stackoverflow.com/questions/3077192/get-a-layouts-widgets-in-pyqt
+
 from PyQt5.QtWidgets import (
-    QDialog, QGroupBox, QLabel,
-    QLineEdit, QVBoxLayout, QHBoxLayout,
-    QPushButton, QComboBox, QMessageBox
+    QDialog, QGroupBox,
+    QLabel,  QLineEdit,
+    QVBoxLayout, QHBoxLayout,
+    QPushButton, QComboBox,
+    QMessageBox
 )
 from src.database.dbuser   import DbUser
 from src.database.dbsearch import DbSearch
 
 
-def add_job(jobName: str, jobId: int, listMyJobs: list, layMyJobs: object) -> None:
+def core_add_job(jobName: str, jobId: int, listMyJobs: list, layMyJobs: object) -> None:
+    """"""
     if jobId not in listMyJobs:
         listMyJobs.append(jobId)
-        lineMyJobs: object = QHBoxLayout()
-        labJob: object = QLabel(jobName)
+        lineMyJobs:   object = QHBoxLayout()
+        labJob:       object = QLabel(jobName)
         btnRemoveJob: object = QPushButton("Supprimer")
         btnRemoveJob.clicked.connect(
             lambda checked, jId=jobId, layItem=lineMyJobs: [
                 listMyJobs.remove(jId),
-                delete_job(layItem)
+                core_delete_job(layItem)
             ]
         )
         lineMyJobs.addWidget(labJob)
@@ -26,20 +31,23 @@ def add_job(jobName: str, jobId: int, listMyJobs: list, layMyJobs: object) -> No
         layMyJobs.addLayout(lineMyJobs)
 
 
-def delete_job(layLineJob: object) -> None:
+def core_delete_job(layLineJob: object) -> None:
+    """"""
     lab: object = layLineJob.itemAt(0).widget()
-    btn: object = layLineJob.itemAt(2).widget()
     lab.deleteLater()
+    btn: object = layLineJob.itemAt(2).widget()
     btn.deleteLater()
     layLineJob.deleteLater()
 
 
-def validate(mainWindow: object, dial: object, layoutLines: list, oldJobs: list = None, newJobs: list = None) -> None:
-    user: object = DbUser(mainWindow = mainWindow)
-    userInfos: list = []
-    for i in layoutLines:
+def core_validate(mainWindow: object, dial: object,
+                  layLines: list, oldJobs: list = None, newJobs: list = None) -> None:
+    """"""
+    user:      object = DbUser(mainWindow = mainWindow)
+    userInfos: list   = []
+    for i in layLines:
         if i != "selectJobs" and i != "myJobs":
-            lineInput: object = layoutLines[i].itemAt(2).widget()
+            lineInput: object = layLines[i].itemAt(2).widget()
             userInfos.append(lineInput.text())
 
     if mainWindow.userStatus == "Pro":
@@ -63,14 +71,11 @@ def validate(mainWindow: object, dial: object, layoutLines: list, oldJobs: list
     )
 
 
-# https://stackoverflow.com/questions/3077192/get-a-layouts-widgets-in-pyqt
-def modif_infos(mainWindow: object) -> None:
-    dial: object = QDialog(parent = mainWindow)
-    dial.setWindowTitle("Mes infos")
-
+def window_main(mainWindow: object) -> None:
     search: object = DbSearch(mainWindow)
-    infos:  list   = search.get_user_info_by_userid(mainWindow.userId)
-
+    dial:   object = QDialog(parent=mainWindow)
+    dial.setWindowTitle("Mes infos")
+    infos: list = search.get_user_info_by_userid(mainWindow.userId)
     if infos:
         champsClients: dict = {
             "Nom":         infos[0][1],
@@ -100,95 +105,94 @@ def modif_infos(mainWindow: object) -> None:
             "Description"
         ]
 
-    layoutLines: list = {}
+    layLines: list = {}
     for i in champsClients:
-        layoutLines[i] = QHBoxLayout()
-        layoutLines[i].addWidget(QLabel(i))
-        layoutLines[i].addStretch()
+        layLines[i] = QHBoxLayout()
+        layLines[i].addWidget(QLabel(i))
+        layLines[i].addStretch()
         if infos:
             if i == "Téléphone":
-                layoutLines[i].addWidget(QLineEdit(champsClients[i], maxLength=10))
+                layLines[i].addWidget(QLineEdit(champsClients[i], maxLength=10))
             elif i == "Code postal":
-                layoutLines[i].addWidget(QLineEdit(champsClients[i], maxLength=6))
+                layLines[i].addWidget(QLineEdit(champsClients[i], maxLength=6))
             else:
-                layoutLines[i].addWidget(QLineEdit(champsClients[i], maxLength=128))
+                layLines[i].addWidget(QLineEdit(champsClients[i], maxLength=128))
         else:
             if i == "Téléphone":
-                layoutLines[i].addWidget(QLineEdit(maxLength=10))
+                layLines[i].addWidget(QLineEdit(maxLength=10))
             elif i == "Code postal":
-                layoutLines[i].addWidget(QLineEdit(maxLength=6))
+                layLines[i].addWidget(QLineEdit(maxLength=6))
             else:
-                layoutLines[i].addWidget(QLineEdit(maxLength=128))
+                layLines[i].addWidget(QLineEdit(maxLength=128))
 
     if mainWindow.userStatus == "Pro":
-        allJobs: object = search.get_job_all()
+        allJobs:       object = search.get_job_all()
+        laySelectJobs: object = QHBoxLayout()
         labSelectJobs: object = QLabel("Les emplois:")
-        cmbAllJobs: object = QComboBox()
-        lineSelectJobs: object = QHBoxLayout()
+        cmbAllJobs:    object = QComboBox()
         for i in allJobs:
             cmbAllJobs.addItem(f"{i[2]}", i[0])
+
         btnSelectJobs = QPushButton("Ajouter")
         btnSelectJobs.clicked.connect(
             lambda :
-                add_job(
+                core_add_job(
                     cmbAllJobs.currentText(),
                     cmbAllJobs.currentData(),
                     newJobs,
                     layMyJobs
                 )
         )
-        lineSelectJobs.addWidget(labSelectJobs)
-        lineSelectJobs.addStretch()
-        lineSelectJobs.addWidget(cmbAllJobs)
-        lineSelectJobs.addStretch()
-        lineSelectJobs.addWidget(btnSelectJobs)
-        layoutLines["selectJobs"] = lineSelectJobs
-
-        myJobs: object = search.get_pro_job_by_proid(mainWindow.userId)
+        laySelectJobs.addWidget(labSelectJobs)
+        laySelectJobs.addStretch()
+        laySelectJobs.addWidget(cmbAllJobs)
+        laySelectJobs.addStretch()
+        laySelectJobs.addWidget(btnSelectJobs)
+        layLines["selectJobs"] = laySelectJobs
+        #
+        myJobs:    object = search.get_pro_job_by_proid(mainWindow.userId)
         layMyJobs: object = QVBoxLayout()
-        newJobs: list = []
+        newJobs:   list   = []
         for i in myJobs:
-            add_job(i[2], i[0], newJobs, layMyJobs)
+            core_add_job(i[2], i[0], newJobs, layMyJobs)
         oldJobs: list = newJobs.copy() # Sinon pointer !!!
-
-        layoutLines["myJobs"] = layMyJobs
-
+        layLines["myJobs"] = layMyJobs
         for i in champsPro:
-            layoutLines[i] = QHBoxLayout()
-            layoutLines[i].addWidget(QLabel(i))
-            layoutLines[i].addStretch()
+            layLines[i] = QHBoxLayout()
+            layLines[i].addWidget(QLabel(i))
+            layLines[i].addStretch()
             if infos:
-                layoutLines[i].addWidget(QLineEdit(champsPro[i], maxLength=256))
+                layLines[i].addWidget(QLineEdit(champsPro[i], maxLength=256))
             else:
-                layoutLines[i].addWidget(QLineEdit(maxLength=256))
+                layLines[i].addWidget(QLineEdit(maxLength=256))
 
-    modifLayout: object = QVBoxLayout()
-    for i in layoutLines:
-        modifLayout.addLayout(layoutLines[i])
+    layModif: object = QVBoxLayout()
+    for i in layLines:
+        layModif.addLayout(layLines[i])
 
     btnModif: object = QPushButton("modifer")
     btnModif.clicked.connect(
         lambda:
-            validate(
+            core_validate(
                 mainWindow,
                 dial,
-                layoutLines,
+                layLines,
                 oldJobs,
                 newJobs
             ) if mainWindow.userStatus == "Pro"
-            else validate(
+            else core_validate(
                 mainWindow,
                 dial,
-                layoutLines
+                layLines
             )
     )
-    layoutBtn: object = QHBoxLayout()
-    layoutBtn.addStretch()
-    layoutBtn.addWidget(btnModif)
-    modifLayout.addLayout(layoutBtn)
-
+    layBtn: object = QHBoxLayout()
+    layBtn.addStretch()
+    layBtn.addWidget(btnModif)
+    layModif.addLayout(layBtn)
+    #
     grpMain: object = QGroupBox("Mes infos")
-    grpMain.setLayout(modifLayout)
+    grpMain.setLayout(layModif)
     mainLayout: object = QVBoxLayout()
     mainLayout.addWidget(grpMain)
     dial.setLayout(mainLayout)
diff --git a/src/core/coreAdmin.py b/src/core/coreAdmin.py
deleted file mode 100644
index 51fe75a..0000000
--- a/src/core/coreAdmin.py
+++ /dev/null
@@ -1,79 +0,0 @@
-
-from src.database import dbadmin
-from PyQt5.QtWidgets import QMessageBox
-
-
-def core_ajout_emploi(mainWindow: object, nomEn: str, nomFr: str) -> int:
-    admin = dbadmin.DbAdmin(mainWindow)
-    success = admin.register_job_category(nomEn, nomFr)
-    if success:
-        QMessageBox.information(
-            mainWindow,
-            "Ajout d'un emploi",
-            "Emploi ajouté!"
-        )
-        return 1
-    else:
-        QMessageBox.warning(
-            mainWindow,
-            "Ajout d'un emploi",
-            "Impossible d'ajouter cet emploi"
-        )
-        return 0
-
-
-def core_suppr_emploi(mainWindow: object, jobId: int) -> int:
-    admin = dbadmin.DbAdmin(mainWindow)
-    success = admin.del_job_category_by_jobid(jobId)
-    if success:
-        QMessageBox.information(
-            mainWindow,
-            "Suppresion d'un emploi",
-            "Emploi supprimé!"
-        )
-        return 1
-    else:
-        QMessageBox.warning(
-            mainWindow,
-            "Suppresion d'un emploi",
-            "Impossible de supprimer cet emploi"
-        )
-        return 0
-
-
-def core_suppr_user(mainWindow: object, userId: int) -> int:
-    admin = dbadmin.DbAdmin(mainWindow)
-    success = admin.del_user_by_userid(userId)
-    if success:
-        QMessageBox.information(
-            mainWindow,
-            "Suppresion d'un utilisateur",
-            "Utilisateur supprimé!"
-        )
-        return 1
-    else:
-        QMessageBox.warning(
-            mainWindow,
-            "Suppresion d'un utilisateur",
-            "Impossible de supprimer cet utilisateur"
-        )
-        return 0
-
-
-def core_suppr_mission(mainWindow: object, missionId: int) -> int:
-    admin = dbadmin.DbAdmin(mainWindow)
-    success = admin.del_mission_by_missionid(missionId)
-    if success:
-        QMessageBox.information(
-            mainWindow,
-            "Suppresion d'une mission",
-            "Mission supprimé!"
-        )
-        return 1
-    else:
-        QMessageBox.warning(
-            mainWindow,
-            "Suppresion d'une mission",
-            "Impossible de supprimer cette mission"
-        )
-        return 0
diff --git a/src/core/coreSearch.py b/src/core/coreSearch.py
deleted file mode 100644
index 47f2f69..0000000
--- a/src/core/coreSearch.py
+++ /dev/null
@@ -1,43 +0,0 @@
-
-from src.database import dbsearch
-from src.gui import windowRecherche
-from PyQt5.QtWidgets import QMessageBox
-
-
-def core_search_id(mainWindow: object, jobId: int) -> None:
-    search: object = dbsearch.DbSearch(mainWindow)
-    resRecherche: tuple = search.get_all_pro_by_jobid(jobId)
-    if resRecherche:
-        core_search_main(mainWindow, resRecherche)
-    else:
-        QMessageBox.information(
-            mainWindow,
-            "Résultat",
-            "Aucun résultat."
-        )
-
-def core_search_name(mainWindow: object, name: str) -> None:
-    search: object = dbsearch.DbSearch(mainWindow)
-    resRecherche: tuple = search.get_pro_info_by_lastname(name)
-    if resRecherche:
-        core_search_main(mainWindow, resRecherche)
-    else:
-        QMessageBox.information(
-            mainWindow,
-            "Résultat",
-            "Aucun résultat."
-        )
-
-def core_search_main(mainWindow: object, resRecherche: tuple) -> None:
-    search: object = dbsearch.DbSearch(mainWindow)
-    results: list = []
-    for i in resRecherche:
-        proInfo: dict = {}
-        proInfo["id"] = i[0]
-        resJobs = search.get_pro_job_by_proid(proInfo["id"])
-        proInfo["text"] = list(i[1:])
-        proInfo["text"].insert(2, ", ".join([j[2] for j in resJobs]))
-        proInfo["text"] = " - ".join(proInfo["text"])
-        results.append(proInfo)
-
-    windowRecherche.main(mainWindow, results)
diff --git a/src/core/coreUser.py b/src/core/coreUser.py
deleted file mode 100644
index ec39b39..0000000
--- a/src/core/coreUser.py
+++ /dev/null
@@ -1,137 +0,0 @@
-
-import re
-from PyQt5.QtWidgets import QMessageBox
-from src.gui import pageHome
-from src.database import dbuser, dbsearch
-
-
-def core_login(mainWindow, email, password) -> None:
-    user = dbuser.DbUser(mainWindow)
-    if user.check_exist_email(email):
-        res = user.check_user_credential(email, password)
-        if res:
-            search = dbsearch.DbSearch(mainWindow).get_user_account_by_userid(res)
-            QMessageBox.information(
-                mainWindow,
-                "Connexion",
-                "Vous êtes connecté"
-            )
-            mainWindow.userConnected = True
-            mainWindow.userId = str(search[0][0])
-            mainWindow.userEmail = search[0][1]
-            mainWindow.userInscrDate = search[0][2]
-            if search[0][3] == 0:
-                mainWindow.userStatus = "Admin"
-            elif search[0][3] == 1:
-                mainWindow.userStatus = "Pro"
-            elif search[0][3] == 2:
-                mainWindow.userStatus = "Client"
-            pageHome.main(mainWindow, True)
-        else:
-            QMessageBox.warning(
-                mainWindow,
-                "Connexion",
-                "Mauvaise combinaison mail & mot de passe"
-            )
-    else:
-        QMessageBox.warning(
-            mainWindow,
-            "Connexion",
-            "Mauvais email"
-        )
-
-
-def core_logout(mainWindow) -> None:
-    if mainWindow.userConnected == True:
-        mainWindow.userConnected = False
-        mainWindow.userId = ""
-        mainWindow.userEmail = ""
-        mainWindow.userInscrDate = ""
-        mainWindow.userStatus = ""
-
-    QMessageBox.information(
-        mainWindow,
-        "Déconnection",
-        "Vous êtes déconnecté."
-    )
-    pageHome.main(mainWindow, True)
-
-
-def core_register(mainWindow, email, password, userStatus) -> None:
-    user = dbuser.DbUser(mainWindow)
-    regNumb    = "[0-9]"
-    regUpper   = "[A-Z]"
-    regSpecial = "[`!@#$%^&*()_+\-=\[\]{};':\"\\|,.<>\/?~µ°€£]"
-    regEmail   = "^[a-z0-9._-]+@[a-z0-9-]+\.[a-z]+"
-
-    # Si vide
-    if not email:
-        QMessageBox.warning(
-            mainWindow,
-            "Email invalide",
-            "Veuillez renseigner un email"
-        )
-        return
-
-    if not password:
-        QMessageBox.warning(
-            mainWindow,
-            "Mot de passe invalide",
-            "Veuillez renseigner un mot de passe"
-        )
-        return
-
-    if userStatus == None:
-        QMessageBox.warning(
-            mainWindow,
-            "Mauvais rôle",
-            "Veuillez selectionner un rôle"
-        )
-        return
-
-    # les regex
-    if not re.fullmatch(regEmail, email):
-        QMessageBox.warning(
-            mainWindow,
-            "Email invalid",
-            "Email non conforme"
-        )
-        return
-
-    if len(password) < 8\
-            or not re.search(regNumb, password)\
-            or not re.search(regUpper, password)\
-            or not re.search(regSpecial, password):
-        QMessageBox.warning(
-            mainWindow,
-            "Mot de passe invalide",
-            ("Le mot de passe doit avoir:\n"
-            "-Au moins 8 characters\n"
-            "-Une majuscule\n"
-            "-Un chiffre\n"
-            "-Un character spécial")
-        )
-        return
-
-    # si email deja présent
-    if user.check_exist_email(email):
-        QMessageBox.warning(
-            mainWindow,
-            "Email invalid",
-            "Email déja utilisé"
-        )
-        return
-
-    res = user.register_user(email, password, userStatus)
-    if res:
-        QMessageBox.information(
-            mainWindow,
-            "Inscription",
-            "Inscription réussie!"
-        )
-    else:
-        QMessageBox.warning(
-            mainWindow,
-            "Erreur bdd",
-            "Erreur lors de l'inscritpion"
-        )
diff --git a/src/database/dbadmin.py b/src/database/dbadmin.py
index 6fcd3f5..76e31b4 100644
--- a/src/database/dbadmin.py
+++ b/src/database/dbadmin.py
@@ -7,10 +7,11 @@
 ############################################################################
 
 # Import de dbmain
-from src.database import dbmain
+from src.database.dbmain import DbMain
+
 
 # Extension de cette classe avec dbmain
-class DbAdmin(dbmain.DbMain):
+class DbAdmin(DbMain):
 
     # ****************************************************************************
     # GESTION DES UTILISATEURS DANS L'ADMIN
@@ -26,6 +27,7 @@ class DbAdmin(dbmain.DbMain):
         result = self.cur.fetchall()
         return result
 
+
     # https:#stackoverflow.com/questions/1361340/how-can-i-do-insert-if-not-exists-in-mysql
     # Suppresion d'un utilisateur
     def del_user_by_userid(self, userId: int) -> int:
@@ -103,6 +105,7 @@ class DbAdmin(dbmain.DbMain):
             # Retourne 0 pour échec
             return 0
 
+
     # Suppresion d'un utilisateur
     def del_job_category_by_jobid(self, jobId: int) -> int:
         # Préparation de la requète pour voir si l'utilisateur existe
@@ -133,6 +136,7 @@ class DbAdmin(dbmain.DbMain):
             # Retourne 0 pour échec
             return 0
 
+
     # ****************************************************************************
     # GESTION DES MISSIONS DANS L'ADMIN
     # ****************************************************************************
diff --git a/src/database/dbmain.py b/src/database/dbmain.py
index 53c368c..4344e23 100644
--- a/src/database/dbmain.py
+++ b/src/database/dbmain.py
@@ -141,6 +141,7 @@ class DbMain():
     TABLEUSERJOB = "userJob"
     TABLEMISSION = "mission"
 
+
     # ****************************************************************************
     # FONCTIONS PRINCIPALES
     # ****************************************************************************
@@ -149,11 +150,13 @@ class DbMain():
         reqInitDb = "CREATE DATABASE IF NOT EXISTS " + self.DATABASE
         self.cur.execute(reqInitDb)
 
+
     # Sélection de la DB
     def select_db(self) -> None:
         reqSelectDb = "USE " + self.DATABASE
         self.cur.execute(reqSelectDb)
 
+
     # Création des tables si elles n'existent pas
     def create_table(self) -> None:
         # userAccount
@@ -172,16 +175,19 @@ class DbMain():
         reqInitMission = self.CREATETABLEMISSION
         self.cur.execute(reqInitMission)
 
+
     # Déclenche les méthodes pour créer la BDD
     def init(self) -> None:
         self.create_db()
         self.select_db()
         self.create_table()
 
+
     # Chiffre la data reçue
     def crypt_pass(self, password: str) -> str:
         return sha512_crypt.hash(password, rounds=10000)
 
+
     # Prépare la requète pour mitiger (se protéger) les injections SQL et
     # initialise si nécessaire la BDD à chaque requète
     def exec_cmd(self, req: str, arg: list = None, commit: bool = False) -> None:
@@ -195,6 +201,7 @@ class DbMain():
         else:
             self.cur.execute(req)
 
+
     # Vérifie si l'email existe dans la table userAccount de la BDD
     def check_exist_email(self, email: str) -> int:
         reqCheckEmailExist = "SELECT EXISTS(SELECT * FROM " + \
@@ -203,6 +210,7 @@ class DbMain():
         # Retourne 1 si existe, sinon 0
         return self.cur.fetchall()[0][0]
 
+
     # Constructeur, fonction "auto" déclenchée à l'instanciation
     def __init__(self, mainWindow) -> None:
         try:
diff --git a/src/database/dbmission.py b/src/database/dbmission.py
index 9d23288..0bb73e0 100644
--- a/src/database/dbmission.py
+++ b/src/database/dbmission.py
@@ -10,18 +10,18 @@
 # https:#www.freecodecamp.org/news/sql-joins-tutorial/
 
 # Import de dbmain
-from src.database import dbmain
+from src.database.dbmain import DbMain
 from datetime import datetime
 
 
 # Extension de cette classe avec dbmain
-class DbMission(dbmain.DbMain):
+class DbMission(DbMain):
 
     # ****************************************************************************
     # ENREGISTREMENT ET VALIDATION DES MISSIONS
     # ****************************************************************************
     # Enregistrement d'une mission
-    def register_mission(self, subject, clientId, proId, jobId):
+    def register_mission(self, subject: str, clientId: int, proId: int, jobId: int) -> int:
         # Préparation de la requète pour enregistrement de la mission
         reqAddMission = """
             INSERT INTO """ + self.TABLEMISSION + """
@@ -29,18 +29,17 @@ class DbMission(dbmain.DbMain):
             VALUES
                 (%s, %s, %s, %s, %s)"""
         # Exécution de la requète
-        self.exec_cmd(reqAddMission,
-                                    [datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
-                                    subject,
-                                    clientId,
-                                    proId,
-                                    jobId
-                                    ]
-                                )
+        self.exec_cmd(
+            reqAddMission,
+            [datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+            subject, clientId, proId, jobId],
+            True
+        )
         return 1
 
+
     # Enregistrement d'une mission
-    def accept_mission_by_missionid(self, missionId):
+    def accept_mission_by_missionid(self, missionId: int) -> int:
         # Préparation de la requète pour enregistrement de la mission
         reqAddMission = """
             UPDATE
@@ -50,10 +49,15 @@ class DbMission(dbmain.DbMain):
             WHERE
                 missionId = %s"""
         # Exécution de la requète
-        self.exec_cmd(reqAddMission, [datetime.now().strftime("%Y-%m-%d %H:%M:%S"), missionId], True)
+        self.exec_cmd(
+            reqAddMission,
+            [datetime.now().strftime("%Y-%m-%d %H:%M:%S"), missionId],
+            True
+        )
         return 1
 
-    def validate_mission_pro_by_missionid(self, missionId):
+
+    def validate_mission_pro_by_missionid(self, missionId: int) -> int:
         # Préparation de la requète pour enregistrement de la mission
         reqAddMission = """
             UPDATE
@@ -63,10 +67,15 @@ class DbMission(dbmain.DbMain):
             WHERE
                 missionId = %s"""
         # Exécution de la requète
-        self.exec_cmd(reqAddMission, [datetime.now().strftime("%Y-%m-%d %H:%M:%S"), missionId], True)
+        self.exec_cmd(
+            reqAddMission,
+            [datetime.now().strftime("%Y-%m-%d %H:%M:%S"), missionId],
+            True
+        )
         return 1
 
-    def validate_mission_client_by_missionid(self, missionId):
+
+    def validate_mission_client_by_missionid(self, missionId: int) -> int:
         # Préparation de la requète pour enregistrement de la mission
         reqAddMission = """
             UPDATE
@@ -76,9 +85,14 @@ class DbMission(dbmain.DbMain):
             WHERE
                 missionId = %s"""
         # Exécution de la requète
-        self.exec_cmd(reqAddMission, [datetime.now().strftime("%Y-%m-%d %H:%M:%S"), missionId], True)
+        self.exec_cmd(
+            reqAddMission,
+            [datetime.now().strftime("%Y-%m-%d %H:%M:%S"), missionId],
+            True
+        )
         return 1
 
+
     def review_mission(self, missionId: int, review: str, note: int) -> None:
         # Préparation de la requète pour enregistrement de la mission
         reqAddMission = """
@@ -91,11 +105,12 @@ class DbMission(dbmain.DbMain):
         # Exécution de la requète
         self.exec_cmd(reqAddMission, [review, note, missionId], True)
 
+
     # ****************************************************************************
     # RECUPERATION DES INFORMATIONS RELATIVES AUX MISSIONS
     # ****************************************************************************
     # Récupérations des missions d'un pro par son id
-    def get_mission_by_proid(self, proId):
+    def get_mission_by_proid(self, proId: int) -> list:
         reqGetMissionsProId = """
             SELECT
                 missionId, date, subject, note, review,
@@ -113,8 +128,9 @@ class DbMission(dbmain.DbMain):
         result = self.cur.fetchall()
         return result
 
+
     # Récupérations des missions d'un client par son id
-    def get_mission_by_clientid(self, clientId):
+    def get_mission_by_clientid(self, clientId: int) -> list:
         reqGetMissionsClientId = """
             SELECT
                 missionId, date, subject, note, review,
@@ -132,6 +148,7 @@ class DbMission(dbmain.DbMain):
         result = self.cur.fetchall()
         return result
 
+
     # Récupérations des missions d'un client par son id
     def get_all_missions(self):
         reqGetAllMission = """
@@ -142,18 +159,3 @@ class DbMission(dbmain.DbMain):
         self.exec_cmd(reqGetAllMission)
         result = self.cur.fetchall()
         return result
-
-    # Compte le nombre de mission d'un consultant par son nom
-    def count_pro_missions_by_proid(self, proId):
-        reqCountMission = """
-            SELECT COUNT(*) FROM
-                """ + self.TABLEMISSION + """
-            INNER JOIN
-                """ + self.TABLEUSERINFO + """
-            ON
-                """ + self.TABLEMISSION + """.proId = """ + self.TABLEUSERINFO + """.userId
-            WHERE
-                proId = %s"""
-        self.exec_cmd(reqCountMission, [proId])
-        result = self.cur.fetchall()
-        return result
diff --git a/src/database/dbsearch.py b/src/database/dbsearch.py
index 0561c9d..62316f4 100644
--- a/src/database/dbsearch.py
+++ b/src/database/dbsearch.py
@@ -9,11 +9,11 @@
 # https:#www.freecodecamp.org/news/sql-joins-tutorial/
 
 # Import de dbmain
-from src.database import dbmain
+from src.database.dbmain import DbMain
 
 
 # Extension de cette classe avec dbmain
-class DbSearch(dbmain.DbMain):
+class DbSearch(DbMain):
     # ****************************************************************************
     # RECUPERATION DES INFORMATIONS RELATIVES AUX UTILISATEURS
     # ****************************************************************************
@@ -43,10 +43,11 @@ class DbSearch(dbmain.DbMain):
         self.exec_cmd(reqGetUserInfo, [userId])
         return self.cur.fetchall()
 
+
     # ****************************************************************************
     # RECUPERATION DES INFORMATIONS RELATIVES AUX PROS
     # ****************************************************************************
-    def get_all_pro_by_jobid(self, jobId):
+    def get_all_pro_by_jobid(self, jobId: int) -> list:
         reqSearchConsultant = """
             SELECT
                 """ + self.TABLEUSERINFO + """.userId,
@@ -62,8 +63,9 @@ class DbSearch(dbmain.DbMain):
         self.exec_cmd(reqSearchConsultant, [jobId])
         return self.cur.fetchall()
 
+
     # Récupération des infos d'un pro par son nom
-    def get_pro_info_by_lastname(self, lastname):
+    def get_pro_info_by_lastname(self, lastname: str) -> list:
         reqSearchConsultant = """
             SELECT
                 """ + self.TABLEUSERINFO + """.userId,
@@ -81,8 +83,9 @@ class DbSearch(dbmain.DbMain):
         self.exec_cmd(reqSearchConsultant, [lastname])
         return self.cur.fetchall()
 
+
     # Récupération des emploies associés à un pro
-    def get_pro_job_by_proid(self, proId):
+    def get_pro_job_by_proid(self, proId: int) -> list:
         reqGetAll = """
             SELECT
                 """ + self.TABLEUSERJOB + """.jobCategoryId,
@@ -98,8 +101,9 @@ class DbSearch(dbmain.DbMain):
         self.exec_cmd(reqGetAll, [proId])
         return self.cur.fetchall()
 
+
     # Récupération des notes d'un consultant par son nom
-    def get_pro_note_by_proid(self, proId):
+    def get_pro_note_by_proid(self, proId: int) -> list:
         reqCountMission = """
             SELECT
                 note
@@ -114,6 +118,7 @@ class DbSearch(dbmain.DbMain):
         self.exec_cmd(reqCountMission, [proId])
         return self.cur.fetchall()
 
+
     # ****************************************************************************
     # RECUPERATION DES INFORMATIONS RELATIVES AUX EMPLOIS
     # ****************************************************************************
@@ -127,6 +132,7 @@ class DbSearch(dbmain.DbMain):
         self.exec_cmd(reqGetAllJobs)
         return self.cur.fetchall()
 
+
     # Récupérer toutes les infos de la table jobCategory
     def get_job_by_jobid(self, jobId: int) -> list:
         reqGetJobinfo = """
diff --git a/src/database/dbuser.py b/src/database/dbuser.py
index 9fbfeb6..bc89f8a 100644
--- a/src/database/dbuser.py
+++ b/src/database/dbuser.py
@@ -10,10 +10,11 @@
 from datetime import datetime
 from passlib.hash import sha512_crypt
 # Import de dbmain
-from src.database import dbmain
+from src.database.dbmain import DbMain
+
 
 # Extension de cette classe avec dbmain
-class DbUser(dbmain.DbMain):
+class DbUser(DbMain):
 
     # ****************************************************************************
     # GESTION DES UTILISATEURS
@@ -48,8 +49,9 @@ class DbUser(dbmain.DbMain):
             # Retourne 0 pour échec
             return 0
 
+
     # Vérification de la combinaison email - pass pour authentification
-    def check_user_credential(self, email, password):
+    def check_user_credential(self, email: str, password: str) -> int:
         # Préparation de la requète pour récupérer les infos ou l'email est présent
         reqCheckCredential = """
             SELECT
@@ -110,49 +112,3 @@ class DbUser(dbmain.DbMain):
                 self.exec_cmd(reqAddInfoProJobs, [i, userId], True)
             for i in jobsRemoved:
                 self.exec_cmd(reqRemoveInfoProJobs, [i, userId], True)
-
-    # ****************************************************************************
-    # GESTION DU TOKEN AUTOLOGIN
-    # ****************************************************************************
-    # Vérification de la combinaison email - jeton d'auto-login pour authentification
-    def check_token_autologin(self, email, token):
-        # Préparation de la requète pour récupérer les infos ou l'email est présent
-        reqCheckToken = """
-            SELECT
-                userId, tokenAutoLogin
-            FROM
-                """ + self.TABLEUSERACCOUNT + """
-            WHERE
-                email = %s"""
-        # Exécution de la requète
-        self.exec_cmd(reqCheckToken, [email])
-        result = self.cur.fetchone()
-        # Vérifiaction de correspondance email & jeton d'auto-connection
-        if result and result[1] == token:
-            return result[0]
-
-    # Mise à jour du jeton d'auto-login
-    def update_token_autologin(self, email, token):
-        # Préparation de la requète pour mise à jour du jeton d'auto-connection
-        reqUpdateToken = """
-            UPDATE
-                """ + self.TABLEUSERACCOUNT + """
-            SET
-                tokenAutoLogin = %s
-            WHERE
-                email = %s"""
-        # Execution de la requète
-        self.exec_cmd(reqUpdateToken, [token, email])
-
-    # Supression du jeton d'auto-login
-    def del_token_autologin(self, email):
-        # Préparation de la requète pour supression du jeton d'auto-connection
-        reqDeleteToken = """
-            UPDATE
-                """ + self.TABLEUSERACCOUNT + """
-            SET
-                tokenAutoLogin = NULL
-            WHERE
-                email = %s"""
-        # Execution de la requète
-        self.exec_cmd(reqDeleteToken, [email])
diff --git a/src/gui/__init__.py b/src/gui/__init__.py
deleted file mode 100644
index e69de29..0000000
--- a/src/gui/__init__.py
+++ /dev/null
diff --git a/src/gui/pageHome.py b/src/gui/pageHome.py
deleted file mode 100644
index 03f8d81..0000000
--- a/src/gui/pageHome.py
+++ /dev/null
@@ -1,101 +0,0 @@
-
-from PyQt5.QtWidgets import (
-    QGroupBox, QPushButton,
-    QComboBox, QLineEdit,
-    QHBoxLayout, QWidget,
-    QVBoxLayout, QLabel
-)
-from src.database import dbsearch
-from src.gui import pageLogin, pageRegister, globalMenu
-from src.core.coreSearch import core_search_id, core_search_name
-from src.core.coreUser import core_logout
-
-
-def main(mainWindow, reloadMenu = False) -> None:
-    if reloadMenu:
-        globalMenu.init(mainWindow)
-
-    classSearch = dbsearch.DbSearch(mainWindow)
-
-    if not mainWindow.userConnected:
-        connexionState = QLabel("Non connecté.")
-    else:
-        connexionState = QLabel(f"Connecté: {mainWindow.userEmail} - {mainWindow.userStatus}")
-
-    if not mainWindow.userConnected:
-        btnConnexion = QPushButton("Connexion")
-        btnConnexion.clicked.connect(lambda: pageLogin.main(mainWindow))
-    else:
-        btnDeconnexion = QPushButton("Déconnexion")
-        btnDeconnexion.clicked.connect(lambda: core_logout(mainWindow))
-
-    btnInscription = QPushButton("Inscription")
-    btnInscription.clicked.connect(lambda: pageRegister.main(mainWindow))
-
-    layoutUser = QHBoxLayout()
-    layoutUser.addStretch()
-    layoutUser.addWidget(btnInscription)
-    if not mainWindow.userConnected:
-        layoutUser.addWidget(btnConnexion)
-    else:
-        layoutUser.addWidget(btnDeconnexion)
-
-    grpUtilisateur = QGroupBox("Gestion de l'utilisateur")
-    grpUtilisateur.setLayout(layoutUser)
-
-    labRechercheNom = QLabel("Par nom")
-    inputRechercheNom = QLineEdit()
-    btnRechercheNom = QPushButton("Rechercher")
-    btnRechercheNom.clicked.connect(
-        lambda:
-            core_search_name(
-                mainWindow,
-                inputRechercheNom.text()
-            )
-    )
-    labRechercheCat = QLabel("Par emploi")
-    comboRechercheCat = QComboBox()
-    alljobs = classSearch.get_job_all()
-    for i in alljobs:
-        comboRechercheCat.addItem("{0}".format(i[2]), i[0])
-    btnRechercheCat = QPushButton("Rechercher")
-    btnRechercheCat.clicked.connect(
-        lambda:
-            core_search_id(
-                mainWindow,
-                comboRechercheCat.currentData()
-            )
-    )
-
-    layoutRechercheNom = QVBoxLayout()
-    layoutRechercheNom.addWidget(labRechercheNom)
-    layoutRechercheNom.addWidget(inputRechercheNom)
-    layoutRechercheNom.addWidget(btnRechercheNom)
-    layoutRechercheCat = QVBoxLayout()
-    layoutRechercheCat.addWidget(labRechercheCat)
-    layoutRechercheCat.addWidget(comboRechercheCat)
-    layoutRechercheCat.addWidget(btnRechercheCat)
-
-    layoutRecherche = QHBoxLayout()
-    layoutRecherche.addStretch()
-    layoutRecherche.addLayout(layoutRechercheNom)
-    layoutRecherche.addStretch()
-    layoutRecherche.addLayout(layoutRechercheCat)
-    layoutRecherche.addStretch()
-
-    grpRecherche = QGroupBox("Recherche")
-    grpRecherche.setLayout(layoutRecherche)
-
-    layoutMain = QVBoxLayout()
-    layoutMain.addWidget(connexionState)
-    layoutMain.addWidget(grpUtilisateur)
-    layoutMain.addStretch()
-    layoutMain.addWidget(grpRecherche)
-    layoutMain.addStretch()
-
-    if hasattr(mainWindow, "mainWidget"):
-        mainWindow.mainWidget.deleteLater()
-
-    mainWindow.mainWidget = QWidget()
-    mainWindow.mainWidget.setLayout(layoutMain)
-    mainWindow.setCentralWidget(mainWindow.mainWidget)
diff --git a/src/gui/pageLogin.py b/src/gui/pageLogin.py
deleted file mode 100644
index e255dfb..0000000
--- a/src/gui/pageLogin.py
+++ /dev/null
@@ -1,68 +0,0 @@
-
-from PyQt5.QtWidgets import (
-    QPushButton, QHBoxLayout, QGroupBox, QLabel,
-    QLineEdit, QWidget, QVBoxLayout, QGridLayout
-)
-from src.gui import pageHome, pageRegister
-from src.core.coreUser import core_login
-
-
-def main(mainWindow) -> None:
-    if not mainWindow.userConnected:
-        connexionState = QLabel("Non connecté.")
-    else:
-        connexionState = QLabel(f"Connecté: {mainWindow.userEmail} - {mainWindow.userStatus}")
-
-    btnAccueil = QPushButton("Accueil")
-    btnAccueil.clicked.connect(lambda: pageHome.main(mainWindow))
-    btnInscription = QPushButton("Inscription")
-    btnInscription.clicked.connect(lambda: pageRegister.main(mainWindow))
-
-    layoutUser = QHBoxLayout()
-    layoutUser.addWidget(btnAccueil)
-    layoutUser.addStretch()
-    layoutUser.addWidget(btnInscription)
-    grpUtilisateur = QGroupBox("Gestion de l'utilisateur")
-    grpUtilisateur.setLayout(layoutUser)
-
-    labMail = QLabel("Email")
-    leditMail = QLineEdit()
-    labPassword = QLabel("Mot de passe")
-    leditPassword = QLineEdit()
-    leditPassword.setEchoMode(QLineEdit.Password)
-    btnConnexion = QPushButton("Connexion")
-    btnConnexion.clicked.connect(
-        lambda:
-            core_login(
-                mainWindow,
-                leditMail.text(),
-                leditPassword.text()
-            )
-    )
-
-    LayoutInfoConnexion = QGridLayout()
-    LayoutInfoConnexion.addWidget(labMail, 0, 0)
-    LayoutInfoConnexion.addWidget(leditMail, 0, 1)
-    LayoutInfoConnexion.addWidget(labPassword, 1, 0)
-    LayoutInfoConnexion.addWidget(leditPassword, 1, 1)
-    LayoutInfoConnexion.addWidget(btnConnexion, 2, 1)
-
-    layoutGroupConnexion = QHBoxLayout()
-    layoutGroupConnexion.addStretch()
-    layoutGroupConnexion.addLayout(LayoutInfoConnexion)
-    layoutGroupConnexion.addStretch()
-
-    grpConnexion = QGroupBox("Connexion")
-    grpConnexion.setLayout(layoutGroupConnexion)
-
-    layoutMain = QVBoxLayout()
-    layoutMain.addWidget(connexionState)
-    layoutMain.addWidget(grpUtilisateur)
-    layoutMain.addStretch()
-    layoutMain.addWidget(grpConnexion)
-    layoutMain.addStretch()
-
-    mainWindow.mainWidget.deleteLater()
-    mainWindow.mainWidget = QWidget()
-    mainWindow.mainWidget.setLayout(layoutMain)
-    mainWindow.setCentralWidget(mainWindow.mainWidget)
\ No newline at end of file
diff --git a/src/gui/pageRegister.py b/src/gui/pageRegister.py
deleted file mode 100644
index f0fc392..0000000
--- a/src/gui/pageRegister.py
+++ /dev/null
@@ -1,84 +0,0 @@
-
-from PyQt5.QtWidgets import (
-    QPushButton, QHBoxLayout, QGroupBox, QLabel,
-    QLineEdit, QWidget, QVBoxLayout, QComboBox, QGridLayout
-)
-from src.gui import pageHome, pageLogin
-from src.core.coreUser import core_register, core_logout
-
-
-def main(mainWindow) -> None:
-    if not mainWindow.userConnected:
-        connexionState = QLabel("Non connecté.")
-    else:
-        connexionState = QLabel(f"Connecté: {mainWindow.userEmail} - {mainWindow.userStatus}")
-
-    btnAccueil = QPushButton("Accueil")
-    btnAccueil.clicked.connect(lambda: pageHome.main(mainWindow))
-
-    if not mainWindow.userConnected:
-        btnConnexion = QPushButton("Connexion")
-        btnConnexion.clicked.connect(lambda: pageLogin.main(mainWindow))
-    else:
-        btnDeconnexion = QPushButton("Déconnexion")
-        btnDeconnexion.clicked.connect(lambda: core_logout(mainWindow))
-
-    layoutUser = QHBoxLayout()
-    layoutUser.addWidget(btnAccueil)
-    layoutUser.addStretch()
-    if not mainWindow.userConnected:
-        layoutUser.addWidget(btnConnexion)
-    else:
-        layoutUser.addWidget(btnDeconnexion)
-
-    grpUtilisateur = QGroupBox("Gestion de l'utilisateur")
-    grpUtilisateur.setLayout(layoutUser)
-
-    labMail = QLabel("Email")
-    leditMail = QLineEdit()
-    labPassword = QLabel("Mot de passe")
-    leditPassword = QLineEdit()
-    leditPassword.setEchoMode(QLineEdit.Password)
-    labStatus = QLabel("Rôle")
-    comboStatus = QComboBox()
-    comboStatus.addItem("Admin", 0)
-    comboStatus.addItem("Pro", 1)
-    comboStatus.addItem("Client", 2)
-
-    btnRegister = QPushButton("S'inscrire")
-    btnRegister.clicked.connect(
-        lambda: core_register(
-            mainWindow,
-            leditMail.text(),
-            leditPassword.text(),
-            comboStatus.currentData()
-        )
-    )
-
-    LayoutInfoConnexion = QGridLayout()
-    LayoutInfoConnexion.addWidget(labMail, 0, 0)
-    LayoutInfoConnexion.addWidget(leditMail, 0, 1)
-    LayoutInfoConnexion.addWidget(labPassword, 1, 0)
-    LayoutInfoConnexion.addWidget(leditPassword, 1, 1)
-    LayoutInfoConnexion.addWidget(labStatus, 2, 0)
-    LayoutInfoConnexion.addWidget(comboStatus, 2, 1)
-    LayoutInfoConnexion.addWidget(btnRegister, 3, 1)
-
-    layoutGroupConnexion = QHBoxLayout()
-    layoutGroupConnexion.addStretch()
-    layoutGroupConnexion.addLayout(LayoutInfoConnexion)
-    layoutGroupConnexion.addStretch()
-    grpConnexion = QGroupBox("Inscription")
-    grpConnexion.setLayout(layoutGroupConnexion)
-
-    layoutMain = QVBoxLayout()
-    layoutMain.addWidget(connexionState)
-    layoutMain.addWidget(grpUtilisateur)
-    layoutMain.addStretch()
-    layoutMain.addWidget(grpConnexion)
-    layoutMain.addStretch()
-
-    mainWindow.mainWidget.deleteLater()
-    mainWindow.mainWidget = QWidget()
-    mainWindow.mainWidget.setLayout(layoutMain)
-    mainWindow.setCentralWidget(mainWindow.mainWidget)
diff --git a/src/gui/windowAdmin.py b/src/gui/windowAdmin.py
deleted file mode 100644
index 3996615..0000000
--- a/src/gui/windowAdmin.py
+++ /dev/null
@@ -1,180 +0,0 @@
-
-from PyQt5.QtWidgets import (
-    QDialog, QGroupBox, QLabel,
-    QLineEdit, QVBoxLayout, QHBoxLayout,
-    QGridLayout, QPushButton, QComboBox
-)
-from src.database import dbsearch, dbadmin, dbmission
-from src.core import coreAdmin
-
-
-class admin_emplois():
-    def cmb_populate(self, mainWindow: object , cmb: object) -> None:
-        # Instanciation DB
-        search:  object = dbsearch.DbSearch(mainWindow)
-        allJobs: object = search.get_job_all()
-        cmb.clear()
-        for i in allJobs:
-            cmb.addItem(f"{i[2]}", i[0])
-
-    def __init__(self, mainWindow: object) -> None:
-        # Fenêtre
-        dial: object = QDialog(parent = mainWindow)
-        dial.setWindowTitle("Admin - Emplois")
-
-        # Widgets Ajout
-        labAjoutEn: object = QLabel("Nom en Anglais")
-        inpAjoutEn: object = QLineEdit()
-        labAjoutFr: object = QLabel("Nom en Français")
-        inpAjoutFr: object = QLineEdit()
-        btnAjout:   object = QPushButton("Enregistrer")
-        btnAjout.clicked.connect(
-            lambda: [
-                coreAdmin.core_ajout_emploi(
-                    mainWindow,
-                    inpAjoutEn.text(),
-                    inpAjoutFr.text()
-                ),
-                self.cmb_populate(mainWindow, cmbSuppr)
-            ]
-        )
-        # Layout Ajout
-        layAjout: object = QGridLayout()
-        layAjout.addWidget(labAjoutEn, 0, 0)
-        layAjout.addWidget(inpAjoutEn, 0, 1)
-        layAjout.addWidget(labAjoutFr, 1, 0)
-        layAjout.addWidget(inpAjoutFr, 1, 1)
-        layAjout.addWidget(btnAjout,   2, 1)
-        # Grp Ajout
-        grpAjout: object = QGroupBox("Ajout d'un emploi")
-        grpAjout.setLayout(layAjout)
-
-        # Widgets Suppr
-        labSuppr: object = QLabel("Emploi à supprimmer")
-        cmbSuppr: object = QComboBox()
-        self.cmb_populate(mainWindow, cmbSuppr)
-        btnSuppr: object = QPushButton("Supprimer")
-        btnSuppr.clicked.connect(
-            lambda: [
-                coreAdmin.core_suppr_emploi(
-                    mainWindow,
-                    cmbSuppr.currentData()
-                ),
-                self.cmb_populate(mainWindow, cmbSuppr)
-            ]
-        )
-        # Layouts Suppr
-        laySuppr: object = QGridLayout()
-        laySuppr.addWidget(labSuppr, 0, 0)
-        laySuppr.addWidget(cmbSuppr, 0, 1)
-        laySuppr.addWidget(btnSuppr, 1, 1)
-        # Grp Suppr
-        grpSuppr: object = QGroupBox("Suppression d'un emploi")
-        grpSuppr.setLayout(laySuppr)
-
-        # Layout Main & show
-        layoutMain: object = QVBoxLayout()
-        layoutMain.addWidget(grpAjout)
-        layoutMain.addWidget(grpSuppr)
-        dial.setLayout(layoutMain)
-        dial.show()
-
-
-def admin_users(mainWindow: object) -> None:
-    # Instanciation DB
-    admin:    object = dbadmin.DbAdmin(mainWindow)
-    allUsers: object = admin.get_all_users_account()
-
-    # Fenêtre
-    dial: object = QDialog(parent = mainWindow)
-    dial.setWindowTitle("Admin - Utilisateurs")
-
-    # Widgets Users
-    labUserId: object = QLabel("Id à supprimer")
-    inpUserId: object = QLineEdit()
-    btnSuppr:  object = QPushButton("Supprimer")
-    btnSuppr.clicked.connect(
-        lambda: [
-            coreAdmin.core_suppr_user(
-                mainWindow,
-                inpUserId.text()
-            ),
-            dial.close()
-        ]
-    )
-    labAllUsers: list = []
-    for i in allUsers:
-        labAllUsers.append(QLabel(f"ID:{i[0]} Mail:{i[1]} Inscr.{i[4]} Status:{i[5]}"))
-    # Layouts Users
-    layUsersCmd: object = QHBoxLayout()
-    layUsersCmd.addStretch()
-    layUsersCmd.addWidget(labUserId)
-    layUsersCmd.addWidget(inpUserId)
-    layUsersCmd.addWidget(btnSuppr)
-    layUsersCmd.addStretch()
-    layUsers: object = QVBoxLayout()
-    for i in range(len(labAllUsers)):
-        layUsers.addWidget(labAllUsers[i])
-    layUserMain: object = QVBoxLayout()
-    layUserMain.addLayout(layUsersCmd)
-    layUserMain.addLayout(layUsers)
-    # Grp Users
-    grpUser: object = QGroupBox("Suppression d'un utilisateur")
-    grpUser.setLayout(layUserMain)
-
-    # Layout Main & Show
-    layoutMain: object = QVBoxLayout()
-    layoutMain.addWidget(grpUser)
-    dial.setLayout(layoutMain)
-    dial.show()
-
-
-def admin_missions(mainWindow: object):
-    # Instanciation DB
-    mission: object = dbmission.DbMission(mainWindow)
-    search:  object = dbsearch.DbSearch(mainWindow)
-
-    # Fenêtre
-    dial: object = QDialog(parent = mainWindow)
-    dial.setWindowTitle("Admin - Missions")
-
-    # Widgets Users
-    labMissionId:   object = QLabel("Id à supprimer")
-    inpMissionId:   object = QLineEdit()
-    btnSuppr:       object = QPushButton("Supprimer")
-    btnSuppr.clicked.connect(
-        lambda: [
-            coreAdmin.core_suppr_mission(
-                mainWindow,
-                inpMissionId.text()
-            ),
-            dial.close()
-        ]
-    )
-    allMissions:    object = mission.get_all_missions()
-    labAllMissions: list = []
-    for i in allMissions:
-        emploi = search.get_job_by_jobid(i[10])[0][2]
-        labAllMissions.append(QLabel(f"ID:{i[0]} date:{i[1].strftime('%m/%d/%Y')} Emploi:{emploi} sujet:{i[2]} clientId:{i[8]} proId:{i[9]} "))
-    # Layouts Missions
-    layMissionsCmd: object = QHBoxLayout()
-    layMissionsCmd.addStretch()
-    layMissionsCmd.addWidget(labMissionId)
-    layMissionsCmd.addWidget(inpMissionId)
-    layMissionsCmd.addWidget(btnSuppr)
-    layMissionsCmd.addStretch()
-    layMissions: object = QVBoxLayout()
-    for i in range(len(labAllMissions)):
-        layMissions.addWidget(labAllMissions[i])
-    layMissionMain: object = QVBoxLayout()
-    layMissionMain.addLayout(layMissionsCmd)
-    layMissionMain.addLayout(layMissions)
-    # Grp Missions
-    grpMission: object = QGroupBox("Suppression d'une mission")
-    grpMission.setLayout(layMissionMain)
-
-    # Layout Main & Show
-    layoutMain: object = QVBoxLayout()
-    layoutMain.addWidget(grpMission)
-    dial.setLayout(layoutMain)
-    dial.show()
diff --git a/src/gui/windowRecherche.py b/src/gui/windowRecherche.py
deleted file mode 100644
index dd71f08..0000000
--- a/src/gui/windowRecherche.py
+++ /dev/null
@@ -1,62 +0,0 @@
-
-from PyQt5.QtWidgets import (
-    QDialog, QVBoxLayout, QHBoxLayout,
-    QLabel, QPushButton, QMessageBox
-)
-from src.database import dbsearch
-# https://docs.python.org/3/faq/programming.html#why-do-lambdas-defined-in-a-loop-with-different-values-all-return-the-same-result
-# https://stackoverflow.com/questions/53751106/create-lambda-functions-in-a-loop-for-pyqt5-signals?noredirect=1
-
-
-def more_infos(mainWindow, proId):
-    search: object = dbsearch.DbSearch(mainWindow)
-    resRecherche: list = search.get_user_info_by_userid(proId)[0][1:]
-    label: list = [
-        "Nom",
-        "Prénom",
-        "Diplôme",
-        "Capacités",
-        "Description",
-        "Téléphone",
-        "Adresse",
-        "Code postale",
-        "Ville",
-    ]
-    text: list = []
-    for i in range(len(resRecherche)):
-        text.append(f"{label[i]}: {resRecherche[i]}")
-
-    QMessageBox.information(
-        mainWindow,
-        "Informations du pro",
-        "\n".join(text)
-    )
-
-def main(mainWindow: object, results: list) -> None:
-    dial = QDialog(parent = mainWindow)
-    dial.setWindowTitle("Recherche")
-    layoutsResult: list = []
-    for i in results:
-        layoutLine = QHBoxLayout()
-        color = results.index(i) % 2
-        if color:
-            colored = QLabel(i["text"])
-            colored.setStyleSheet("background-color: rgb(230,200,200); border-radius: 3px")
-            layoutLine.addWidget(colored)
-        else:
-            layoutLine.addWidget(QLabel(i["text"]))
-        btnInfos = QPushButton("Infos")
-        btnInfos.clicked.connect(
-            lambda checked, proId = i['id']:
-                more_infos(mainWindow, proId)
-        )
-        layoutLine.addStretch()
-        layoutLine.addWidget(btnInfos)
-        layoutsResult.append(layoutLine)
-
-    layoutMain = QVBoxLayout()
-    for layout in layoutsResult:
-        layoutMain.addLayout(layout)
-
-    dial.setLayout(layoutMain)
-    dial.show()
diff --git a/src/main.py b/src/main.py
index 8ea9c2c..24fc1e1 100644
--- a/src/main.py
+++ b/src/main.py
@@ -1,31 +1,33 @@
 
 import sys
 from PyQt5.QtWidgets import QMainWindow, QApplication
-from src.gui import pageHome
-from src.gui import globalMenu
+from src.app import mainHome
+from src.app import mainMenuBar
 
 
 class mainWindow(QMainWindow):
-
+    """"""
+    #
     VERSION = 0.1
-
+    #
     mysqlReachable: bool = False
-
-    userConnected: bool = True
-    userId:        str  = "24"
+    #
+    userConnected: bool = False
+    userId:        str  = ""
     userEmail:     str  = ""
-    userStatus:    str  = "Client"
+    userStatus:    str  = ""
     userInscrDate: str  = ""
 
     def __init__(self) -> None:
         super().__init__() # Déclenche l'"__init__" de QMainWindow
-        globalMenu.init(self)
-        pageHome.main(self)
+        mainMenuBar.menu_init(self)
+        mainHome.window_main(self)
 
 
 if __name__ == "__main__":
     def main():
-        """Démarrage de l'app
+        """
+        Démarrage de l'app
         """
         APP = QApplication(sys.argv)
         GUI = mainWindow()