CMS-CSE/core/class/file.class.php

<?php
/**
 * Classe file
 * 
 * Cette classe gère les opérations liées aux fichiers, y compris l'enregistrement,
 * la suppression, le téléchargement, et la gestion des répertoires.
 */
class file
{
    /**
     * Enregistre un fichier temporaire dans un répertoire spécifié.
     *
     * @param array $_temp Tableau contenant les informations du fichier temporaire.
     * @param string $_folderFiles Chemin du répertoire où enregistrer le fichier (par défaut DIR_DATAS_FILES).
     * @return string|false Retourne le hash MD5 du fichier enregistré ou FALSE en cas d'échec.
     */
    public static function record(array $_temp, string $_folderFiles = DIR_DATAS_FILES)
    {
        $md5 = md5_file($_temp["tmp_name"]);

        if(self::findM5($md5) == FALSE){
            if (copy($_temp["tmp_name"], $_folderFiles . $md5)) {
                db::query("INSERT INTO " . DB_T_FILES . " (id, name, size, id_user) VALUES (:id, :name, :size, :id_user)");
                db::bind(':id', $md5);
                db::bind(':name', $_temp['name']);
                db::bind(':size', $_temp['size']);
                db::bind(':id_user', session::getId());
    
                try {
                    db::execute();
                    return $md5;
                } catch (Exception $ex) {
                    unlink($_folderFiles . $md5);
                    alert::recError("Erreur #record sur l'import du fichier " . $_temp['name']);
                    return FALSE;
                }
            }
        } else {
            alert::recError("Erreur #record ce fichier a déjà été importé : " . $_temp['name']);
            return FALSE;
        }
    }

    /**
     * Vérifie les erreurs lors du téléchargement d'un fichier.
     *
     * @param array $_file Tableau contenant les informations du fichier téléchargé.
     * @return array Retourne un tableau avec le statut et la description de l'erreur (le cas échéant).
     */
    public static function getErrorUpload(array $_file){
        $return = [];
        if ($_file['error'] === UPLOAD_ERR_INI_SIZE) {
            $return = [
                        "status" => "error",
                        "description" => "Le fichier téléchargé dépasse la taille maximale autorisée fixé à " . ini_get('upload_max_filesize')
                    ];
        } elseif ($_file['error'] !== UPLOAD_ERR_OK) {
            $phpFileUploadErrors = array(
                1 => 'Le fichier téléchargé dépasse la directive upload_max_filesize dans php.ini',
                2 => 'Le fichier téléchargé dépasse la directive MAX_FILE_SIZE spécifiée dans le formulaire HTML',
                3 => 'Le fichier n\'a été que partiellement téléchargé',
                4 => 'Aucun fichier n\'a été téléchargé',
                6 => 'Il manque un dossier temporaire',
                7 => 'Échec de l\'écriture du fichier sur le disque',
                8 => 'Une extension PHP a arrêté le téléchargement du fichier',
            );
            $return = [
                "status" => "error",
                "description" => $phpFileUploadErrors[$_file['error']]
            ];
        } else {
            $return = [
                "status" => "success"
            ];
        }
        return $return;
    }

    /**
     * Vérifie si un fichier existe dans la base de données à partir de son hash MD5.
     *
     * @param string $_md5 Hash MD5 du fichier.
     * @return bool Retourne TRUE si le fichier existe, FALSE sinon.
     */
    public static function findM5(string $_md5){
        db::query("SELECT "
            . "IF(" . DB_T_FILES . ".name IS NOT NULL, TRUE, FALSE) AS exist "
            . "FROM " . DB_T_FILES . " "
            . "WHERE " . DB_T_FILES . ".id = :md5");
        db::bind(':md5', $_md5);
        $return = db::single();
        return ($return == TRUE) ? TRUE : FALSE;
    }

    /**
     * Supprime un fichier du système de fichiers et de la base de données.
     *
     * @param string|null $_id Identifiant du fichier à supprimer.
     * @param string $_folderFiles Chemin du répertoire contenant le fichier (par défaut DIR_DATAS_FILES).
     * @return bool Retourne TRUE en cas de succès, FALSE en cas d'échec.
     */
    public static function delete(string $_id = NULL, string $_folderFiles = DIR_DATAS_FILES){
        if (isset($_id) and $_id != NULL and file_exists($_folderFiles . $_id)) {
            if (unlink($_folderFiles . $_id)) {
                db::query("DELETE FROM " . DB_T_FILES . " WHERE id = :id");
                db::bind(':id', $_id);

                try {
                    db::execute();
                    return TRUE;
                } catch (Exception $ex) {
                    alert::recError("Erreur lors de la désindexation du fichier");
                    return FALSE;
                }
            } else {
                alert::recError("Erreur sur la suppression du fichier");
                return FALSE;
            }
        } else {
            return FALSE;
        }
    }

    /**
     * Télécharge un fichier à partir de son identifiant.
     *
     * @param string $_id Identifiant du fichier à télécharger.
     * @param string $_folderFiles Chemin du répertoire contenant le fichier (par défaut DIR_DATAS_FILES).
     * @return string|false Retourne le chemin du fichier ou FALSE si le fichier n'existe pas.
     */
    public static function download(string $_id, string $_folderFiles = DIR_DATAS_FILES){
        if (file_exists($_folderFiles . $_id)) {
            return $_folderFiles . $_id;
        } else {
            return FALSE;
        }
    }

