Ajout des fonctionnalités de gestion des projets : création, récupération et suppression de projets, avec gestion des dossiers associés.

controllers/projectController.js

@@ -0,0 +1,76 @@
+const db = require('../db');
+const fileUtils = require('../utils/fileUtils');
+
+/**
+ * Crée un nouveau projet et un dossier associé.
+ * @param {Object} req - La requête contenant les détails du projet.
+ * @param {Object} res - La réponse à renvoyer au client.
+ */
+exports.createProject = (req, res) => {
+    const { name, description } = req.body;
+
+    // Créer un dossier pour le projet
+    fileUtils.createProjectFolder(name)
+        .then(folderPath => {
+            // Ajouter le projet à la base de données
+            const query = 'INSERT INTO public.projects (name, description, folder_path) VALUES ($1, $2, $3) RETURNING id';
+            return db.query(query, [name, description, folderPath]);
+        })
+        .then(result => {
+            res.status(201).json({ message: 'Projet créé avec succès', id: result.rows[0].id });
+        })
+        .catch(err => {
+            console.error('Erreur lors de la création du projet:', err);
+            res.status(500).json({ error: 'Erreur serveur' });
+        });
+};
+
+/**
+ * Récupère tous les projets.
+ * @param {Object} req - La requête.
+ * @param {Object} res - La réponse à renvoyer au client.
+ */
+exports.getAllProjects = (req, res) => {
+    const query = 'SELECT * FROM public.projects';
+    db.query(query)
+        .then(result => {
+            res.json(result.rows);
+        })
+        .catch(err => {
+            console.error('Erreur lors de la récupération des projets:', err);
+            res.status(500).json({ error: 'Erreur serveur' });
+        });
+};
+
+/**
+ * Supprime un projet et son dossier associé.
+ * @param {Object} req - La requête contenant l'ID du projet à supprimer.
+ * @param {Object} res - La réponse à renvoyer au client.
+ */
+exports.deleteProject = (req, res) => {
+    const projectId = req.params.id;
+
+    // Récupérer le chemin du dossier du projet
+    const query = 'SELECT folder_path FROM public.projects WHERE id = $1';
+    db.query(query, [projectId])
+        .then(result => {
+            if (result.rowCount === 0) {
+                return res.status(404).json({ error: 'Aucun projet trouvé avec cet ID.' });
+            }
+            const folderPath = result.rows[0].folder_path;
+
+            // Supprimer le projet de la base de données
+            return db.query('DELETE FROM public.projects WHERE id = $1', [projectId])
+                .then(() => {
+                    // Supprimer le dossier du projet
+                    return fileUtils.deleteProjectFolder(folderPath);
+                });
+        })
+        .then(() => {
+            res.status(200).json({ message: 'Projet supprimé avec succès' });
+        })
+        .catch(err => {
+            console.error('Erreur lors de la suppression du projet:', err);
+            res.status(500).json({ error: 'Erreur serveur' });
+        });
+};

file_watcher.js

@@ -0,0 +1,54 @@
+const fs = require('fs');
+const path = require('path');
+const db = require('./db'); // Assurez-vous d'importer le fichier db.js
+
+const PROJECTS_DIR = path.join(__dirname, '../storage');
+
+// Fonction pour créer un dossier pour un projet
+function createProjectDirectory(projectId) {
+  const projectPath = path.join(PROJECTS_DIR, projectId.toString());
+  
+  fs.mkdir(projectPath, { recursive: true }, (err) => {
+    if (err) {
+      console.error(`Erreur lors de la création du dossier du projet ${projectId}:`, err);
+      return;
+    }
+    console.log(`Dossier créé pour le projet ${projectId} à ${projectPath}`);
+  });
+}
+
+// Fonction pour surveiller les changements dans le dossier de projets
+function watchProjects() {
+  fs.watch(PROJECTS_DIR, (eventType, filename) => {
+    if (eventType === 'rename') {
+      const projectId = path.basename(filename);
+      if (fs.existsSync(path.join(PROJECTS_DIR, filename))) {
+        // Un nouveau projet a été créé
+        console.log(`Nouveau projet détecté: ${projectId}`);
+        createProjectDirectory(projectId);
+        // Ajouter une entrée dans la base de données
+        db.query('INSERT INTO public.projects (id, name) VALUES ($1, $2)', [projectId, projectId], (err) => {
+          if (err) {
+            console.error('Erreur lors de l\'ajout du projet à la base de données:', err);
+          } else {
+            console.log(`Projet ${projectId} ajouté à la base de données.`);
+          }
+        });
+      } else {
+        // Un projet a été supprimé
+        console.log(`Projet supprimé: ${projectId}`);
+        // Supprimer l'entrée de la base de données
+        db.query('DELETE FROM public.projects WHERE id = $1', [projectId], (err) => {
+          if (err) {
+            console.error('Erreur lors de la suppression du projet de la base de données:', err);
+          } else {
+            console.log(`Projet ${projectId} supprimé de la base de données.`);
+          }
+        });
+      }
+    }
+  });
+}
+
+// Démarrer la surveillance des projets
+watchProjects();

