Documentation des class 3

core/class/debug.class.php

@@ -1,17 +1,49 @@
 <?php
 
+/**
+ * Classe de gestion des fonctionnalités de débogage.
+ *
+ * Cette classe fournit des outils pour le débogage, tels que la gestion des journaux,
+ * l'affichage des erreurs, et la mesure du temps d'exécution.
+ */
 class debug
 {
+    /**
+     * Tableau des journaux de débogage.
+     *
+     * @var array
+     */
     private static $logs = [];
+
+    /**
+     * Temps de début pour mesurer l'exécution.
+     *
+     * @var float
+     */
     private static $startTime;
+
+    /**
+     * Temps de fin pour mesurer l'exécution.
+     *
+     * @var float
+     */
     private static $closeTime;
 
+    /**
+     * Active l'affichage des erreurs PHP.
+     */
     public static function display_errors(){
         ini_set('display_errors', 1);
         ini_set('display_startup_errors', 1);
         error_reporting(E_ALL);
     }
     
+    /**
+     * Génère le type de fichier en fonction d'une chaîne donnée.
+     *
+     * @param string $_string Chaîne utilisée pour déterminer le type de fichier.
+     * @return string Nom du fichier généré.
+     */
     private static function typeFile(string $_string){
         switch ($_string) {
             case 'maintenance':
@@ -26,6 +58,11 @@ class debug
         }
     }
     
+    /**
+     * Ajoute un fichier spécifique dans le répertoire racine.
+     *
+     * @param string|null $_string Nom du fichier à ajouter (optionnel).
+     */
     public static function addFile(?string $_string = NULL)
     {
         if($_string != NULL){
@@ -34,6 +71,11 @@ class debug
         }
     }
 
+    /**
+     * Supprime un fichier spécifique du répertoire racine.
+     *
+     * @param string|null $_string Nom du fichier à supprimer (optionnel).
+     */
     public static function removeFile(?string $_string = NULL)
     {
         if($_string != NULL){
@@ -41,11 +83,20 @@ class debug
         }
     }
 
+    /**
+     * Vérifie si un fichier spécifique existe dans le répertoire racine.
+     *
+     * @param string|null $_string Nom du fichier à vérifier (optionnel).
+     * @return bool TRUE si le fichier existe, FALSE sinon.
+     */
     public static function isFile(?string $_string = NULL)
     {
         return file_exists(DOCUMENT_ROOT . self::typeFile($_string)) ? TRUE : FALSE;
     }
     
+    /**
+     * Inclut les ressources de débogage si le mode debug est activé.
+     */
     public static function includeDebug()
     {
         if (debug::isFile("debug")) {
@@ -53,6 +104,14 @@ class debug
         }
     }
 
+    /**
+     * Affiche ou retourne une variable formatée pour le débogage.
+     *
+     * @param mixed $var Variable à afficher.
+     * @param string $label Étiquette pour identifier la variable (par défaut 'Dump').
+     * @param bool $echo Indique si la sortie doit être affichée (TRUE) ou retournée (FALSE).
+     * @return string|null Contenu formaté si $echo est FALSE, sinon NULL.
+     */
     public static function dump($var, $label = 'Dump', $echo = true)
     {
         // Start output buffering
@@ -83,6 +142,13 @@ class debug
         }
     }
 
+    /**
+     * Convertit un objet en chaîne formatée pour le débogage.
+     *
+     * @param object $object Objet à convertir.
+     * @param string|null $_tab Indentation pour le formatage (optionnel).
+     * @return string Représentation formatée de l'objet.
+     */
     public static function objectToString($object, $_tab = NULL) {
         ob_start();
 
@@ -109,6 +175,13 @@ class debug
 
 
 
+    /**
+     * Convertit un tableau en chaîne formatée pour le débogage.
+     *
+     * @param array $array Tableau à convertir.
+     * @param string|null $_tab Indentation pour le formatage (optionnel).
+     * @return string Représentation formatée du tableau.
+     */
     public static function arrayToString($array, $_tab = NULL)
     {
         ob_start();
@@ -134,6 +207,13 @@ class debug
         return ob_get_clean();
     }
 
+    /**
+     * Convertit une variable en chaîne de caractères pour le débogage.
+     *
+     * @param mixed $var La variable à convertir.
+     * @param string $label Une étiquette pour identifier la variable.
+     * @return string La représentation formatée de la variable.
+     */
     private static function variableToString($var, $label)
     {
         ob_start();
@@ -146,6 +226,11 @@ class debug
         return ob_get_clean();
     }
 
+    /**
+     * Récupère la trace d'exécution sous forme de chaîne.
+     *
+     * @return string La trace d'exécution formatée.
+     */
     public static function getTraces(){
         $return = "Trace : ";
         
@@ -162,6 +247,12 @@ class debug
         return $return;
     }
 
+    /**
+     * Affiche un tableau formaté pour le débogage.
+     *
+     * @param array|null $_array Le tableau à afficher (optionnel).
+     * @param int|null $_exit Si défini, termine le script après l'affichage (optionnel).
+     */
     public static function print_r(?array $_array = NULL, ?int $_exit = NULL)
     {
         echo "<div>".debug::getTraces() . "</div>";
@@ -176,12 +267,24 @@ class debug
         ($_exit != NULL) ? exit() : NULL;
     }
 
+    /**
+     * Vérifie si une chaîne contient du HTML.
+     *
+     * @param string $_string La chaîne à vérifier.
+     * @return bool TRUE si la chaîne contient du HTML, FALSE sinon.
+     */
     public static function isHtml(string $_string) : bool 
     {
         $stripped_string = strip_tags($_string);
         return $_string !== $stripped_string;
     }
 
+    /**
+     * Génère un contenu HTML encapsulé dans un iframe.
+     *
+     * @param string $htmlContent Le contenu HTML à encapsuler.
+     * @return string Le contenu HTML complet avec iframe.
+     */
     public static function generateHtmlContent($htmlContent)
     {
         $id = md5(microtime());
@@ -213,6 +316,12 @@ class debug
     }
 
 
+    /**
+     * Ajoute un message au journal de débogage.
+     *
+     * @param mixed $_message Le message à ajouter.
+     * @param string|null $_mark Une marque pour identifier le message (optionnel).
+     */
     public static function log($_message, $_mark = NULL)
     {        
         $mark = "<div class='debug-head-console'>";
@@ -234,6 +343,12 @@ class debug
         }
     }
 
+    /**
+     * Ajoute un message au journal de session de débogage.
+     *
+     * @param mixed $_message Le message à ajouter.
+     * @param string|null $_mark Une marque pour identifier le message (optionnel).
+     */
     public static function logSession($_message, $_mark = NULL)
     {        
         $mark = "<div class='debug-head-console'>";
@@ -255,6 +370,9 @@ class debug
         }
     }
 
+    /**
+     * Affiche les journaux de débogage.
+     */
     public static function renderLogs()
     {
             echo "<div id='debugger-logs'>";
@@ -301,6 +419,9 @@ class debug
             get::javascript("debug");
     }
 
+    /**
+     * Initialise le débogueur en enregistrant une fonction de fermeture.
+     */
     public static function init()
     {
         // Register shutdown function to render logs at the end of the script execution
@@ -309,24 +430,46 @@ class debug
         });
     }
 
+    /**
+     * Démarre un chronomètre pour mesurer le temps d'exécution.
+     */
     public static function startTimer()
     {
         self::$startTime = microtime(true);
     }
 
+    /**
+     * Arrête le chronomètre et calcule le temps écoulé.
+     */
     public static function endTimer()
     {
         self::$closeTime = microtime(true) - self::$startTime;
     }
 
+    /**
+     * Génère un badge HTML avec un lien et un libellé.
+     *
+     * @param string $_link Lien vers lequel le badge redirige.
+     * @param string $_label Libellé affiché sur le badge.
+     * @return string Le code HTML du badge.
+     */
     public static function getBadge(string $_link,string $_label){
         return '<a href="'. $_link .'" target="_blank" class="badge debug-badge">'. $_label .'</a>';
     }
 
+    /**
+     * Affiche l'environnement actuel si ce n'est pas l'environnement de production.
+     */
     public static function printEnvironnement(){
         echo (ENVIRONNEMENT != "PROD") ? " [" . ENVIRONNEMENT . "]" : NULL;
     }
 
+    /**
+     * Construit un badge HTML personnalisé à partir des données fournies.
+     *
+     * @param array $_data Données pour personnaliser le badge (couleur, texte, lien, etc.).
+     * @return string Le code HTML du badge.
+     */
     private static function buildBadge(array $_data){
         $color = empty($_data["color"]) ? "black" : $_data["color"];
         $backgroundColor = empty($_data["background-color"]) ? "orangered" : $_data["background-color"];
@@ -337,6 +480,11 @@ class debug
         return "<a href=\"" . $link . "\"><span class=\"badge " . $class . "\" style=\"background-color:" . $backgroundColor . "; color:" . $color . "; padding: 3px 5px 2px 5px; margin-right: 5px;\">" . $icon . $txt . "</span></a>";
     }
 