    /**
     * Nettoie un répertoire en supprimant les fichiers au-delà d'un certain nombre.
     *
     * @param string $_path Chemin du répertoire à nettoyer.
     * @param int $_nbFiles Nombre maximum de fichiers à conserver (par défaut 5).
     * @return bool Retourne TRUE en cas de succès, FALSE en cas d'échec.
     */
    public static function cleanFilesByOrder(string $_path, int $_nbFiles = 5){
        $return = TRUE;
        $cpt = 0;
        $files = array();
        $dir = new DirectoryIterator($_path);
        $blackList = array(
            ".",
            "..",
            "index.html",
            "index.php"
        );

        foreach ($dir as $fileinfo) {
            $files[$fileinfo->getMTime()] = $fileinfo->getFilename();
        }

        krsort($files);

        foreach ($files as $file) {
            if (!in_array($file, $blackList)) {
                if ($cpt++ >= $_nbFiles) {
                    $return = (unlink($_path . $file)) ? TRUE : FALSE;
                }
            }
        }

        return $return;
    }

    /**
     * Supprime tous les fichiers d'un répertoire.
     *
     * @param string $_path Chemin du répertoire à nettoyer.
     * @return bool Retourne TRUE en cas de succès, FALSE en cas d'échec.
     */
    public static function cleanAllFiles(string $_path){
        $return = TRUE;
        $dir = new DirectoryIterator($_path);
        $blackList = array(
            ".",
            "..",
            "index.html",
            "index.php"
        );

        foreach ($dir as $fileinfo) {
            if (!in_array($fileinfo->getFilename(), $blackList)) {
                $return = (unlink($_path . $fileinfo->getFilename())) ? TRUE : FALSE;
            }
        }
        return $return;
    }

    /**
     * Supprime les fichiers d'un répertoire en fonction de leur ancienneté.
     *
     * @param string $_path Chemin du répertoire à nettoyer.
     * @param int $_limitTime Temps limite en secondes (par défaut 24 heures).
     * @return void
     */
    public static function cleanFilesByTime(string $_path, int $_limitTime = 24 * 3600){
        if ($handle = opendir($_path)) {
            while (false !== ($file = readdir($handle))) {
                $filelastmodified = filemtime($_path . $file);
                if ((time() - $filelastmodified) > $_limitTime) {
                    unlink($_path . $file);
                }
            }
            closedir($handle);
        }
    }

    /**
     * Copie un répertoire et son contenu vers un autre emplacement.
     *
     * @param string $_folder Chemin du répertoire source.
     * @param string $_target Chemin du répertoire cible.
     * @return void
     */
    public static function copyFolder(string $_folder, string $_target){
        if ($dir = opendir($_folder)) {
            mkdir($_target);
            while (($file = readdir($dir))) {
                if (($file != '.') && ($file != '..')) {
                    if (is_dir($_folder . '/' . $file)) {
                        self::copyFolder($_folder . '/' . $file, $_target . '/' . $file);
                    } else {
                        copy($_folder . '/' . $file, $_target . '/' . $file);
                    }
                }
            }
            closedir($dir);
        }
    }

    /**
     * Supprime un répertoire et son contenu.
     *
     * @param string $_dir Chemin du répertoire à supprimer.
     * @return bool Retourne TRUE en cas de succès, FALSE en cas d'échec.
     */
    public static function deleteFolder(string $_dir){
        if (is_dir($_dir)) {
            $command = "rm -r " . $_dir;
            try {
                system($command);
                return TRUE;
            } catch (Exception $ex) {
                return FALSE;
            }
        }
    }


    /**
     * Crée une archive ZIP à partir d'un répertoire.
     *
     * @param string $_dir Chemin du répertoire à compresser.
     * @param string $_name Nom de l'archive ZIP.
     * @return string Retourne le nom de l'archive ZIP créée.
     */
    public static function zip(string $_dir, string $_name){
        $zip = new ZipArchive();
        $zip_name = $_name . ".zip";
        $zip->open($zip_name, ZipArchive::CREATE);
        $files = new RecursiveIteratorIterator(new RecursiveDirectoryIterator($_dir), RecursiveIteratorIterator::LEAVES_ONLY);
        foreach ($files as $file) {
            if (!$file->isDir()) {
                $filePath = $file->getRealPath();
                $relativePath = substr($filePath, strlen($_dir));
                $zip->addFile($filePath, $relativePath);
            }
        }
        $zip->close();
        return $zip_name;
    }

    /**
     * Décompresse une archive ZIP dans un répertoire cible.
     *
     * @param string $_zip Chemin de l'archive ZIP.
     * @param string $_target Chemin du répertoire cible.
     * @return string|false Retourne le nom du répertoire décompressé ou FALSE en cas d'échec.
     */
    public static function unzip(string $_zip, string $_target){
        if (is_file($_zip)) {
            $zipInfo = pathinfo($_zip);
            if ($zipInfo["extension"] == "zip") {
                $command = "unzip -q " . $_zip . " -d " . $_target . $zipInfo["filename"];
                try {
                    system($command);
                    return $zipInfo["filename"];
                } catch (Exception $ex) {
                    return FALSE;
                }
            }
        }
        return FALSE;
    }

    /**
     * Calcule la taille totale d'un répertoire.
     *
     * @param string $_rep Chemin du répertoire.
     * @return int Retourne la taille totale du répertoire en octets.
     */
    public static function sizeFolder(string $_rep){
        $Racine = opendir($_rep);
        $Taille = 0;
        while ($Dossier = readdir($Racine)) {
            if ($Dossier != '..' and $Dossier != '.') {
                //Ajoute la taille du sous dossier
                if (is_dir($_rep . '/' . $Dossier)) $Taille += self::sizeFolder($_rep . '/' .
                    $Dossier);
                //Ajoute la taille du fichier
                else $Taille += filesize($_rep . '/' . $Dossier);
            }
        }
        closedir($Racine);
        return $Taille;
    }
}