models/projectModel.js

@@ -0,0 +1,41 @@
+module.exports = {
+   createProject: async (db, projectData) => {
+     const query = 'INSERT INTO public.projects (name, description, start_date, status) VALUES ($1, $2, $3, $4) RETURNING id';
+     const values = [projectData.name, projectData.description, projectData.start_date, projectData.status];
+     try {
+       const result = await db.query(query, values);
+       return result.rows[0].id;
+     } catch (error) {
+       throw new Error('Erreur lors de la création du projet: ' + error.message);
+     }
+   },
+ 
+   getProjectById: async (db, projectId) => {
+     const query = 'SELECT * FROM public.projects WHERE id = $1';
+     try {
+       const result = await db.query(query, [projectId]);
+       return result.rows[0];
+     } catch (error) {
+       throw new Error('Erreur lors de la récupération du projet: ' + error.message);
+     }
+   },
+ 
+   updateProject: async (db, projectId, projectData) => {
+     const query = 'UPDATE public.projects SET name = $1, description = $2, start_date = $3, status = $4 WHERE id = $5';
+     const values = [projectData.name, projectData.description, projectData.start_date, projectData.status, projectId];
+     try {
+       await db.query(query, values);
+     } catch (error) {
+       throw new Error('Erreur lors de la mise à jour du projet: ' + error.message);
+     }
+   },
+ 
+   deleteProject: async (db, projectId) => {
+     const query = 'DELETE FROM public.projects WHERE id = $1';
+     try {
+       await db.query(query, [projectId]);
+     } catch (error) {
+       throw new Error('Erreur lors de la suppression du projet: ' + error.message);
+     }
+   }
+ };

utils/fileUtils.js

@@ -0,0 +1,49 @@
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Crée un dossier pour un projet donné.
+ * @param {number} projectId - L'ID du projet.
+ * @param {string} baseDir - Le répertoire de base où le dossier du projet sera créé.
+ */
+function createProjectDirectory(projectId, baseDir) {
+    const projectDir = path.join(baseDir, `storage/${projectId}`);
+    if (!fs.existsSync(projectDir)) {
+        fs.mkdirSync(projectDir, { recursive: true });
+    }
+}
+
+/**
+ * Supprime le dossier d'un projet donné.
+ * @param {number} projectId - L'ID du projet.
+ * @param {string} baseDir - Le répertoire de base où le dossier du projet est situé.
+ */
+function deleteProjectDirectory(projectId, baseDir) {
+    const projectDir = path.join(baseDir, `storage/${projectId}`);
+    if (fs.existsSync(projectDir)) {
+        fs.rmdirSync(projectDir, { recursive: true });
+    }
+}
+
+/**
+ * Synchronise les fichiers d'un projet dans son dossier.
+ * @param {number} projectId - L'ID du projet.
+ * @param {string} sourceDir - Le répertoire source des fichiers à synchroniser.
+ * @param {string} baseDir - Le répertoire de base où le dossier du projet est situé.
+ */
+function syncProjectFiles(projectId, sourceDir, baseDir) {
+    const projectDir = path.join(baseDir, `storage/${projectId}`);
+    if (fs.existsSync(sourceDir)) {
+        fs.readdirSync(sourceDir).forEach(file => {
+            const srcFile = path.join(sourceDir, file);
+            const destFile = path.join(projectDir, file);
+            fs.copyFileSync(srcFile, destFile);
+        });
+    }
+}
+
+module.exports = {
+    createProjectDirectory,
+    deleteProjectDirectory,
+    syncProjectFiles
+};