public static bool VerifierAuthentification(string nom, string prenom, string pwd)
        {
            string req = "select * from developpeur d join profil p on d.idprofil = p.idprofil ";

            req += "where d.nom = @nom and d.prenom = @prenom and d.pwd = @pwd and p.nom = 'admin';";
            Dictionary <string, object> parameters = new Dictionary <string, object>();

            parameters.Add("@nom", nom);
            parameters.Add("@prenom", prenom);
            parameters.Add("@pwd", GetStringSha256Hash(pwd));
            ConnexionBDD curseur = ConnexionBDD.GetInstance(connectionString);

            curseur.ReqSelect(req, parameters);

            if (curseur.Read())
            {
                curseur.Close();
                return(true);
            }
            else
            {
                curseur.Close();
                return(false);
            }
        }
Exemplo n.º 2
0
        public static List <Developpeur> getLesDeveloppeurs()
        {
            List <Developpeur> lesDeveloppeurs = new List <Developpeur>();
            string             req             = "SELECT developpeur.iddeveloppeur AS devId, developpeur.nom AS devNom, developpeur.prenom AS devPrenom, developpeur.tel AS devTel, developpeur.mail AS devMail, developpeur.idProfil AS devIdProfil, developpeur.pwd AS devPwd, profil.nom AS profilNom" +
                                                 " FROM developpeur" +
                                                 " LEFT JOIN profil ON developpeur.idProfil = profil.idProfil" +
                                                 " ORDER BY developpeur.nom;";

            connexionDb.ReqSelect(req);

            int    idDev;
            string nom;
            string prenom;
            string tel;
            string mail;
            int    idProfil;
            string PWD;
            string profil;

            while (connexionDb.Read())
            {
                idDev    = (int)connexionDb.Field("devId");
                nom      = connexionDb.Field("devNom").ToString();
                prenom   = connexionDb.Field("devPrenom").ToString();
                tel      = connexionDb.Field("devTel").ToString();
                mail     = connexionDb.Field("devMail").ToString();
                idProfil = (int)connexionDb.Field("devIdProfil");
                PWD      = connexionDb.Field("devPwd").ToString();
                profil   = connexionDb.Field("profilNom").ToString();

                lesDeveloppeurs.Add(new Developpeur(idDev, nom, prenom, tel, mail, idProfil, profil, PWD));
            }
            connexionDb.Close();
            return(lesDeveloppeurs);
        }
Exemplo n.º 3
0
        /// <summary>
        /// Méthode qui crée une requête SQL puis l'envoie à la classe ConnexionBDD pour supprimer un membre du personnel de la base de données.
        /// </summary>
        /// <param name="personnel">Objet de type Personnel, correspondant au membre du personnel à supprimer.</param>
        public static void DelPersonnel(Personnel personnel)
        {
            string req = "delete from personnel where idpersonnel = @idpersonnel";
            Dictionary <string, object> parameters = new Dictionary <string, object>();

            parameters.Add("@idpersonnel", personnel.IdPersonnel);
            ConnexionBDD connection = ConnexionBDD.GetInstance(connectionString);

            connection.ReqUpdate(req, parameters);
            connection.Close();
        }
        public static void DelDeveloppeur(Developpeur developpeur)
        {
            string req = "delete from developpeur where iddeveloppeur = @iddeveloppeur;";
            Dictionary <string, object> parameters = new Dictionary <string, object>();

            parameters.Add("@iddeveloppeur", developpeur.IdDeveloppeur);
            ConnexionBDD connexion = ConnexionBDD.GetInstance(connectionString);

            connexion.ReqUpdate(req, parameters);
            connexion.Close();
        }
