on garde le premier before-restore du jour, cleanBackups avec tri et priorités, oubli dans mysqldump.php

4 files changed, 73 insertions, 12 deletions

diff --git a/bin/mysqldump.php b/bin/mysqldump.php
index 4356a81..b7ae3ef 100644
--- a/bin/mysqldump.php
+++ b/bin/mysqldump.php
@@ -9,5 +9,5 @@ require "../vendor/autoload.php";
 Config::load('../config/config.ini');
 require '../src/model/doctrine-bootstrap.php';
 
-$file_name = Backup::mySQLdump($entityManager); // créer un nouveau backup
+$file_name = Backup::mySQLdump($entityManager, 'console'); // créer un nouveau backup
 echo realpath($file_name) . "\n";
\ No newline at end of file
diff --git a/public/js/maintenance.js b/public/js/maintenance.js
index 87f4aec..3d3d5e8 100644
--- a/public/js/maintenance.js
+++ b/public/js/maintenance.js
@@ -1,3 +1,5 @@
+// js/maintenance.js
+
 function displayLogs(){
         const log_table = getElementOrThrow('log_table');
         
@@ -41,4 +43,4 @@ function cleanLogs(){
 }
 
 // notification après restauration
-
+// et éventuellement récupérer le message de l'exception d'une autre manière
diff --git a/src/controller/MaintenanceController.php b/src/controller/MaintenanceController.php
index c62b21b..83304de 100644
--- a/src/controller/MaintenanceController.php
+++ b/src/controller/MaintenanceController.php
@@ -81,7 +81,7 @@ class MaintenanceController
         static public function downloadSQL(EntityManager $entityManager, UploadedFile $uploaded_file): void
         {
         if(pathinfo($uploaded_file->getClientOriginalName())['extension'] !== 'sql'){
-                throw new Exception("charger un fichier au format SQL");
+                throw new Exception("Charger un fichier au format SQL");
         }
         //echo $uploaded_file->getSize(); // à garder de côté au cas où
 
@@ -89,7 +89,7 @@ class MaintenanceController
 
         try{
                 // enregistrer le fichier
-                var_dump($uploaded_file->move(Backup::$backup_dir, $server_place));
+                $uploaded_file->move(Backup::$backup_dir, $server_place);
 
                 // s'en servir
                 Backup::restoreDatabase($entityManager, $server_place);
diff --git a/src/service/Backup.php b/src/service/Backup.php
index 63368b5..1b44351 100644
--- a/src/service/Backup.php
+++ b/src/service/Backup.php
@@ -9,7 +9,7 @@ use Symfony\Component\Process\Process; // protection injection dans le shell
 class Backup
 {
         static public string $backup_dir = '../var/backups';
-        static private int $amount_to_keep = 30;
+        static private int $amount_to_keep = 20;
 
         static public function mySQLdump(EntityManager $entityManager, string $type): string
         {
@@ -81,19 +81,78 @@ class Backup
                 return $backup_list[count($backup_list) - 1];
         }
 
-        static public function cleanBackups(): void {
+        static public function cleanBackups(): void
+        {
                 $files = glob(self::$backup_dir . '/*.sql');
-                usort($files, fn($a, $b) => filemtime($b) <=> filemtime($a)); // filemtime = date de dernière modification
-                $files_to_delete = array_slice($files, self::$amount_to_keep);
-                foreach($files_to_delete as $file){
-                    unlink($file);
+                //usort($files, fn($a, $b) => filemtime($b) <=> filemtime($a)); // filemtime = date de dernière modification
+                arsort($files);
+
+                // tri par nom de BDD puis par date
+                $sorted_files = [];
+                $list_by_database = []; // pour le nettoyage 2
+                foreach($files as $file){
+                        $exploded = explode('_', basename($file));
+                        $sorted_files[$exploded[0]][$exploded[1]][] = $file;
+                        $list_by_database[$exploded[0]][] = $file;
+                }
+
+                $today = new DateTime()->format('Y-m-d');
+                foreach($sorted_files as $db_name => $from_one_database){
+                        // on garde une "quantité à garder" par BDD
+                        if(count($from_one_database) > self::$amount_to_keep){
+                                // nettoyage 1
+                                foreach($from_one_database as $date => $with_same_date){
+                                        // pas touche à aujourd'hui
+                                        if($date != $today){
+                                                self::cleanBackupsByPriority($with_same_date);
+                                        }
+                                }
+                                // nettoyage 2
+                                $files_to_delete = array_slice($list_by_database[$db_name], self::$amount_to_keep);
+                                foreach($files_to_delete as $file){
+                                    unlink($file);
+                                }
+                        }
+                }
+        }
+
+        // conserver un seul backup par jour choisi dans cet ordre de préférence: console => before-restore => download => auto
+        // cet ordre correspond à: volonté de l'utilisateur => état du jour avant changement => volonté de changement => automatique sans contrôle
+        static private function cleanBackupsByPriority(array $files): void
+        {
+                $priorities = [
+                        'console' => 1,
+                        'before-restore' => 2,
+                        'uploaded' => 3,
+                        'auto' => 4,
+                ];
+                $best_priority = PHP_INT_MAX;
+
+                // recherche du fichier à conserver
+                $to_keep = null;
+                foreach($files as $file){
+                        foreach($priorities as $keyword => $priority){
+                                if(str_contains(basename($file), $keyword) && $priority < $best_priority){
+                                        $best_priority = $priority;
+                                        $to_keep = $file;
+                                        break;
+                                }
+                        }
+                }
+                // suppression des autres
+                foreach($files as $file){
+                    if($file !== $to_keep){
+                        unlink($file);
+                    }
                 }
         }
 
         static public function restoreDatabase(EntityManager $entityManager, string $file_name): void
         {
-                // backup de sécurité
-                Backup::mySQLdump($entityManager, 'before-restore');
+                // création d'un backup de sécurité non écrasable
+                if(!file_exists(self::$backup_dir . '/' . Config::$database . '_' . new DateTime()->format('Y-m-d') . '_before-restore.sql')){
+                        Backup::mySQLdump($entityManager, 'before-restore');
+                }
                 
                 $version = $entityManager->getConnection()->fetchOne('SELECT VERSION()');
                 $engine = stripos($version, 'mariadb') !== false ? 'mariadb' : 'mysql';