Controller.class.php

Aller à la documentation de ce fichier.

<?php
 
namespace ComusParty\Controllers;
 
use ComusParty\App\Db;
use ComusParty\App\Exceptions\AuthenticationException;
use ComusParty\App\Exceptions\MethodNotFoundException;
use ComusParty\App\MessageHandler;
use Error;
use Exception;
use PDO;
use Twig\Environment;
use Twig\Error\LoaderError;
use Twig\Error\RuntimeError;
use Twig\Error\SyntaxError;
use Twig\Loader\FilesystemLoader;

class Controller
{
    private PDO $pdo;

    private FilesystemLoader $loader;

 
    private Environment $twig;
    private ?array $get = null;

    private ?array $post = null;

    public function __construct(FilesystemLoader $loader, Environment $twig)
    {
        $this->pdo = Db::getInstance()->getConnection();
        $this->loader = $loader;
        $this->twig = $twig;
 
        if (BACKUP_ENABLE && BACKUP_MODE === 'manual') {
            $this->makeDatabaseBackup();
        }
 
        if (!empty($_GET)) {
            $this->get = $_GET;
        }
 
        if (!empty($_POST)) {
            $this->post = $_POST;
        }
    }

    private function makeDatabaseBackup(): void
    {
        $minutesBetweenBackups = BACKUP_INTERVAL;
        $isBackupNeeded = false;
 
        if (file_exists(__DIR__ . '/../../backup')) {
            $files = glob(__DIR__ . '/../../backup/db-backup_*.sql');
            usort($files, function ($a, $b) {
                return filemtime($a) < filemtime($b);
            });
 
            if (count($files) > 0) {
                $lastBackup = $files[0];
                $lastBackupTime = filemtime($lastBackup);
                $currentTime = time();
                $diff = $currentTime - $lastBackupTime;
                $minutes = $diff / 60;
 
                if ($minutes >= $minutesBetweenBackups) {
                    $isBackupNeeded = true;
                }
 
                # Suppression des anciennes sauvegardes
                if (count($files) > BACKUP_RETENTION) {
                    for ($i = BACKUP_RETENTION; $i < count($files); $i++) {
                        unlink($files[$i]);
                    }
                }
            } else {
                $isBackupNeeded = true;
            }
        } else {
            $isBackupNeeded = true;
        }
 
        if (!$isBackupNeeded) {
            return;
        }
 
        try {
            $date = date('Y-m-d_H-i-s');
            $backupFile = 'db-backup_' . $date . '.sql';
 
            $stmt = $this->getPdo()->prepare('SHOW TABLES');
            $stmt->execute();
            $tables = $stmt->fetchAll(PDO::FETCH_COLUMN);
 
 
            $sql = 'CREATE DATABASE IF NOT EXISTS `' . DB_NAME . '`' . ";\n\n"; // Création de la base de données
            $sql .= 'USE `' . DB_NAME . "`;\n\n"; // Utilisation de la base de données pour la suite des opérations
            $sql .= "SET foreign_key_checks = 0;\n\n"; // Désactivation des contraintes de clés étrangères
 
            foreach ($tables as $table) {
                $sql .= 'DROP TABLE IF EXISTS `' . $table . '`;';
 
                $stmt = $this->getPdo()->prepare('SHOW CREATE TABLE `' . $table . '`');
                $stmt->execute();
                $sql .= "\n\n" . $stmt->fetchColumn(1) . ";\n\n";
 
                $stmt = $this->getPdo()->prepare('SELECT COUNT(*) FROM `' . $table . '`');
                $stmt->execute();
                $count = $stmt->fetchColumn();
                $numBatches = intval($count / BACKUP_FETCH_LIMIT) + 1;
 
                for ($b = 1; $b <= $numBatches; $b++) {
                    $request = 'SELECT * FROM `' . $table . '` LIMIT ' . ($b * BACKUP_FETCH_LIMIT - BACKUP_FETCH_LIMIT) . ',' . BACKUP_FETCH_LIMIT;
                    $stmt = $this->getPdo()->prepare($request);
                    $stmt->execute();
 
                    $realBatchSize = $stmt->rowCount();
                    $numFields = $stmt->columnCount();
 
                    if ($realBatchSize !== 0) {
                        $sql .= 'INSERT INTO `' . $table . '` VALUES ';
 
                        for ($i = 0; $i < $numFields; $i++) {
                            $rowCount = 1;
                            while ($row = $stmt->fetch(PDO::FETCH_NUM)) {
                                $sql .= '(';
                                for ($j = 0; $j < $numFields; $j++) {
                                    if (isset($row[$j])) {
                                        $row[$j] = addslashes($row[$j]);
                                        $row[$j] = str_replace("\n", "\\n", $row[$j]);
                                        $row[$j] = str_replace("\r", "\\r", $row[$j]);
                                        $row[$j] = str_replace("\f", "\\f", $row[$j]);
                                        $row[$j] = str_replace("\t", "\\t", $row[$j]);
                                        $row[$j] = str_replace("\v", "\\v", $row[$j]);
                                        $row[$j] = str_replace("\a", "\\a", $row[$j]);
                                        $row[$j] = str_replace("\b", "\\b", $row[$j]);
                                        if ($row[$j] == 'true' or $row[$j] == 'false' or preg_match('/^-?[1-9][0-9]*$/', $row[$j]) or $row[$j] == 'NULL' or $row[$j] == 'null') {
                                            $sql .= $row[$j];
                                        } else {
                                            $sql .= '\'' . $row[$j] . '\'';
                                        }
                                    } else {
                                        $sql .= 'NULL';
                                    }
 
                                    if ($j < ($numFields - 1)) {
                                        $sql .= ',';
                                    }
                                }
 
                                if ($rowCount == $realBatchSize) {
                                    $rowCount = 0;
                                    $sql .= ");\n"; // Fermeture de l'instruction d'insertion
                                } else {
                                    $sql .= "),\n"; // Fermeture de la ligne d'insertion
                                }
 
                                $rowCount++;
                            }
                        }
                    }
                }
            }
 
            $sql .= "SET foreign_key_checks = 1;\n";
 
            if (!is_dir(__DIR__ . '/../../backup')) {
                mkdir(__DIR__ . '/../../backup');
            }
 
            file_put_contents(__DIR__ . '/../../backup/' . $backupFile, $sql);
        } catch (Exception $e) {
            if (!is_dir(__DIR__ . '/../../backup')) {
                mkdir(__DIR__ . '/../../backup');
            }
 
            file_put_contents(__DIR__ . '/../../backup/error.txt', $e->getMessage());
        }
    }