Exemplo n.º 5
0
        /// <summary>
        /// Méthode qui crée une requête sql qui récupère les utilisateurs et les mots de passe correspondants de la table 'responsable' de la base de données,
        /// à condition qu'ils correspondent avec le nom d'utilisateur et mot de passe saisis par l'utilisateur.
        /// Retourne 'vrai' si c'est le cas, 'faux' si le curseur est vide (et donc aucun utilisateur/motdepasse correspondant a été trouvé).
        /// </summary>
        /// <param name="utilisateur">Le nom d'utilisateur saisi par l'utilisateur dans la vue FrmAuthentification.</param>
        /// <param name="motdepasse">Le mot de passe saisi par l'utilisateur dans la vue FrmAuthentification.</param>
        /// <returns></returns>
        public static Boolean VerifierAuthentification(string utilisateur, string motdepasse)
        {
            string req = "select * from responsable where login=@login and pwd=@pwd;";
            Dictionary <string, object> parameters = new Dictionary <string, object>();

            parameters.Add("@login", utilisateur);
            parameters.Add("@pwd", GetStringSha256Hash(motdepasse));
            ConnexionBDD curseur = ConnexionBDD.GetInstance(connectionString);

            curseur.ReqSelect(req, parameters);

            if (curseur.Read())
            {
                curseur.Close();
                return(true);
            }
            else
            {
                curseur.Close();
                return(false);
            }
        }
Exemplo n.º 6
0
        /// <summary>
        /// Méthode qui crée une requête SQL puis l'envoie à la classe ConnexionBDD pour supprimer une absence de la base de données.
        /// </summary>
        /// <param name="absence">Objet de type absence, correspondant à l'absence qu'on veut supprimer.</param>
        /// <param name="personnelAbsence">Objet de type Personnel qui représente le membre du personnel pour lequel on veut supprimer l'absence.</param>
        public static void DelAbsence(Absence absence, Personnel personnelAbsence)
        {
            string dateDebut = DateTime.Parse(absence.DateDebut).ToString("yyyy-MM-dd");
            string req       = "delete from absence where idpersonnel = @idpersonnel and DATE(datedebut) = @datedebut;";
            Dictionary <string, object> parameters = new Dictionary <string, object>();

            parameters.Add("@idpersonnel", personnelAbsence.IdPersonnel);
            parameters.Add("@datedebut", dateDebut);
            ConnexionBDD connection = ConnexionBDD.GetInstance(connectionString);

            connection.ReqUpdate(req, parameters);
            connection.Close();
        }
Exemplo n.º 7
0
 /// <summary>
 /// Remplit le dictionnaire des motifs s'il n'a pas déjà été initialisé.
 /// </summary>
 private static void SetMotifs()
 {
     if (Absence.Motifs.Count == 0)
     {
         string       req     = "select * from motif";
         ConnexionBDD curseur = ConnexionBDD.GetInstance(connectionString);
         curseur.ReqSelect(req, null);
         while (curseur.Read())
         {
             Absence.Motifs.Add((int)curseur.Field("idmotif"), (string)curseur.Field("libelle"));
         }
         curseur.Close();
     }
 }
Exemplo n.º 8
0
 /// <summary>
 /// Remplit le dictionnaire des services s'il n'a pas déjà été initialisé.
 /// </summary>
 private static void SetServices()
 {
     if (Personnel.Services.Count == 0)
     {
         string       req     = "select * from service";
         ConnexionBDD curseur = ConnexionBDD.GetInstance(connectionString);
         curseur.ReqSelect(req, null);
         while (curseur.Read())
         {
             Personnel.Services.Add((int)curseur.Field("idservice"), (string)curseur.Field("nom"));
         }
         curseur.Close();
     }
 }
Exemplo n.º 9
0
        /// <summary>
        /// Controle si l'utillisateur a le droit de se connecter (login et pwd)
        /// </summary>
        /// <param name="login">Identifiant entré</param>
        /// <param name="pwd">Mot  de passe entré.</param>
        /// <returns></returns>
        public static Boolean ControleAuthentification(string login, string pwd)
        {
            string req = "select * from responsable ";

            req += "where login=@login and pwd=SHA2(@pwd, 256)";
            Dictionary <string, object> parameters = new Dictionary <string, object>();

            parameters.Add("@login", login);
            parameters.Add("@pwd", pwd);
            ConnexionBDD curs = ConnexionBDD.GetInstance(connectionString);

            curs.ReqSelect(req, parameters);
            if (curs.Read())
            {
                curs.Close();
                return(true);
            }
            else
            {
                curs.Close();
                return(false);
            }
        }
