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

<?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');
        ini_set('default_socket_timeout', $_sec);
        if (self::$authent = @ssh2_connect(SFTP_HOST, 22)) {
            ini_set('default_socket_timeout', $originalConnectionTimeout);
            return TRUE;
        } else {
            return FALSE;
        }
    }

    /**
     * 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;
    }

    /**
     * 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;
    }

    /**
     * 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()) {
            ($_showAlert == TRUE) ? alert::recError("Erreur de connection au serveur distant") : NULL;
            return FALSE;
        }
        if (!self::authentHost()) {
            ($_showAlert == TRUE) ? alert::recError("Erreur d'authentification au serveur distant") : NULL;
            return FALSE;
        }
        if (!self::initializeHost()) {
            ($_showAlert == TRUE) ? alert::recError("Erreur d'initialisation au serveur distant") : NULL;
            return FALSE;
        }
        ($_showAlert == TRUE) ? alert::recSuccess("Accès au serveur distant") : NULL;
        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();
        $stream = @fopen("ssh2.sftp://" . self::$authent . SFTP_REMOTE . $_file, "w");
        if ($stream == FALSE){
            alert::recError("Impossible d'écrire sur le serveur distant");
            return FALSE;
        }
        $data = @file_get_contents(SFTP_LOCAL . $_file);
        if ($data == FALSE){
            alert::recError("Impossible d'extraire les données du fichier local");
            return FALSE;
        }
        if (@fwrite($stream, $data) === false) {
            alert::recError($_file . " n'a pas pu être transféré au serveur distant");
            return FALSE;
        } else {
            alert::recSuccess($_file . " a été trasféré avec succès");
            return TRUE;
        }
        @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)
    {

        db::query("UPDATE " . DB_T_EXCEL . " SET createForSFTP = NULL WHERE id = :id");
        db::bind(':id', salaries::lastExcel());
        try {
            db::execute();
            alert::recSuccess($_file . " a été supprimé du serveur local.");
            return TRUE;
        } catch (Exception $e) {
            alert::recError($_file . " n'a pas pu être supprimé");
            return FALSE;
        }
    }

    /**
     * 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");
            return FALSE;
        } elseif (!self::fileExist(SFTP_LOCAL . $_file)) {
            alert::recError($_file . " n'est pas présent sur le serveur");
            return FALSE;
        } else {
            return self::sendFile($_file);
        }
    }

    /**
     * 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);
        $realpath = @ssh2_sftp_realpath(self::$connexion, SFTP_REMOTE);
        $dir = "ssh2.sftp://" . self::$connexion . $realpath;
        $tempArray = array();

        if (is_dir($dir)) {
            if ($dh = opendir($dir)) {
                while (($file = readdir($dh)) !== false) {
                    $tempFile = NULL;
                    $realpath = @ssh2_sftp_realpath(self::$connexion, $file);
                    $filetype = filetype($dir . $realpath);
                    $size = sprintf("%.2f", filesize($dir . $realpath));

                    if ($filetype != "dir") {
                        $infos = @ssh2_sftp_stat(self::$connexion, SFTP_REMOTE.$file);
                        $tempFile["file"] = $file;
                        $tempFile["size"] = core::formatFileSize($infos["size"], 2);
                        $tempFile["date"] = core::dateFromTimestamp($infos["atime"]);
                        $tempArray[] = $tempFile;
                    }
                }
                closedir($dh);
            }
        }
        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();
        if ($scandir = scandir(SFTP_LOCAL)) {
            foreach ($scandir as $file) {
                $tempFile = NULL;
                if (is_file(SFTP_LOCAL . $file) === TRUE and $file != "index.html") {
                    $tempFile["file"] = $file;
                    $tempFile["size"] = core::formatFileSize(filesize(SFTP_LOCAL . $file), 2);
                    $tempFile["date"] = core::dateFromTimestamp(filemtime(SFTP_LOCAL . $file));
                    $tempArray[] = $tempFile;
                }
            }
        }
        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);
        if (@ssh2_sftp_unlink(self::$connexion, SFTP_REMOTE . $_file)) {
            alert::recSuccess($_file . " a été supprimé du serveur distant.");
            return TRUE;
        } else {
            alert::recError($_file . " n'a pas été supprimé du serveur distant");
            return FALSE;
        }
    }

    /**
     * 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);
        //ssh2_scp_recv(self::$authent, SFTP_REMOTE.$_file, SFTP_LOCAL.$_file);

        $stream = @fopen("ssh2.sftp://" . self::$authent . SFTP_REMOTE . $_file, 'r');
        $contents = stream_get_contents($stream);
        file_put_contents(DIR_TEMP . $_file, $contents);
        @fclose($stream);
    }
}