    public function getPdo(): PDO
    {
        return $this->pdo;
    }

    public function setPdo(PDO $pdo): void
    {
        $this->pdo = $pdo;
    }

    public function call(string $method, ?array $args = []): mixed
    {
        if (!method_exists($this, $method) || !is_callable([$this, $method])) {
            throw new MethodNotFoundException('La méthode ' . $method . ' n\'existe pas dans le contrôleur ' . get_class($this));
        }
 
        try {
            return $this->{$method}(...array_values($args));
        } catch (Exception $e) {
            switch ($e::class) {
                case AuthenticationException::class:
                    MessageHandler::addExceptionParametersToSession($e);
                    header('Location: /login');
                    break;
                default:
                    MessageHandler::displayFullScreenException($e);
                    break;
            }
        } catch (Error $e) {
            MessageHandler::displayFullScreenError($e);
        }
 
        return null;
    }

    public function getLoader(): FilesystemLoader
    {
        return $this->loader;
    }

    public function setLoader(FilesystemLoader $loader): void
    {
        $this->loader = $loader;
    }

    public function getTwig(): Environment
    {
        return $this->twig;
    }

    public function setTwig(Environment $twig): void
    {
        $this->twig = $twig;
    }

    public function getGet(): ?array
    {
        return $this->get;
    }

    public function setGet(?array $get): void
    {
        $this->get = $get;
    }

    public function getPost(): ?array
    {
        return $this->post;
    }

    public function setPost(?array $post): void
    {
        $this->post = $post;
    }
}