Exemplo n.º 10
0
        public static List <Profil> GetLesProfils()
        {
            List <Profil> lesProfils = new List <Profil>();
            string        req        = "SELECT * FROM profil ORDER BY nom";
            ConnexionBDD  curseur    = ConnexionBDD.GetInstance(connectionString);

            curseur.ReqSelect(req, null);
            while (curseur.Read())
            {
                Profil profil = new Profil((int)curseur.Field("idprofil"), (string)curseur.Field("nom"));
                lesProfils.Add(profil);
            }
            curseur.Close();
            return(lesProfils);
        }
        /// <summary>
        /// Récupère et retourne les services provenant de la BDD
        /// </summary>
        /// <returns>liste des services</returns>
        public static List <Service> GetLesServices()
        {
            List <Service> lesServices = new List <Service>();
            string         req         = "select * from service order by nom;";
            ConnexionBDD   curs        = ConnexionBDD.GetInstance(stringConnect);

            curs.ReqSelect(req, null);
            while (curs.Read())
            {
                Service service = new Service((int)curs.Field("idservice"), (string)curs.Field("nom"));
                lesServices.Add(service);
            }
            curs.Close();
            return(lesServices);
        }
Exemplo n.º 12
0
        /// <summary>
        /// Obtient l'identifiant de personnel le plus grand.
        /// </summary>
        /// <returns>Identifiant maximum de la table "personnel".</returns>
        public static int GetMaxIdPersonnel()
        {
            string       req     = "select max(idpersonnel) from personnel";
            ConnexionBDD curseur = ConnexionBDD.GetInstance(connectionString);

            curseur.ReqSelect(req, null);
            int max = -1;

            if (curseur.Read())
            {
                max = (int)curseur.Field("max(idpersonnel)");
            }
            curseur.Close();
            return(max);
        }
        /// <summary>
        /// Récupère et retourne les motifs provenant de la BDD
        /// </summary>
        /// <returns>liste des motifs</returns>
        public static List <Motif> GetLesMotifs()
        {
            List <Motif> lesMotifs = new List <Motif>();
            string       req       = "select * from motif order by libelle;";
            ConnexionBDD curs      = ConnexionBDD.GetInstance(stringConnect);

            curs.ReqSelect(req, null);
            while (curs.Read())
            {
                Motif motif = new Motif((int)curs.Field("idmotif"), (string)curs.Field("libelle"));
                lesMotifs.Add(motif);
            }
            curs.Close();
            return(lesMotifs);
        }
Exemplo n.º 14
0
        /// <summary>
        /// Récupère et retourne les profils provenant de la BDD
        /// </summary>
        /// <returns>liste des profils</returns>
        public static List <Profil> GetLesProfils()
        {
            List <Profil> lesProfils = new List <Profil>();
            string        req        = "select * from profil order by nom;";
            ConnexionBDD  curs       = ConnexionBDD.GetInstance(connectionString);

            curs.ReqSelect(req, null);
            while (curs.Read())
            {
                Profil profil = new Profil((int)curs.Field("idprofil"), (string)curs.Field("nom"));
                lesProfils.Add(profil);
            }
            curs.Close();
            return(lesProfils);
        }
Exemplo n.º 15
0
        /// <summary>
        /// Méthode qui crée une requête SQL puis l'envoie à la classe ConnexionBDD pour récupérer une liste d'objets du type Personnel, correspondant aux membres du personnel enregistrés dans la base de données.
        /// </summary>
        /// <returns>Une liste d'objets du type Personnel.</returns>
        public static List <Personnel> GetLePersonnel()
        {
            List <Personnel> lePersonnel = new List <Personnel>();
            string           req         = "select p.idpersonnel as idpersonnel, p.idservice as idservice, p.nom as nom, p.prenom as prenom, s.nom as service, p.tel as tel, p.mail as mail ";

            req += "from personnel p join service s on p.idservice = s.idservice order by nom, prenom;";
            ConnexionBDD curseur = ConnexionBDD.GetInstance(connectionString);

            curseur.ReqSelect(req, null);
            while (curseur.Read())
            {
                lePersonnel.Add(new Personnel((int)curseur.Field("idpersonnel"), (int)curseur.Field("idservice"), (string)curseur.Field("nom"), (string)curseur.Field("prenom"), (string)curseur.Field("service"), (string)curseur.Field("tel"), (string)curseur.Field("mail")));
            }
            curseur.Close();
            return(lePersonnel);
        }