+    /**
+     * Récupère tous les badges de débogage disponibles.
+     *
+     * @return string Les badges HTML générés.
+     */
     public static function getBadges(){
         $return = "";
         if(debug::isFile("maintenance")){
@@ -401,20 +549,38 @@ class debug
         return $return;
     }
 
+    /**
+     * Ajoute des données au tableau de session de débogage.
+     *
+     * @param mixed $_data Les données à ajouter à la session.
+     */
     public static function setSession($_data){
         $_SESSION["DEBUG"][] = $_data;
     }
 
+    /**
+     * Récupère les données de la session de débogage et les réinitialise.
+     *
+     * @return array Les données de la session de débogage.
+     */
     public static function getSession(){
         $return = $_SESSION["DEBUG"];
         self::resetSession();
         return $return;
     }
 
+    /**
+     * Vérifie si des données de débogage sont présentes dans la session.
+     *
+     * @return bool TRUE si des données sont présentes, FALSE sinon.
+     */
     public static function ifSession(){
         return empty($_SESSION["DEBUG"]) ? FALSE : TRUE;
     }
 
+    /**
+     * Réinitialise les données de la session de débogage.
+     */
     public static function resetSession(){
         unset($_SESSION["DEBUG"]);
     }

core/class/proweb.class.php

@@ -1,7 +1,17 @@
 <?php
 
+/**
+ * Classe proweb
+ * 
+ * Cette classe gère les opérations liées aux données Proweb, telles que la récupération, la suppression et la vérification des données.
+ */
 class proweb
 {
+    /**
+     * Récupère les données de base des salariés Proweb.
+     *
+     * @return array Résultats des salariés Proweb.
+     */
     public static function getBase()
     {
         db::query("SELECT *, 
@@ -13,6 +23,12 @@ class proweb
         return db::resultset();
     }
 
+    /**
+     * Récupère les informations d'un fichier Excel Proweb par son identifiant.
+     *
+     * @param int $_id Identifiant du fichier Excel.
+     * @return array Informations du fichier Excel.
+     */
     public static function getExcelById(int $_id)
     {
         db::query("SELECT * FROM " . DB_T_EXCEL_PROWEB . " WHERE id = :id");
@@ -20,6 +36,12 @@ class proweb
         return db::single();
     }
 
+    /**
+     * Supprime un fichier Excel Proweb par son identifiant.
+     *
+     * @param int $_id Identifiant du fichier Excel.
+     * @return bool Succès ou échec de la suppression.
+     */
     public static function deleteExcel(int $_id)
     {
 
@@ -36,12 +58,23 @@ class proweb
         }
     }
 
+    /**
+     * Récupère les informations du dernier fichier Excel.
+     *
+     * @return array Informations du dernier fichier Excel.
+     */
     public static function getExcel()
     {
         db::query("SELECT * FROM " . DB_T_EXCEL . " ORDER BY id DESC LIMIT 0, 1");
         return db::single();
     }
 
+    /**
+     * Convertit une date en format "MoisAnnée".
+     *
+     * @param string $datetime La date à convertir.
+     * @return string La date convertie.
+     */
     public static function convertDateMoisAn(string $datetime)
     {
         $pieces = explode(" ", $datetime);
@@ -49,12 +82,24 @@ class proweb
         return $pieces2[0] . $pieces2[1];
     }
 
+    /**
+     * Convertit une date en format "JourMoisAnnée".
+     *
+     * @param string $datetime La date à convertir.
+     * @return string La date convertie.
+     */
     public static function convertDateMoisAnJour(string $datetime)
     {
         $pieces = explode(" ", $datetime);
         return $pieces[0];
     }
 
+    /**
+     * Archive les valeurs d'un fichier Excel Proweb.
+     *
+     * @param array $_array Données à archiver.
+     * @return array Données archivées avec les erreurs éventuelles.
+     */
     public static function archiveExcelValues(array $_array)
     {
         $_return["error"] = 0;
@@ -147,8 +192,50 @@ class proweb
         return $_return;
     }
 
-    // Les initialisations
+    /**
+     * Vérifie les données d'un salarié par son identifiant de connexion.
+     *
+     * @param string $_loginId Identifiant de connexion du salarié.
+     * @param string|null $_nom Nom du salarié (optionnel).
+     * @param string|null $_prenom Prénom du salarié (optionnel).
+     * @return array Données du salarié vérifié.
+     */
+    public static function checkSalarieByLoginId(string $_loginId, ?string $_nom = NULL, ?string $_prenom = NULL)
+    {
+        // Récupération des données de l'excel au format Json
+        if ($_nom == NULL) {
+            db::query("SELECT id, loginId, jourEntree, jourSortie, contrat FROM " . DB_T_SALARIES . " WHERE loginId = :loginId");
+        } else {
+            db::query("SELECT id, loginId, jourEntree, jourSortie, contrat FROM " . DB_T_SALARIES . " WHERE loginId = :loginId OR (nom = :nom AND prenom = :prenom)");
+            db::bind(':nom', $_nom);
+            db::bind(':prenom', $_prenom);
+        }
+        db::bind(':loginId', $_loginId);
+        return db::single();
+    }
 
+    /**
+     * Télécharge un fichier Excel Proweb par son identifiant.
+     *
+     * @param int $_id Identifiant du fichier Excel.
+     * @param string $_file Nom du fichier temporaire.
+     * @return string Chemin du fichier téléchargé.
+     */
+    public static function downloadExcel(int $_id, string $_file)
+    {
+        $data = base64_decode(self::getExcelById($_id)["file"]);
+        $fileTemp = fopen(DIR_TEMP . $_file, "w");
+        file_put_contents(DIR_TEMP . $_file, $data);
+        fclose($fileTemp);
+        return DIR_TEMP . $_file;
+    }
+
+    /**
+     * Convertit une date en format approprié pour l'archivage.
+     *
+     * @param string $_string La date à convertir.
+     * @return string La date convertie ou "N/A" si invalide.
+     */
     private static function archiveExcelValuesDate(string $_string)
     {
         if(!isset($_string) or $_string == "00-00-0000"){
@@ -158,26 +245,56 @@ class proweb
         }
     }
 
+    /**
+     * Convertit le sexe en format approprié pour l'archivage.
+     *
+     * @param string $_string Le sexe à convertir.
+     * @return string Le sexe converti ou "N/A" si invalide.
+     */
     private static function archiveExcelValuesSexe(string $_string)
     {
         return (empty($_string)) ? "N/A" : $_string;
     }
 
+    /**
+     * Nettoie et convertit un identifiant de connexion pour l'archivage.
+     *
+     * @param string $_string L'identifiant à convertir.
+     * @return string L'identifiant nettoyé.
+     */
     private static function archiveExcelValuesloginId(string $_string)
     {
         return core::cleanAccent($_string);
     }
 
+    /**
+     * Nettoie et convertit un nom pour l'archivage.
+     *
+     * @param string $_string Le nom à convertir.
+     * @return string Le nom nettoyé.
+     */
     private static function archiveExcelValuesNom(string $_string)
     {
         return core::cleanAccent($_string);
     }
 
+    /**
+     * Nettoie et convertit un prénom pour l'archivage.
+     *
+     * @param string $_string Le prénom à convertir.
+     * @return string Le prénom nettoyé.
+     */
     private static function archiveExcelValuesPrenom(string $_string)
     {
         return core::cleanAccent($_string);
     }
 
+    /**
+     * Convertit une valeur d'activité pour l'archivage.
+     *
+     * @param string $_string La valeur à convertir.
+     * @return int|string La valeur convertie ou "N/A" si invalide.
+     */
     private static function archiveExcelValuesActif(string $_string)
     {
         if ($_string == "O") {
@@ -189,33 +306,36 @@ class proweb
         }
     }
 
+    /**
+     * Nettoie et convertit un lieu pour l'archivage.
+     *
+     * @param string $_string Le lieu à convertir.
+     * @return string Le lieu nettoyé ou "N/A" si invalide.
+     */
     private static function archiveExcelValuesLieu(string $_string)
     {
         return (empty($_string)) ? "N/A" : $_string;
     }
 
-    // Les checks 
-
-    public static function checkSalarieByLoginId(string $_loginId, string $_nom = NULL, string $_prenom = NULL)
-    {
-        // Récupération des données de l'excel au format Json
-        if ($_nom == NULL) {
-            db::query("SELECT id, loginId, jourEntree, jourSortie, contrat FROM " . DB_T_SALARIES . " WHERE loginId = :loginId");
-        } else {
-            db::query("SELECT id, loginId, jourEntree, jourSortie, contrat FROM " . DB_T_SALARIES . " WHERE loginId = :loginId OR (nom = :nom AND prenom = :prenom)");
-            db::bind(':nom', $_nom);
-            db::bind(':prenom', $_prenom);
-        }
-        db::bind(':loginId', $_loginId);
-        return db::single();
-    }
-
+    /**
+     * Vérifie si une valeur d'activité est valide.
+     *
+     * @param string $_string La valeur à vérifier.
+     * @return bool TRUE si valide, FALSE sinon.
+     */
     private static function checkValuesActif(string $_string)
     {
         return ($_string == "N/A") ? FALSE : TRUE;
     }
 
-    private static function checkValuesloginId(string $_idLogin, string $_idLoginRH = NULL)
+    /**
+     * Vérifie si un identifiant de connexion est valide.
+     *
+     * @param string $_idLogin Identifiant de connexion.
+     * @param string|null $_idLoginRH Identifiant RH (optionnel).
+     * @return bool TRUE si valide, FALSE sinon.
+     */
+    private static function checkValuesloginId(string $_idLogin, ?string $_idLoginRH = NULL)
     {
         if ($_idLoginRH != NULL) {
             if (empty(self::checkSalarieByLoginId($_idLogin)["id"])) {
@@ -234,41 +354,91 @@ class proweb
         }
     }
 
+    /**
+     * Vérifie si une valeur RHBase est valide.
+     *
+     * @param int $_RH Valeur RHBase.
+     * @param int $_actif Valeur actif.
+     * @return bool TRUE si valide, FALSE sinon.
+     */
     private static function checkValuesRHBase(int $_RH, int $_actif)
     {
         return ($_RH == 0 and $_actif == 1) ? FALSE : TRUE;
     }
 
+    /**
+     * Vérifie si une date d'entrée est valide.
+     *
+     * @param string $_string La date d'entrée.
+     * @return bool TRUE si valide, FALSE sinon.
+     */
     private static function checkValuesJourEntree(string $_string)
     {
         return ($_string == "N/A") ? FALSE : TRUE;
     }
 
+    /**
+     * Vérifie si une date de sortie est valide.
+     *
+     * @param string $_string La date de sortie.
+     * @param int $_actif Valeur actif.
+     * @return bool TRUE si valide, FALSE sinon.
+     */
     private static function checkValuesJourSortie(string $_string, int $_actif)
     {
         return ($_string != "N/A" and $_actif == 1) ? FALSE : TRUE;
     }
 
+    /**
+     * Vérifie si un nom est valide.
+     *
+     * @param string $_string Le nom à vérifier.
+     * @return bool TRUE si valide, FALSE sinon.
+     */
     private static function checkValuesNom(string $_string)
     {
         return (empty($_string)) ? FALSE : TRUE;
     }
 
+    /**
+     * Vérifie si un prénom est valide.
+     *
+     * @param string $_string Le prénom à vérifier.
+     * @return bool TRUE si valide, FALSE sinon.
+     */
     private static function checkValuesPrenom(string $_string)
     {
         return (empty($_string)) ? FALSE : TRUE;
     }
 
+    /**
+     * Vérifie si un sexe est valide.
+     *
+     * @param string $_string Le sexe à vérifier.
+     * @return bool TRUE si valide, FALSE sinon.
+     */
     private static function checkValuesSexe(string $_string)
     {
         return ($_string == NULL or ($_string != "M." and $_string != "Mme")) ? FALSE : TRUE;
     }
 
+    /**
+     * Vérifie si un lieu est valide.
+     *
+     * @param string $_string Le lieu à vérifier.
+     * @return bool TRUE si valide, FALSE sinon.
+     */
     private static function checkValuesLieu(string $_string)
     {
         return (empty($_string)) ? FALSE : TRUE;
     }
 
+    /**
+     * Vérifie si une date de naissance est valide.
+     *
+     * @param string $_string La date de naissance.
+     * @return bool TRUE si valide, FALSE sinon.
+     */
     private static function checkValuesNaissance(string $_string)
     {
         if(empty($_string) OR $_string == "N/A") {
@@ -280,6 +450,12 @@ class proweb
         }
     }
 
+    /**
+     * Calcule l'âge à partir d'une date de naissance.
+     *
+     * @param string $_date La date de naissance.
+     * @return int L'âge calculé.
+     */
     private static function calculAge(string $_date)
     {
         $pieces = explode(" ", $_date);
@@ -288,13 +464,4 @@ class proweb
         ? ((date("Y") - $birthDate[0]) - 1)
         : (date("Y") - $birthDate[0]));
     }
-
-    public static function downloadExcel(int $_id, string $_file)
-    {
-        $data = base64_decode(self::getExcelById($_id)["file"]);
-        $fileTemp = fopen(DIR_TEMP . $_file, "w");
-        file_put_contents(DIR_TEMP . $_file, $data);
-        fclose($fileTemp);
-        return DIR_TEMP . $_file;
-    }
 }

core/class/prowebDossiers.class.php

@@ -1,8 +1,18 @@
 <?php
 
+/**
+ * Classe prowebDossiers
+ * 
+ * Cette classe gère les opérations liées aux dossiers Proweb, telles que la récupération, l'ajout, la suppression et la vérification des données.
+ */
 class prowebDossiers
 {
-
+    /**
+     * Récupère les informations d'un fichier Excel Proweb par son identifiant.
+     *
+     * @param int $_id Identifiant du fichier Excel.
+     * @return array Informations du fichier Excel.
+     */
     public static function getExcelById(int $_id)
     {
         db::query("SELECT * FROM " . DB_T_EXCEL_PROWEB_DOSSIERS . " WHERE id = :id");
@@ -10,12 +20,23 @@ class prowebDossiers
         return db::single();
     }
 
+    /**
+     * Récupère tous les dossiers Proweb.
+     *
+     * @return array Liste des dossiers Proweb.
+     */
     public static function all()
     {
         db::query("SELECT * FROM " . DB_T_DOSSIERS_PROWEB);
         return db::resultset();
     }
 
+    /**
+     * Supprime un fichier Excel Proweb par son identifiant.
+     *
+     * @param int $_id Identifiant du fichier Excel.
+     * @return bool Succès ou échec de la suppression.
+     */
     public static function deleteExcel(int $_id)
     {
 
@@ -32,6 +53,12 @@ class prowebDossiers
         }
     }
 
+    /**
+     * Vérifie si les données d'un fichier Excel sont conformes aux attentes.
+     *
+     * @param array $_array Données du fichier Excel.
+     * @return bool TRUE si les données sont conformes, FALSE sinon.
+     */
     public static function checkExcel(array $_array)
     {
 
@@ -81,6 +108,12 @@ class prowebDossiers
     }
 
 
+    /**
+     * Ajoute des données provenant d'un fichier Excel dans la base de données.
+     *
+     * @param array $_array Données à ajouter.
+     * @return bool TRUE en cas de succès, FALSE en cas d'échec.
+     */
     public static function add(array $_array)
     {
         if (empty($_array)) {
@@ -184,12 +217,24 @@ class prowebDossiers
     }
 
 
+    /**
+     * Récupère les informations du dernier fichier Excel.
+     *
+     * @return array Informations du dernier fichier Excel.
+     */
     public static function getExcel()
     {
         db::query("SELECT * FROM " . DB_T_EXCEL . " ORDER BY id DESC LIMIT 0, 1");
         return db::single();
     }
 
+    /**
+     * Télécharge un fichier Excel Proweb par son identifiant.
+     *
+     * @param int $_id Identifiant du fichier Excel.
+     * @param string $_file Nom du fichier temporaire.
+     * @return string Chemin du fichier téléchargé.
+     */
     public static function downloadExcel(int $_id, string $_file)
     {
         $data = base64_decode(self::getExcelById($_id)["file"]);
@@ -199,6 +244,11 @@ class prowebDossiers
         return DIR_TEMP . $_file;
     }
 
+    /**
+     * Génère un lien vers les dossiers Proweb avec une date formatée.
+     *
+     * @return string Lien formaté vers les dossiers Proweb.
+     */
     public static function getLinkProweb() {
         $date = new DateTime();
         $date->modify('-12 months');

core/class/pwa.class.php

@@ -1,9 +1,21 @@
 <?php
-
+/**
+ * Classe pwa
+ * 
+ * Cette classe gère les fonctionnalités liées aux Progressive Web Apps (PWA), telles que le service worker et le manifeste.
+ */
 class pwa
 {
+    /**
+     * @var string Nom du fichier du service worker.
+     */
     private static $serviceWorker = "serviceWorker.js";
 
+    /**
+     * Récupère le fichier manifeste approprié en fonction du domaine.
+     *
+     * @return string Nom du fichier manifeste.
+     */
     private static function getManifeste()
     {
         if(!empty($_SERVER['HTTP_HOST'])){
@@ -23,6 +35,9 @@ class pwa
         }
     }
 
+    /**
+     * Affiche le script pour enregistrer ou désenregistrer le service worker.
+     */
     public static function printServiceWorker()
     {
         echo '<script>';
@@ -40,6 +55,9 @@ class pwa
         echo '</script>';
     }
 
+    /**
+     * Affiche le lien vers le fichier manifeste dans le HTML.
+     */
     public static function printManifeste()
     {
         if (PWA == 1) {

core/class/salaries.class.php

@@ -707,19 +707,29 @@ class salaries
         $tmpSFTP = fopen(SFTP_LOCAL . $csv, "w");
         fputcsv($tmpSFTP, array("loginId", "jourSortie"), ";");
 
-        foreach (json_decode($forSFTP["forSFTP"], TRUE) as $salarie) {
-
-            $tmpSalarie = NULL;
-// TODO Extract
-            if (isset($salarie["loginId"]) and $salarie["loginId"] != "" and isset($salarie["jourSortie"])) {
-                $tmpSalarie["loginId"] = $salarie["loginId"];
-                $tmpSalarie["jourSortie"] = $salarie["jourSortie"];
-                fputcsv($tmpSFTP, $tmpSalarie, ";");
+        $decodedData = json_decode($forSFTP["forSFTP"], TRUE);
+        if (is_array($decodedData)) {
+            foreach ($decodedData as $salarie) {
+                self::processSalarie($salarie, $tmpSFTP);
             }
+        } else {
+            throw new Exception("Données JSON invalides pour SFTP.");
         }
+
         self::recDateForSFTP($lastExcel);
     }
 
+    private static function processSalarie($salarie, $tmpSFTP)
+    {
+        if (isset($salarie["loginId"]) && $salarie["loginId"] != "" && isset($salarie["jourSortie"])) {
+            $tmpSalarie = [
+                "loginId" => $salarie["loginId"],
+                "jourSortie" => $salarie["jourSortie"]
+            ];
+            fputcsv($tmpSFTP, $tmpSalarie, ";");
+        }
+    }
+
     private static function recDateForSFTP(int $_idExcel)
     {
         db::query("UPDATE " . DB_T_EXCEL . " SET "

core/class/serverLog.class.php

@@ -1,7 +1,18 @@
 <?php 
 
+/**
+ * Classe serverLog
+ * 
+ * Cette classe gère les journaux du serveur, y compris l'affichage des logs,
+ * la détection des types de logs, et le filtrage des informations sensibles.
+ */
 class serverLog {
 
+    /**
+     * Affiche un log avec un style approprié en fonction de son contenu.
+     *
+     * @param string $_log Le message de log à afficher.
+     */
     public static function printLog(string $_log){
         if (serverLog::detectLogsAttempts($_log)) {
             self::printLogAttempts($_log);
@@ -20,12 +31,23 @@ class serverLog {
         }
     }
 
+    /**
+     * Filtre un log pour masquer les informations sensibles avant de l'afficher.
+     *
+     * @param string $_log Le message de log à filtrer.
+     */
     public static function filtreLog(string $_log){
         $log = self::hidePassword($_log);
         $log = self::hideEmail($log);
         self::printLog($log);
     }
 
+    /**
+     * Détecte si une chaîne correspond au format des tentatives de connexion.
+     *
+     * @param string $str La chaîne à analyser.
+     * @return bool Vrai si la chaîne correspond, faux sinon.
+     */
     private static function detectLogsAttempts(string $str): bool {
         return preg_match(
             '/^\d{1,3}(\.\d{1,3}){3},\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2},/',
@@ -33,6 +55,11 @@ class serverLog {
         ) === 1;
     }
 
+    /**
+     * Affiche un log formaté pour les tentatives de connexion.
+     *
+     * @param string $_log Le message de log à afficher.
+     */
     public static function printLogAttempts(string $_log){
         $parts = explode(',', $_log, 4);
         if (count($parts) === 4) {
@@ -46,6 +73,12 @@ class serverLog {
         }
     }
 
+    /**
+     * Détecte si une chaîne correspond au format des logs Apache.
+     *
+     * @param string $str La chaîne à analyser.
+     * @return bool Vrai si la chaîne correspond, faux sinon.
+     */
     private static function detectApacheLog(string $str): bool {
         return preg_match(
             '/^\[(?<date>[A-Za-z]{3} [A-Za-z]{3} \d{2} [\d:.]+ \d{4})\] \[(?<type>[^\]]+)\] \[pid (?<pid>\d+):tid (?<tid>\d+)\] \[client (?<client>[^\]]+)\] (?<msg>.*?)(?:, referer: (?<referer>.+))?$/',
@@ -53,6 +86,11 @@ class serverLog {
         ) === 1;
     }
 
+    /**
+     * Affiche un log Apache avec des couleurs pour chaque partie.
+     *
+     * @param string $line La ligne de log Apache à afficher.
+     */
     public static function printColoredApacheLog(string $line) {
         $regex = '/^\[(?<date>[A-Za-z]{3} [A-Za-z]{3} \d{2} [\d:.]+ \d{4})\] \[(?<type>[^\]]+)\] \[pid (?<pid>\d+):tid (?<tid>\d+)\] \[client (?<client>[^\]]+)\] (?<msg>.*?)(?:, referer: (?<referer>.+))?$/';
         if (preg_match($regex, $line, $matches)) {
@@ -71,26 +109,61 @@ class serverLog {
         }
     }
 
+    /**
+     * Vérifie si un log contient le chemin du dossier www.
+     *
+     * @param string $_log Le message de log à analyser.
+     * @return bool Vrai si le chemin est trouvé, faux sinon.
+     */
     private static function ifFolderWww(string $_log){
         return (stripos($_log, DOCUMENT_ROOT) !== false) ? TRUE : FALSE;
     }
 
+    /**
+     * Vérifie si un log contient le domaine CMS.
+     *
+     * @param string $_log Le message de log à analyser.
+     * @return bool Vrai si le domaine est trouvé, faux sinon.
+     */
     private static function ifFolderDomain(string $_log){
         return (stripos($_log, DOMAIN_CMS) !== false) ? TRUE : FALSE;
     }
 
+    /**
+     * Vérifie si un log est général (ni dossier www, ni domaine CMS).
+     *
+     * @param string $_log Le message de log à analyser.
+     * @return bool Vrai si le log est général, faux sinon.
+     */
     private static function ifGeneral(string $_log){
         return (stripos($_log, "/var/www/") == FALSE AND stripos($_log, "https://") == FALSE) ? TRUE : FALSE;
     }
 
+    /**
+     * Masque les mots de passe dans une chaîne de log.
+     *
+     * @param string $input La chaîne à traiter.
+     * @return string La chaîne avec les mots de passe masqués.
+     */
     private static function hidePassword($input) {
         return preg_replace("/('password'\s*=>\s*)'[^']*'/", "$1'##PASSWORD##'", $input);
     }
 
+    /**
+     * Masque les adresses e-mail dans une chaîne de log.
+     *
+     * @param string $input La chaîne à traiter.
+     * @return string La chaîne avec les adresses e-mail masquées.
+     */
     private static function hideEmail($input) {
         return preg_replace("/('email'\s*=>\s*)'[^']*'/", "$1'##EMAIL##'", $input);
     }
 
+    /**
+     * Affiche les logs d'un fichier dans la console, avec des options de recherche et de limite.
+     *
+     * @param string $_logFile Le chemin du fichier de log à lire.
+     */
     public static function consoleLog(string $_logFile){
         if (!is_readable($_logFile)) {
             echo "Le fichier n'est pas accessible en lecture.";

core/class/session.class.php

@@ -1,55 +1,126 @@
 <?php
-
+/**
+ * Classe session
+ * 
+ * Cette classe gère les sessions utilisateur, y compris la création, la récupération,
+ * la modification et la suppression des données de session.
+ */
 class session
 {
+    /**
+     * Crée une session avec les données fournies.
+     *
+     * @param array $_array Données de la session.
+     * @param string $_type Type de session (par défaut "user").
+     */
     public static function createSession(array $_array, string $_type = "user")
     {
         $_SESSION[$_type] = $_array;
     }
 
+    /**
+     * Récupère l'identifiant de la session.
+     *
+     * @param string $_type Type de session (par défaut "user").
+     * @return mixed Identifiant de la session.
+     */
     public static function getId(string $_type = "user")
     {
         return $_SESSION[$_type]["id"];
     }
 
+    /**
+     * Récupère une valeur spécifique de la session.
+     *
+     * @param string $_val Clé de la valeur à récupérer.
+     * @param string $_type Type de session (par défaut "user").
+     * @return mixed Valeur correspondante dans la session.
+     */
     public static function getValue(string $_val, string $_type = "user")
     {
         return $_SESSION[$_type][$_val];
     }
 
+    /**
+     * Définit une valeur spécifique dans la session.
+     *
+     * @param mixed $_vl Valeur à définir.
+     * @param string $_val Clé de la valeur à définir.
+     * @param string $_type Type de session (par défaut "user").
+     */
     public static function setValue($_vl, string $_val, string $_type = "user")
     {
         $_SESSION[$_type][$_val] = $_vl;
     }
 
+    /**
+     * Récupère le nom complet de l'utilisateur dans la session.
+     *
+     * @param string $_type Type de session (par défaut "user").
+     * @return string Nom complet de l'utilisateur.
+     */
     public static function getName(string $_type = "user")
     {
         return $_SESSION[$_type]["prenom"] . " " . $_SESSION[$_type]["nom"];
     }
 
+    /**
+     * Récupère le type d'utilisateur dans la session.
+     *
+     * @param string $_type Type de session (par défaut "user").
+     * @return mixed Type d'utilisateur.
+     */
     public static function getType(string $_type = "user")
     {
         return $_SESSION[$_type]["idType"];
     }
 
+    /**
+     * Vérifie si l'utilisateur est connecté.
+     *
+     * @param string $_type Type de session (par défaut "user").
+     * @return bool Vrai si l'utilisateur est connecté, faux sinon.
+     */
     public static function isConnect(string $_type = "user")
     {
         return (isset($_SESSION[$_type]["id"])) ? TRUE : FALSE;
     }
 
+    /**
+     * Vérifie si l'utilisateur a accès à un type spécifique.
+     *
+     * @param array $_type Types d'accès autorisés.
+     * @return bool Vrai si l'utilisateur a accès, faux sinon.
+     */
     public static function access(array $_type){
         return (in_array($_SESSION["user"]["idType"], $_type)) ? TRUE : FALSE;
     }
 
+    /**
+     * Vérifie si l'utilisateur est dans l'espace des contrôleurs.
+     *
+     * @return bool Vrai si l'utilisateur est dans l'espace des contrôleurs, faux sinon.
+     */
     public static function isEspaceControleurs(){
         return ($_SERVER['HTTP_HOST'] == DOMAIN_CONTROL) ? TRUE : FALSE;
     }
 
+    /**
+     * Vérifie si l'utilisateur est dans l'espace des salariés.
+     *
+     * @return bool Vrai si l'utilisateur est dans l'espace des salariés, faux sinon.
+     */
     public static function isEspaceSalaries(){
         return ($_SERVER['HTTP_HOST'] == DOMAIN_EVENTS) ? TRUE : FALSE;
     }
 
-    public static function setTemp(array $_array, string $_name = NULL){
+    /**
+     * Définit des données temporaires dans la session.
+     *
+     * @param array $_array Données temporaires à définir.
+     * @param string|null $_name Nom de la clé temporaire (par défaut "tmp").
+     */
+    public static function setTemp(array $_array, ?string $_name = NULL){
         if($_name == NULL){
             $_SESSION["TEMP"]["tmp"] = $_array;
         } else {
@@ -57,7 +128,13 @@ class session
         }
     }
 
-    public static function getTemp(string $_name = NULL){
+    /**
+     * Récupère des données temporaires de la session.
+     *
+     * @param string|null $_name Nom de la clé temporaire (par défaut "tmp").
+     * @return mixed Données temporaires récupérées.
+     */
+    public static function getTemp(?string $_name = NULL){
         if(empty($_SESSION["TEMP"])){ 
             return NULL; 
         } elseif($_name == NULL){
@@ -69,7 +146,12 @@ class session
         return $return;
     }
 
-    public static function resetTemp(string $_name = NULL){
+    /**
+     * Réinitialise les données temporaires dans la session.
+     *
+     * @param string|null $_name Nom de la clé temporaire à réinitialiser (par défaut toutes).
+     */
+    public static function resetTemp(?string $_name = NULL){
         unset($_SESSION["TEMP"]);
     }
 

core/class/sftp.class.php

@@ -1,12 +1,37 @@
 <?php
-
+/**
+ * Classe sftp
+ * 
+ * Cette classe gère les interactions avec un serveur SFTP, y compris la connexion,
+ * l'envoi, la suppression et la récupération de fichiers.
+ */
 class sftp
 {
-
+    /**
+     * @var mixed Ressource d'authentification ou identifiants pour la connexion SFTP.
+     */
     private static $authent;
+
+    /**
+     * @var mixed Ressource ou objet de connexion SFTP.
+     */
     private static $connexion;
+
+    /**
+     * @var mixed Données à envoyer via la connexion SFTP.
+     */
     private static $dataSend;
 
+    /**
+     * Établit une connexion à l'hôte SFTP via le protocole SSH2.
+     *
+     * Modifie temporairement le délai d'attente par défaut du socket selon le nombre de secondes spécifié,
+     * puis tente de se connecter. Restaure le délai d'attente initial après la tentative de connexion.
+     * Retourne TRUE si la connexion réussit, FALSE sinon.
+     *
+     * @param int $_sec Nombre de secondes à définir pour le délai d'attente du socket (par défaut : 2).
+     * @return bool TRUE si la connexion est réussie, FALSE en cas d'échec.
+     */
     private static function connectHost(int $_sec = 2)
     {
         $originalConnectionTimeout = ini_get('default_socket_timeout');
@@ -19,26 +44,54 @@ class sftp
         }
     }
 
+    /**
+     * Authentifie l'utilisateur auprès de l'hôte SFTP.
+     *
+     * @return bool Vrai si l'authentification est réussie, faux sinon.
+     */
     private static function authentHost()
     {
         return (@ssh2_auth_password(self::$authent, SFTP_USER, SFTP_PASS)) ? TRUE : FALSE;
     }
 
+    /**
+     * Initialise la connexion SFTP.
+     *
+     * @return bool Vrai si l'initialisation est réussie, faux sinon.
+     */
     private static function initializeHost()
     {
         return (self::$connexion = @ssh2_sftp(self::$authent)) ? TRUE : FALSE;
     }
 
-    private static function fileExist(string $_file = NULL)
+    /**
+     * Vérifie si un fichier existe localement.
+     *
+     * @param string $_file Chemin du fichier à vérifier.
+     * @return bool Vrai si le fichier existe, faux sinon.
+     */
+    private static function fileExist(?string $_file = NULL)
     {
         return (file_exists($_file)) ? TRUE : FALSE;
     }
 
-    private static function fileGetContents(string $_file = NULL)
+    /**
+     * Lit le contenu d'un fichier local.
+     *
+     * @param string $_file Chemin du fichier à lire.
+     * @return bool Vrai si le contenu est lu avec succès, faux sinon.
+     */
+    private static function fileGetContents(?string $_file = NULL)
     {
         return (self::$dataSend = @file_get_contents($_file)) ? TRUE : FALSE;
     }
 
+    /**
+     * Accède à l'hôte SFTP en établissant une connexion complète.
+     *
+     * @param bool $_showAlert Affiche des alertes en cas d'erreur (par défaut TRUE).
+     * @return bool Vrai si l'accès est réussi, faux sinon.
+     */
     private static function accessHost(bool $_showAlert = TRUE)
     {
         if (!self::connectHost()) {
@@ -57,11 +110,22 @@ class sftp
         return TRUE;
     }
 
+    /**
+     * Teste l'accès à l'hôte SFTP sans afficher d'alertes.
+     *
+     * @return bool Vrai si l'accès est réussi, faux sinon.
+     */
     public static function testAccessHost()
     {
         return (self::accessHost(FALSE)) ? TRUE : FALSE;
     }
 
+    /**
+     * Envoie un fichier au serveur distant.
+     *
+     * @param string $_file Nom du fichier à envoyer.
+     * @return bool Vrai si le fichier est envoyé avec succès, faux sinon.
+     */
     private static function sendFile(string $_file)
     {
         self::accessHost();
@@ -85,6 +149,12 @@ class sftp
         @fclose($stream);
     }
 
+    /**
+     * Supprime un fichier du serveur distant.
+     *
+     * @param string $_file Nom du fichier à supprimer.
+     * @return bool Vrai si le fichier est supprimé avec succès, faux sinon.
+     */
     public static function deleteFileToRemote(string $_file)
     {
 
@@ -100,7 +170,13 @@ class sftp
         }
     }
 
-    public static function sendFileToRemote(string $_file = NULL)
+    /**
+     * Envoie un fichier local au serveur distant.
+     *
+     * @param string|null $_file Nom du fichier à envoyer.
+     * @return bool Vrai si le fichier est envoyé avec succès, faux sinon.
+     */
+    public static function sendFileToRemote(?string $_file = NULL)
     {
         if ($_file == NULL) {
             alert::recError("Le fichier à envoyé n'a pas été défini");
@@ -113,6 +189,11 @@ class sftp
         }
     }
 
+    /**
+     * Scanne les fichiers présents dans le dossier distant.
+     *
+     * @return array Liste des fichiers dans le dossier distant.
+     */
     public static function scanFolderRemote()
     {
         self::accessHost(FALSE);
@@ -142,6 +223,11 @@ class sftp
         return $tempArray;
     }
 
+    /**
+     * Scanne les fichiers présents dans le dossier local.
+     *
+     * @return array Liste des fichiers dans le dossier local.
+     */
     public static function scanFolderLocal()
     {
         $tempArray = array();
@@ -159,6 +245,12 @@ class sftp
         return $tempArray;
     }
 
+    /**
+     * Supprime un fichier du serveur distant.
+     *
+     * @param string $_file Nom du fichier à supprimer.
+     * @return bool Vrai si le fichier est supprimé avec succès, faux sinon.
+     */
     public static function deleteFormRemote(string $_file)
     {
         self::accessHost(FALSE);
@@ -171,6 +263,11 @@ class sftp
         }
     }
 
+    /**
+     * Télécharge un fichier du serveur distant vers le serveur local.
+     *
+     * @param string $_file Nom du fichier à télécharger.
+     */
     public static function downloadFormRemote(string $_file)
     {
         self::accessHost(FALSE);

core/class/simpleCSV.class.php

@@ -1,25 +1,75 @@
 <?php
 
+/**
+ * Classe simpleCSV
+ * 
+ * Cette classe permet de manipuler des fichiers CSV, notamment pour les importer
+ * et les exporter sous forme de tableaux associatifs.
+ */
 class simpleCSV
 {
-
+    /**
+     * Délimiteur utilisé dans le fichier CSV.
+     * @var string
+     */
     private $_delimiter;
+
+    /**
+     * Caractère d'encadrement utilisé dans le fichier CSV.
+     * @var string
+     */
     private $_enclosure;
+
+    /**
+     * Caractère de saut de ligne utilisé dans le fichier CSV.
+     * @var string
+     */
     private $_linebreak;
+
+    /**
+     * Contenu du fichier CSV.
+     * @var string
+     */
     private $_csv = '';
 
+    /**
+     * Importe un fichier CSV ou une chaîne CSV en tableau associatif.
+     *
+     * @param string $filename_or_data Chemin du fichier ou contenu CSV.
+     * @param bool $is_data Indique si l'entrée est une chaîne CSV (true) ou un fichier (false).
+     * @param string $delimiter Délimiteur à utiliser (par défaut : auto).
+     * @param string $enclosure Caractère d'encadrement à utiliser (par défaut : auto).
+     * @param string $linebreak Caractère de saut de ligne à utiliser (par défaut : auto).
+     * @return array Tableau associatif représentant le contenu du CSV.
+     */
     public static function import($filename_or_data, $is_data = false, $delimiter = 'auto', $enclosure = 'auto', $linebreak = 'auto')
     {
         $csv = new static($delimiter, $enclosure, $linebreak);
         return $csv->toArray($filename_or_data, $is_data);
     }
 
+    /**
+     * Exporte un tableau associatif en chaîne CSV.
+     *
+     * @param array $items Tableau associatif à exporter.
+     * @param string $delimiter Délimiteur à utiliser (par défaut : ,).
+     * @param string $enclosure Caractère d'encadrement à utiliser (par défaut : ").
+     * @param string $linebreak Caractère de saut de ligne à utiliser (par défaut : \r\n).
+     * @return string Chaîne CSV générée.
+     */
     public static function export($items, $delimiter = ',', $enclosure = '"', $linebreak = "\r\n")
     {
         $csv = new static($delimiter, $enclosure, $linebreak);
         return $csv->fromArray($items);
     }
 
+    /**
+     * Constructeur de la classe simpleCSV.
+     *
+     * @param string $delimiter Délimiteur à utiliser (par défaut : auto).
+     * @param string $enclosure Caractère d'encadrement à utiliser (par défaut : auto).
+     * @param string $linebreak Caractère de saut de ligne à utiliser (par défaut : auto).
+     */
     public function __construct($delimiter = 'auto', $enclosure = 'auto', $linebreak = 'auto')
     {
         $this->_delimiter = $delimiter;
@@ -27,6 +77,12 @@ class simpleCSV
         $this->_linebreak = $linebreak;
     }
 
+    /**
+     * Définit ou détecte automatiquement le délimiteur utilisé dans le CSV.
+     *
+     * @param string|bool $set Délimiteur à définir ou false pour détecter automatiquement.
+     * @return string Délimiteur utilisé.
+     */
     public function delimiter($set = false)
     {
         if ($set !== false) {
@@ -53,6 +109,12 @@ class simpleCSV
         return $this->_delimiter;
     }
 
+    /**
+     * Définit ou détecte automatiquement le caractère d'encadrement utilisé dans le CSV.
+     *
+     * @param string|bool $set Caractère d'encadrement à définir ou false pour détecter automatiquement.
+     * @return string Caractère d'encadrement utilisé.
+     */
     public function enclosure($set = false)
     {
         if ($set !== false) {
@@ -71,6 +133,12 @@ class simpleCSV
         return $this->_enclosure;
     }
 
+    /**
+     * Définit ou détecte automatiquement le caractère de saut de ligne utilisé dans le CSV.
+     *
+     * @param string|bool $set Caractère de saut de ligne à définir ou false pour détecter automatiquement.
+     * @return string Caractère de saut de ligne utilisé.
+     */
     public function linebreak($set = false)
     {
         if ($set !== false) {
@@ -90,6 +158,13 @@ class simpleCSV
         return $this->_linebreak;
     }
 
+    /**
+     * Convertit un fichier ou une chaîne CSV en tableau associatif.
+     *
+     * @param string $filename Chemin du fichier ou contenu CSV.
+     * @param bool $is_csv_content Indique si l'entrée est une chaîne CSV (true) ou un fichier (false).
+     * @return array Tableau associatif représentant le contenu du CSV.
+     */
     public function toArray($filename, $is_csv_content = false)
     {
 
@@ -151,6 +226,12 @@ class simpleCSV
         return $r;
     }
 
+    /**
+     * Convertit un tableau associatif en chaîne CSV.
+     *
+     * @param array $items Tableau associatif à convertir.
+     * @return string Chaîne CSV générée.
+     */
     public function fromArray($items)
     {
         if (!is_array($items)) {

core/class/stats.class.php

@@ -1,7 +1,23 @@
 <?php
-
+/**
+ * Classe stats
+ *
+ * Cette classe fournit des méthodes pour calculer des statistiques générales
+ * sur les employés, y compris les répartitions par sexe, contrat, activité,
+ * et les entrées par année.
+ */
 class stats {
 
+    /**
+     * Calcule les statistiques générales des employés.
+     *
+     * Cette méthode récupère les statistiques par lieu, y compris les répartitions
+     * par sexe, contrat, activité, ainsi que les entrées par année. Elle calcule
+     * également les statistiques globales pour tous les lieux combinés.
+     *
+     * @param int $_actifOnly Indique si seules les données des employés actifs doivent être prises en compte (1 par défaut).
+     * @return array Retourne un tableau contenant les statistiques globales et par lieu.
+     */
     public static function countStatistiquesGenerale(int $_actifOnly = 1){
         $actif = ($_actifOnly == 1) ? " AND actif = 1" : "";
 

core/class/tags.class.php

@@ -1,8 +1,19 @@
 <?php
-
+/**
+ * Classe tags
+ *
+ * Cette classe gère les opérations liées aux tags, y compris leur récupération,
+ * création, mise à jour, suppression et association avec des documents ou utilisateurs.
+ */
 class tags
 {
 
+    /**
+     * Récupère tous les tags ou les tags d'un type spécifique.
+     *
+     * @param float|null $_idTag Identifiant du type de tag (optionnel).
+     * @return array Liste des tags.
+     */
     public static function getAll(?float $_idTag = NULL) {
         
         if($_idTag == NULL){
@@ -21,6 +32,12 @@ class tags
         return db::resultset();
     }
 
+    /**
+     * Récupère un tag spécifique par son identifiant.
+     *
+     * @param float $_idTag Identifiant du tag.
+     * @return array Informations sur le tag.
+     */
     public static function getTag(float $_idTag) {
         db::query("SELECT"
             . " *"
@@ -30,6 +47,12 @@ class tags
         return db::single();
     }
 
+    /**
+     * Compte le nombre de documents associés à un tag spécifique.
+     *
+     * @param float|null $_idTag Identifiant du tag.
+     * @return int Nombre de documents associés.
+     */
     public static function getAllAttachment(?float $_idTag = NULL) {
         
         db::query("SELECT"
@@ -40,6 +63,11 @@ class tags
         return db::single()["nbDocuments"];
     }
 
+    /**
+     * Supprime les tags inutilisés.
+     *
+     * @return bool TRUE si la suppression est réussie, FALSE sinon.
+     */
     public static function cleanTags(){
         db::query("DELETE FROM tags WHERE id_type = 2 AND NOT EXISTS (SELECT 1 FROM documents_tags WHERE documents_tags.id_tags = tags.id)");
         try {
@@ -50,6 +78,11 @@ class tags
         }
     }
 
+    /**
+     * Supprime les doublons de tags dans les documents.
+     *
+     * @return bool TRUE si la suppression est réussie, FALSE sinon.
+     */
     public static function cleanTagsDuplicate() {
         db::query("DELETE dt1"
             . " FROM documents_tags dt1"
@@ -65,6 +98,13 @@ class tags
         }      
     }
 
+    /**
+     * Insère un nouveau tag dans la base de données.
+     *
+     * @param string $_tag Libellé du tag.
+     * @param float $_idTag Identifiant du type de tag (par défaut : 2).
+     * @return bool TRUE si l'insertion est réussie, FALSE sinon.
+     */
     private static function insert(string $_tag, float $_idTag = 2) {
         db::query("INSERT INTO " . DB_T_TAGS . " (id_type, label) VALUES (:id_type, :label)");
         db::bind(':id_type', $_idTag);
@@ -78,6 +118,13 @@ class tags
         }
     }
 
+    /**
+     * Met à jour un tag existant.
+     *
+     * @param float $_id Identifiant du tag.
+     * @param string $_tag Nouveau libellé du tag.
+     * @return bool TRUE si la mise à jour est réussie, FALSE sinon.
+     */
     public static function maj(float $_id, string $_tag) {
         db::query("UPDATE " . DB_T_TAGS . " SET label = :label WHERE id = :id; ");
         db::bind(':label', $_tag);
@@ -91,6 +138,13 @@ class tags
         }
     }
 
+    /**
+     * Fusionne deux tags en un seul.
+     *
+     * @param float $_idMaster Identifiant du tag maître.
+     * @param float $_idSlave Identifiant du tag à fusionner.
+     * @return bool TRUE si la fusion est réussie, FALSE sinon.
+     */
     public static function merge(float $_idMaster, float $_idSlave) {
         db::query("UPDATE " . DB_T_DOCUMENT_TAGS . " SET id_tags = :idMaster WHERE id_tags = :idSlave; ");
         db::bind(':idMaster', $_idMaster);
@@ -104,6 +158,12 @@ class tags
         }
     }
 
+    /**
+     * Trouve et crée des tags à partir d'une chaîne de caractères.
+     *
+     * @param string $_tags Chaîne de caractères contenant les tags.
+     * @param float $_idTag Identifiant du type de tag (par défaut : 2).
+     */
     static public function findAndCreate(string $_tags, float $_idTag = 2){
         $find = [];
         $tmp = explode(",", $_tags);
@@ -120,6 +180,12 @@ class tags
         }
     }
 
+    /**
+     * Génère une liste de tags au format JSON pour jQuery.
+     *
+     * @param float|null $_idTag Identifiant du type de tag (optionnel).
+     * @return string Liste des tags au format JSON.
+     */
     public static function getJquery(?float $_idTag = NULL) {
         $tmp = "[";
         foreach (self::getAll($_idTag) as $tags) {
@@ -129,6 +195,13 @@ class tags
         return $tmp;
     }
 
+    /**
+     * Convertit une chaîne de tags en identifiants correspondants.
+     *
+     * @param string|null $_tags Chaîne de caractères contenant les tags.
+     * @param float|null $_idTag Identifiant du type de tag (optionnel).
+     * @return string|null Identifiants des tags sous forme de chaîne.
+     */
     public static function textToId(?string $_tags = NULL, ?float $_idTag = NULL) {
         $return = NULL;
         if($_tags != NULL) {
@@ -153,6 +226,12 @@ class tags
         return $return;
     }
 
+    /**
+     * Trouve les utilisateurs associés à des tags spécifiques.
+     *
+     * @param string|null $_tags Chaîne de caractères contenant les tags.
+     * @return array Liste des utilisateurs associés aux tags.
+     */
     public static function findUsersTags(?string $_tags = NULL){
 
         $tmp = explode(",", $_tags);
@@ -182,6 +261,13 @@ class tags
         return  db::resultset();
     }
 
+    /**
+     * Compare les tags d'un utilisateur avec ceux d'un document.
+     *
+     * @param string|null $_tag_user Tags de l'utilisateur.
+     * @param string|null $_tag_document Tags du document.
+     * @return bool TRUE si des tags correspondent, FALSE sinon.
+     */
     public static function compareUserDocument(?string $_tag_user = NULL, ?string $_tag_document = NULL){
         if($_tag_user == NULL OR $_tag_document == NULL){
             return FALSE;

core/class/user.class.php

@@ -3,7 +3,9 @@
 /**
  * Classe `user`
  *
- * Cette classe gère les utilisateurs et leurs actions.
+ * Cette classe gère les utilisateurs et leurs actions, telles que la récupération
+ * des informations utilisateur, la gestion des jetons JWT, l'authentification,
+ * la gestion des tags associés aux utilisateurs, et bien plus encore.
  */
 class user
 {
@@ -37,6 +39,11 @@ class user
         return $return;
     }
 
+    /**
+     * Récupère la liste des utilisateurs.
+     *
+     * @return array Liste des utilisateurs avec leurs informations et tags associés.
+     */
     public static function getUsers() {
         // Récupération des données de l'excel au format Json
         db::query("SELECT "
@@ -63,6 +70,12 @@ class user
         return $return;
     }
 
+    /**
+     * Récupère le nom complet d'un utilisateur par son identifiant.
+     *
+     * @param int $_id Identifiant de l'utilisateur.
+     * @return string Nom complet de l'utilisateur.
+     */
     public static function getNameById(int $_id) {
         db::query("SELECT "
                 . "CONCAT (" . DB_T_USER . ".prenom, ' ', " . DB_T_USER . ".nom) AS 'name' "
@@ -72,6 +85,12 @@ class user
         return db::single()["name"];
     }
 
+    /**
+     * Récupère le secret Google Authenticator d'un utilisateur.
+     *
+     * @param int $_id Identifiant de l'utilisateur.
+     * @return string Secret Google Authenticator.
+     */
     public static function getMyGoogleAuthenticator(int $_id){
         db::query("SELECT "
                 . "" . DB_T_USER . ".googleAuthenticatorSecret "
@@ -81,6 +100,12 @@ class user
         return db::single()["googleAuthenticatorSecret"];
     }
 
+    /**
+     * Vérifie si un utilisateur a activé Google Authenticator.
+     *
+     * @param string $_email Email de l'utilisateur.
+     * @return int 1 si activé, 0 sinon.
+     */
     public static function checkGoogleAuthenticator(string $_email){
         db::query("SELECT "
                 . "" . DB_T_USER . ".googleAuthenticator "
@@ -91,6 +116,13 @@ class user
         return (isset($return["googleAuthenticator"])) ? $return["googleAuthenticator"] : 0;
     }
 
+    /**
+     * Insère un jeton JWT pour un utilisateur.
+     *
+     * @param int $_id_user Identifiant de l'utilisateur.
+     * @param string $_jwt Jeton JWT à insérer.
+     * @return bool TRUE si l'insertion est réussie, FALSE sinon.
+     */
     private static function insertJWT($_id_user, $_jwt){
         self::deleteJWTbyUSer($_id_user);
 
@@ -106,6 +138,12 @@ class user
         }
     }
 
+    /**
+     * Supprime tous les jetons JWT d'un utilisateur.
+     *
+     * @param int $_id_user Identifiant de l'utilisateur.
+     * @return bool TRUE si la suppression est réussie, FALSE sinon.
+     */
     public static function deleteJWTbyUSer($_id_user){
         db::query("DELETE FROM " . DB_T_JWT . " WHERE id_user = :id_user");
         db::bind(':id_user', $_id_user);
@@ -117,6 +155,13 @@ class user
         }
     }
 
+    /**
+     * Met à jour un jeton JWT par son empreinte MD5.
+     *
+     * @param string $_md5 Empreinte MD5 du jeton existant.
+     * @param string $_jwt Nouveau jeton JWT.
+     * @return bool TRUE si la mise à jour est réussie, FALSE sinon.
+     */
     public static function updateJWTbyMd5($_md5, $_jwt){
         db::query("UPDATE " . DB_T_JWT . " SET jwt = :jwt, md5 = :newmd5 WHERE md5 = :md5");
         db::bind(':md5', $_md5);
@@ -130,6 +175,12 @@ class user
         }
     }
 
+    /**
+     * Récupère les informations d'un utilisateur à partir d'un jeton JWT.
+     *
+     * @param string $_jwt Jeton JWT.
+     * @return array|bool Informations de l'utilisateur ou FALSE si non trouvé.
+     */
     public static function getInfosByJWT($_jwt){
         db::query("SELECT id_user, creer FROM " . DB_T_JWT . " WHERE md5 = :md5");
         db::bind(':md5', md5($_jwt));
@@ -142,6 +193,12 @@ class user
         }
     }
 
+    /**
+     * Authentifie un utilisateur avec ses informations d'entrée.
+     *
+     * @param array $_input Données d'entrée pour l'authentification.
+     * @return array Résultat de l'authentification avec les informations utilisateur.
+     */
     public static function authenticator(array $_input)
     {
         db::query("SELECT id, email, password, prenom, nom, id_type, googleAuthenticator, googleAuthenticatorSecret, actif FROM " . DB_T_USER . " WHERE email = :email AND deleted = 0");
@@ -183,6 +240,12 @@ class user
         }
     }
 
+    /**
+     * Connecte un utilisateur en vérifiant ses informations d'entrée.
+     *
+     * @param array $_input Données d'entrée pour la connexion.
+     * @return bool TRUE si la connexion est réussie, FALSE sinon.
+     */
     public static function connect(array $_input) {
 
         $connect = jwt::authenticate($_input);
@@ -225,13 +288,23 @@ class user
             return FALSE;
         }
     }
-    
+
+    /**
+     * Met à jour la date de dernière connexion d'un utilisateur.
+     *
+     * @param int $_id Identifiant de l'utilisateur.
+     */
     private static function updateLastConnect(int $_id){
         db::query("UPDATE " . DB_T_USER . " SET `last_connect` = CURRENT_TIMESTAMP() WHERE id = :id");
         db::bind(':id', $_id);
         db::execute();
     }
-    
+
+    /**
+     * Ajoute un nouvel utilisateur dans la base de données.
+     *
+     * @param array $_input Données de l'utilisateur à ajouter.
+     */
     public static function add_user(array $_input){
         db::query("INSERT INTO " . DB_T_USER . " "
                 . "(email, password, googleAuthenticator, googleAuthenticatorSecret, prenom, nom, id_type, actif) "
@@ -257,12 +330,22 @@ class user
             exit();
         }
     }
-    
+
+    /**
+     * Récupère l'identifiant du dernier utilisateur ajouté.
+     *
+     * @return int Identifiant du dernier utilisateur.
+     */
     public static function lastUser(){
         db::query("SELECT MAX(id) AS id FROM ". DB_T_USER);
         return db::single()["id"];
     }
-    
+
+    /**
+     * Met à jour les informations d'un utilisateur existant.
+     *
+     * @param array $_input Données mises à jour de l'utilisateur.
+     */
     public static function maj_user(array $_input){
 
         if($_input["password"] != ""){
@@ -320,6 +403,12 @@ class user
         }
     }
 
+    /**
+     * Récupère les tags associés à un utilisateur.
+     *
+     * @param float $_idUser Identifiant de l'utilisateur.
+     * @return string|null Liste des tags sous forme de chaîne ou NULL si aucun tag.
+     */
     static public function getTags(float $_idUser){
         db::query("SELECT "
             . "" . DB_T_TAGS . ".label "
@@ -343,6 +432,12 @@ class user
         }
     }  
 
+    /**
+     * Récupère les identifiants des tags associés à un utilisateur.
+     *
+     * @param float $_idUser Identifiant de l'utilisateur.
+     * @return array|null Liste des identifiants des tags ou NULL si aucun tag.
+     */
     static public function getIdTags(float $_idUser){
         db::query("SELECT "
             . "" . DB_T_USER_TAGS . ".id_tags "
@@ -362,7 +457,14 @@ class user
         }
     }
 
-    private static function addTags(float $_idUser, string $_tags = NULL)
+    /**
+     * Ajoute des tags à un utilisateur.
+     *
+     * @param float $_idUser Identifiant de l'utilisateur.
+     * @param string|null $_tags Liste des tags sous forme de chaîne (séparés par des virgules).
+     * @return bool TRUE si les tags sont ajoutés avec succès, FALSE en cas d'échec.
+     */
+    private static function addTags(float $_idUser, ?string $_tags = NULL)
     {
         db::query("DELETE FROM " . DB_T_USER_TAGS . " WHERE id_user = :id_user");
         db::bind(':id_user', $_idUser);
@@ -389,6 +491,11 @@ class user
         }
     }
     
+    /**
+     * Marque un utilisateur comme supprimé.
+     *
+     * @param int $_id Identifiant de l'utilisateur.
+     */
     public static function deleteUser(int $_id){
         db::query("UPDATE " . DB_T_USER . " SET deleted = 1 WHERE id = :id");
         db::bind(':id', $_id);
@@ -401,6 +508,11 @@ class user
         }
     }
 
+    /**
+     * Restaure un utilisateur précédemment supprimé.
+     *
+     * @param int $_id Identifiant de l'utilisateur.
+     */
     public static function restoreUser(int $_id){
         db::query("UPDATE " . DB_T_USER . " SET deleted = 0 WHERE id = :id");
         db::bind(':id', $_id);
@@ -413,12 +525,20 @@ class user
         }
     }
 
+    /**
+     * Vérifie si l'utilisateur a activé la double authentification.
+     *
+     * @return bool TRUE si la double authentification est activée, FALSE sinon.
+     */
     static public function checkSecur(){
         db::query("SELECT googleAuthenticator FROM " . DB_T_USER . " WHERE id = :id");
         db::bind(':id', session::getId());
         return db::single()["googleAuthenticator"] == 1 ? TRUE : FALSE;
     }
 
+    /**
+     * Affiche un message de sécurité si la double authentification n'est pas activée.
+     */
     static public function printIsSecur(){
         if(ALERT_AUTHENTICATOR == TRUE){
             $_SESSION["CALLOUT"] ??= 0;

maj/sql/maj.sql

@@ -1,89 +0,0 @@
-DROP TABLE IF EXISTS `type_access`;
-DROP TABLE IF EXISTS `access_exception`;
-
-CREATE TABLE `access_exception` (
-  `id` int NOT NULL,
-  `id_access` int NOT NULL,
-  `exception` varchar(150) NOT NULL,
-  PRIMARY KEY (`id`),
-  KEY `id_access` (`id_access`)
-) ENGINE=InnoDB;
-
-CREATE TABLE `type_access` (
-  `id` varchar(7) NOT NULL,
-  `id_type` int NOT NULL,
-  `id_access` int NOT NULL,
-  `id_exception` int DEFAULT NULL,
-  PRIMARY KEY (`id`),
-  KEY `idx_access_type` (`id_access`),
-  KEY `idx_type_access` (`id_type`),
-  KEY `idx_exception` (`id_exception`)
-) ENGINE=InnoDB;
-
-ALTER TABLE `type_access`
-  ADD CONSTRAINT `fk_access_type` FOREIGN KEY (`id_access`) REFERENCES `access` (`id`),
-  ADD CONSTRAINT `fk_exception` FOREIGN KEY (`id_exception`) REFERENCES `access_exception` (`id`),
-  ADD CONSTRAINT `fk_type_access` FOREIGN KEY (`id_type`) REFERENCES `type_user` (`id`);
-
-ALTER TABLE `access_exception`
-  ADD CONSTRAINT `id_access` FOREIGN KEY (`id_access`) REFERENCES `access` (`id`);
-
-INSERT INTO `access_exception` (`id`, `id_access`, `exception`) VALUES
-(1, 16, 'salaire'),
-(2, 17, 'salaire');
-
-INSERT INTO `type_access` (`id`, `id_type`, `id_access`, `id_exception`) VALUES
-('3#10', 3, 10, NULL);
-
-INSERT INTO `type_access` (`id`, `id_type`, `id_access`, `id_exception`) VALUES
-('4#10', 4, 10, NULL),
-('4#11', 4, 11, NULL),
-('4#12', 4, 12, NULL),
-('4#13', 4, 13, NULL),
-('4#14', 4, 14, NULL),
-('4#15', 4, 15, NULL),
-('4#16', 4, 16, 1),
-('4#17', 4, 17, 2),
-('4#4', 4, 4, NULL),
-('4#5', 4, 5, NULL),
-('4#6', 4, 6, NULL),
-('4#7', 4, 7, NULL),
-('4#8', 4, 8, NULL),
-('4#9', 4, 9, NULL);
-
-INSERT INTO `type_access` (`id`, `id_type`, `id_access`, `id_exception`) VALUES
-('5#1', 5, 1, NULL),
-('5#10', 5, 10, NULL),
-('5#11', 5, 11, NULL),
-('5#12', 5, 12, NULL),
-('5#13', 5, 13, NULL),
-('5#14', 5, 14, NULL),
-('5#15', 5, 15, NULL),
-('5#16', 5, 16, NULL),
-('5#17', 5, 17, NULL),
-('5#2', 5, 2, NULL),
-('5#4', 5, 4, NULL),
-('5#5', 5, 5, NULL),
-('5#6', 5, 6, NULL),
-('5#7', 5, 7, NULL),
-('5#8', 5, 8, NULL),
-('5#9', 5, 9, NULL);
-
-INSERT INTO `type_access` (`id`, `id_type`, `id_access`, `id_exception`) VALUES
-('6#10', 6, 10, NULL),
-('6#11', 6, 11, NULL),
-('6#12', 6, 12, NULL),
-('6#14', 6, 14, NULL),
-('6#15', 6, 15, NULL),
-('6#16', 6, 16, 1),
-('6#17', 6, 17, 2),
-('6#4', 6, 4, NULL),
-('6#5', 6, 5, NULL),
-('6#7', 6, 7, NULL),
-('6#8', 6, 8, NULL);
-
-INSERT INTO `type_access` (`id`, `id_type`, `id_access`, `id_exception`) VALUES
-('7#1', 7, 1, NULL),
-('7#16', 7, 16, NULL),
-('7#17', 7, 17, NULL);
-