Exemplo n.º 16
0
        /// <summary>
        /// Méthode qui crée une requête SQL puis l'envoie à la classe ConnexionBDD pour ajouter une nouvelle absence dans la base de données.
        /// </summary>
        /// <param name="absence">Objet de type Absence, correspondant à la nouvelle absence.</param>
        public static void AddAbsence(Absence absence)
        {
            string req = "insert into absence(idpersonnel, datedebut, idmotif, datefin) ";

            req += "values(@idpersonnel, @datedebut, @idmotif, @datefin);";
            Dictionary <string, object> parameters = new Dictionary <string, object>();

            parameters.Add("@idpersonnel", absence.IdPersonnel);
            parameters.Add("@datedebut", absence.DateDebut);
            parameters.Add("@idmotif", absence.IdMotif);
            parameters.Add("@datefin", absence.DateFin);
            ConnexionBDD connection = ConnexionBDD.GetInstance(connectionString);

            connection.ReqUpdate(req, parameters);
            connection.Close();
        }
Exemplo n.º 17
0
        public static List <Developpeur> GetLesDeveloppeurs()
        {
            List <Developpeur> lesDeveloppeurs = new List <Developpeur>();
            string             req             = "SELECT d.iddeveloppeur as iddeveloppeur, d.nom as nom, d.prenom as prenom, d.tel as tel, d.mail as mail, p.idprofil as idprofil, p.nom as profil ";

            req += "FROM developpeur AS d JOIN profil AS p ON(d.idprofil = p.idprofil) ORDER BY nom, prenom";
            ConnexionBDD curseur = ConnexionBDD.GetInstance(connectionString);

            curseur.ReqSelect(req, null);
            while (curseur.Read())
            {
                Developpeur developpeur = new Developpeur((int)curseur.Field("iddeveloppeur"), (string)curseur.Field("nom"), (string)curseur.Field("prenom"), (string)curseur.Field("tel"), (string)curseur.Field("mail"), (int)curseur.Field("idprofil"), (string)curseur.Field("profil"));
                lesDeveloppeurs.Add(developpeur);
            }
            curseur.Close();
            return(lesDeveloppeurs);
        }
Exemplo n.º 18
0
        /// <summary>
        /// Remplit les absences d'un personnel.
        /// </summary>
        /// <param name="personnel">Personnel concerné</param>
        public static void SetAbsences(Personnel personnel)
        {
            string req = "select p.idpersonnel, a.datedebut, a.datefin, a.idmotif from personnel p JOIN absence a USING (idpersonnel)";

            req += " where p.idpersonnel = @idpersonnel";
            req += " order by datedebut DESC";
            ConnexionBDD curseur = ConnexionBDD.GetInstance(connectionString);
            Dictionary <string, object> parameters = new Dictionary <string, object>();

            parameters.Add("@idpersonnel", personnel.IdPersonnel);
            curseur.ReqSelect(req, parameters);
            while (curseur.Read())
            {
                personnel.Absences.Add(new Absence(personnel, (DateTime)curseur.Field("datedebut"), (DateTime)curseur.Field("datefin"), (int)curseur.Field("idmotif")));
            }
            curseur.Close();
        }
Exemplo n.º 19
0
        /// <summary>
        /// Méthode qui crée une requête SQL puis l'envoie à la classe ConnexionBDD pour modifier un membre du personnel présent dans la base de données.
        /// </summary>
        /// <param name="personnel">Objet de type Personnel, correspondant au membre du personnel à modifier.</param>
        public static void UpdatePersonnel(Personnel personnel)
        {
            string req = "update personnel set idservice = @idservice, nom = @nom, prenom = @prenom, tel = @tel, mail = @mail ";

            req += "where idpersonnel = @idpersonnel;";
            Dictionary <string, object> parameters = new Dictionary <string, object>();

            parameters.Add("@idpersonnel", personnel.IdPersonnel);
            parameters.Add("@idservice", personnel.IdService);
            parameters.Add("@nom", personnel.Nom);
            parameters.Add("@prenom", personnel.Prenom);
            parameters.Add("@tel", personnel.Tel);
            parameters.Add("@mail", personnel.Mail);
            ConnexionBDD connection = ConnexionBDD.GetInstance(connectionString);

            connection.ReqUpdate(req, parameters);
            connection.Close();
        }
Exemplo n.º 20
0
        /// <summary>
        /// Méthode qui crée une requête SQL puis l'envoie à la classe ConnexionBDD pour modifier une absence de la base de données.
        /// </summary>
        /// <param name="absenceAModifier">Objet de type absence, correspondant à l'absence initiale qu'on veut modifier.</param>
        /// <param name="nouvelleAbsence">Objet de type absence, correspondant à l'absence initiale modifiée.</param>
        public static void UpdateAbsence(Absence absenceAModifier, Absence nouvelleAbsence)
        {
            string ancienneDateDebut = DateTime.Parse(absenceAModifier.DateDebut).ToString("yyyy-MM-dd");
            string req = "update absence set datedebut = @nouveaudatedebut, idmotif = @idmotif, datefin = @datefin ";

            req += "where idpersonnel = @idpersonnel and DATE(datedebut) = @anciennedatedebut;";
            Dictionary <string, object> parameters = new Dictionary <string, object>();

            parameters.Add("@nouveaudatedebut", nouvelleAbsence.DateDebut);
            parameters.Add("idmotif", nouvelleAbsence.IdMotif);
            parameters.Add("datefin", nouvelleAbsence.DateFin);
            parameters.Add("idpersonnel", absenceAModifier.IdPersonnel);
            parameters.Add("@anciennedatedebut", ancienneDateDebut);
            ConnexionBDD connection = ConnexionBDD.GetInstance(connectionString);

            connection.ReqUpdate(req, parameters);
            connection.Close();
        }
Exemplo n.º 21
0
        /// <summary>
        /// Méthode qui crée une requête SQL puis l'envoie à la classe ConnexionBDD pour ajouter un nouveau membre du personnel dans la base de données.
        /// </summary>
        /// <param name="personnel">Objet de type Personnel, correspondant au nouveau membre du personnel.</param>
        public static void AddPersonnel(Personnel personnel)
        {
            string req = "insert into personnel(idpersonnel, idservice, nom, prenom, tel, mail) ";

            req += "values(@idpersonnel, @idservice, @nom, @prenom, @tel, @mail);";
            Dictionary <string, object> parameters = new Dictionary <string, object>();

            parameters.Add("@idpersonnel", personnel.IdPersonnel);
            parameters.Add("@idservice", personnel.IdService);
            parameters.Add("@nom", personnel.Nom);
            parameters.Add("@prenom", personnel.Prenom);
            parameters.Add("@tel", personnel.Tel);
            parameters.Add("@mail", personnel.Mail);
            ConnexionBDD connection = ConnexionBDD.GetInstance(connectionString);

            connection.ReqUpdate(req, parameters);
            connection.Close();
        }
Exemplo n.º 22
0
        /// <summary>
        /// Récupère et retourne les développeurs provenant de la BDD
        /// </summary>
        /// <returns>liste des développeurs</returns>
        public static List <Developpeur> GetLesDeveloppeurs()
        {
            List <Developpeur> lesDeveloppeurs = new List <Developpeur>();
            string             req             = "select d.iddeveloppeur as iddeveloppeur, d.nom as nom, d.prenom as prenom, d.tel as tel, d.mail as mail, p.idprofil as idprofil, p.nom as profil ";

            req += "from developpeur d join profil p on (d.idprofil = p.idprofil) ";
            req += "order by nom, prenom;";
            ConnexionBDD curs = ConnexionBDD.GetInstance(connectionString);

            curs.ReqSelect(req, null);
            while (curs.Read())
            {
                Developpeur developpeur = new Developpeur((int)curs.Field("iddeveloppeur"), (string)curs.Field("nom"), (string)curs.Field("prenom"), (string)curs.Field("tel"), (string)curs.Field("mail"), (int)curs.Field("idprofil"), (string)curs.Field("profil"));
                lesDeveloppeurs.Add(developpeur);
            }
            curs.Close();
            return(lesDeveloppeurs);
        }
        /// <summary>
        /// récupère et retourne le personnel provenant de la BDD
        /// </summary>
        /// <returns>liste de personnel</returns>
        public static List <Personnel> GetLesPersonnels()
        {
            List <Personnel> lesPersonnels = new List <Personnel>();
            string           req           = "select p.idpersonnel as idpersonnel, p.nom as nom, p.prenom as prenom, p.tel as tel, p.mail as mail, s.idservice as idservice, s.nom as service ";

            req += "from personnel p join service s on (p.idservice = s.idservice) ";
            req += "order by nom, prenom;";
            ConnexionBDD curs = ConnexionBDD.GetInstance(stringConnect);

            curs.ReqSelect(req, null);
            while (curs.Read())
            {
                Personnel personnel = new Personnel((int)curs.Field("idpersonnel"), (string)curs.Field("nom"), (string)curs.Field("prenom"), (string)curs.Field("tel"), (string)curs.Field("mail"), (int)curs.Field("idservice"), (string)curs.Field("service"));
                lesPersonnels.Add(personnel);
            }
            curs.Close();
            return(lesPersonnels);
        }
        /// <summary>
        /// récupère et retourne les absences de la BDD en fonction de l'idpersonnel
        /// La requête classe les absences en fonction de la date de debut d'absence la plus récente à la plus anciennce
        /// </summary>
        /// <returns></returns>
        public static List <Absences> GetLesAbsences(Personnel personnel)
        {
            List <Absences>             LesAbsences = new List <Absences>();
            string                      req         = "select *, m.libelle as motif from absence a join motif m on (a.idmotif = m.idmotif) where idpersonnel = @idpersonnel order by datedebut DESC;";
            ConnexionBDD                curs        = ConnexionBDD.GetInstance(stringConnect);
            Dictionary <string, object> parameters  = new Dictionary <string, object>
            {
                { "@idpersonnel", personnel.Idpersonnel }
            };

            curs.ReqSelect(req, parameters);
            while (curs.Read())
            {
                Absences absences = new Absences((int)curs.Field("idpersonnel"), (DateTime)curs.Field("datedebut"), (int)curs.Field("idmotif"), (string)curs.Field("motif"), (DateTime)curs.Field("datefin"));
                LesAbsences.Add(absences);
            }
            curs.Close();
            return(LesAbsences);
        }
Exemplo n.º 25
0
        /// <summary>
        /// Méthode qui crée une requête SQL puis l'envoie à la classe ConnexionBDD pour récupérer une liste d'objets du type Absence, correspondant aux différents absences enregistrés dans la base de données pour un membre du personnel.
        /// </summary>
        /// <param name="personnel">Objet du type Personnel qui représente le membre du personnel dont on veut afficher les absences.</param>
        /// <returns>La liste d'absences du membre du personnel passé en entrée.</returns>
        public static List <Absence> GetLesAbsences(Personnel personnel)
        {
            List <Absence> lesAbsences = new List <Absence>();
            string         req         = "select a.datedebut, a.idmotif as 'idmotif', m.libelle as 'motif', a.datefin from absence a join motif m on a.idmotif = m.idmotif ";

            req += "where idpersonnel = @idpersonnel order by datedebut desc;";
            Dictionary <string, object> parameters = new Dictionary <string, object>();

            parameters.Add("@idpersonnel", personnel.IdPersonnel);
            ConnexionBDD curseur = ConnexionBDD.GetInstance(connectionString);

            curseur.ReqSelect(req, parameters);
            while (curseur.Read())
            {
                string  dateDebut = ((DateTime)curseur.Field("datedebut")).ToString("dd/MM/yyyy");
                string  dateFin   = ((DateTime)curseur.Field("datefin")).ToString("dd/MM/yyyy");
                Absence absence   = new Absence((int)personnel.IdPersonnel, dateDebut, (int)curseur.Field("idmotif"), (string)curseur.Field("motif"), dateFin);                lesAbsences.Add(absence);
            }
            curseur.Close();
            return(lesAbsences);
        }
Exemplo n.º 26
0
        /// <summary>
        /// Obtient la liste du personnel depuis la base de données.
        /// </summary>
        /// <returns>Liste du personnel.</returns>
        public static List <Personnel> GetPersonnels()
        {
            SetServices();
            List <Personnel> personnels = new List <Personnel>();
            string           req        = "select * from personnel join service using (idservice)";
            ConnexionBDD     curseur    = ConnexionBDD.GetInstance(connectionString);

            curseur.ReqSelect(req, null);

            while (curseur.Read())
            {
                personnels.Add(new Personnel((int)curseur.Field("idpersonnel"), (string)curseur.Field("nom"),
                                             (string)curseur.Field("prenom"), (string)curseur.Field("mail"), (string)curseur.Field("tel"), (int)curseur.Field("idService")));
            }
            curseur.Close();

            SetMotifs();
            foreach (Personnel personnel in personnels)
            {
                SetAbsences(personnel);
            }
            return(personnels);
        }