Merge pull request 'Refactor des fonctions primaires' (#5) from refactor into main

Reviewed-on: https://gitea.kerboul.me/timelapse/timelapse-backend/pulls/5

api.js

@@ -7,8 +7,8 @@ const videoRoutes = require('./routes/videoRoutes');
 const imageRoutes = require('./routes/imageRoutes');
 const cameraRoutes = require('./routes/cameraRoutes');
 const uploadRoutes = require('./routes/uploadRoutes');
-const fileWatcher = require('./src/data/filewatcher.js');
+const FileWatcher = require('./src/data/filewatcher');
-const ffmpeg = require('./ffmpeg.js');
+const database_manager = require('./src/database/database_manager');
 
 router.use(cors({
   origin: ['http://127.0.0.1:5500', 'http://localhost:5500', 'http://localhost:3000'],

db.js

@@ -1,6 +1,10 @@
 const { Client } = require('pg');
+const devlock = require('./devlock.js');
 
-const client = new Client({
+let dev = devlock.is_dev;
+console.log('[INFO] Environment:', dev ? 'Development Local' : 'Development Remote');
+
+let client = new Client({
   host: '192.168.192.3',
   port: 5432,
   user: 'timelapse',
@@ -8,16 +12,28 @@ const client = new Client({
   database: 'timelapse'
 });
 
-function connectWithRetry() {
+if (dev) {
+  client = new Client({
+    host: 'mikoshi',
+    port: 54322,
+    user: 'timelapse',
+    password: 'timelapse',
+    database: 'timelapse_dev'
+  });
+}
+
+
+function init_database() {
+  console.log('[DB] Initialisation de la base de données PostgreSQL...');
   client.connect(err => {
     if (err) {
       console.error('Erreur de connexion à la base de données:', err);
-      setTimeout(connectWithRetry, 30000);
+      setTimeout(init_database, 3000);
     } else {
       console.log('[DB] Connecté à la base de données PostgreSQL.');
     }
   });
 }
 
-connectWithRetry();
+init_database();
 module.exports = client;

devlock.js

@@ -0,0 +1,5 @@
+let is_dev = false; // Set to true for development mode
+
+module.exports = {
+   is_dev
+}

eslint.config.mjs

@@ -0,0 +1,11 @@
+import { defineConfig } from "eslint/config";
+import globals from "globals";
+import js from "@eslint/js";
+
+
+export default defineConfig([
+  { files: ["**/*.{js,mjs,cjs}"] },
+  { files: ["**/*.js"], languageOptions: { sourceType: "commonjs" } },
+  { files: ["**/*.{js,mjs,cjs}"], languageOptions: { globals: globals.browser } },
+  { files: ["**/*.{js,mjs,cjs}"], plugins: { js }, extends: ["js/recommended"] },
+]);

ffmpeg.js

@@ -1,9 +1,9 @@
 const { exec } = require('child_process');
 
-exec('ffmpeg -version', (error, stdout, stderr) => {
+exec('ffmpeg -version', (error) => {
    if (error) {
       console.log('FFmpeg is not installed. Installing FFmpeg...');
-      exec('apt update && apt install -y ffmpeg', (installError, installStdout, installStderr) => {
+      exec('apt update && apt install -y ffmpeg', (installError) => {
          if (installError) {
             console.error(`Error installing FFmpeg: ${installError}`);
             return;

package.json

@@ -4,7 +4,8 @@
   "main": "index.js",
   "scripts": {
     "start": "node server.js",
-    "dev": "nodemon server.js"
+    "dev": "nodemon server.js",
+    "local" : "nodemon server_local.js"
   },
   "keywords": [],
   "author": "",
@@ -22,7 +23,10 @@
     "swagger-ui-express": "^5.0.1"
   },
   "devDependencies": {
+    "@eslint/js": "^9.23.0",
     "@types/cors": "^2.8.17",
+    "eslint": "^9.23.0",
+    "globals": "^16.0.0",
     "nodemon": "^3.1.7"
   }
 }

routes/cameraRoutes.js

@@ -1,10 +1,8 @@
 const express = require('express');
 const router = express.Router();
-const path = require('path');
-const fs = require('fs');
-const dbTester = require('../test/tester');
 const db = require('../db');
 const serverError = require('../utils/serverError');
+const { start } = require('repl');
 
 //const minInterval = 3; // Minutes
 //const maxInterval = 60; // Minutes
@@ -70,7 +68,7 @@ async function getCamera() {
 }
 
 async function printCameraStatus() {
-   let camera = getCamera();
+   let camera = await getCamera();
    console.log('Statut de la caméra:');
    console.log('Intervalle de capture:', camera.captureInterval, 'minutes');
    console.log('Maintenance:', camera.maintenance === 1 ? 'En cours' : 'Aucune');
@@ -176,8 +174,15 @@ async function changeProjectStatus(projectId, status) {
    }
 }
 
+async function startup() {
    await initCamera();
    await printCameraStatus();
+}
+
+startup()
+   .catch(err => {
+      console.error('Erreur lors de l\'initialisation de la caméra:', err);
+   });
 
 /**
  * @swagger
@@ -232,8 +237,8 @@ async function setCameraSettings(interval, maintenance) {
             console.error('Erreur lors de la mise à jour des paramètres de la caméra:', err);
          } else {
             console.log('Paramètres de la caméra mis à jour avec succès.');
-            captureInterval = interval;
+            //captureInterval = interval;
-            maintenance = maintenance;
+            //maintenance = maintenance;
          }
       });
    } catch (err) {

routes/imageRoutes.js

@@ -1,7 +1,6 @@
 const express = require('express');
 const router = express.Router();
 const sharp = require('sharp');
-const path = require('path');
 const fs = require('fs');
 const dbTester = require('../test/tester');
 const db = require('../db');

routes/measurementRoutes.js

@@ -1,86 +1,54 @@
 const express = require('express');
 const router = express.Router();
-const db = require('../db');
+const database_manager = require('../src/database/database_manager');
-const measureManager = require('../src/measure/measureManager');
-const serverError = require('../utils/serverError');
 
 router.get('/measurements', (req, res) => {
-   const query = 'SELECT * FROM public.measurements';
+   const measurements = database_manager.measurement.get_all_measurements();
-   db.query(query, (err, results) => {
+   if (!measurements) {
-      if (err) {
+      return res.status(404).json({ error: 'No measurements found' });
-         serverError.sendError('Erreur lors de la récupération des mesures:', res, err, 500);
    }
-      res.json(results.rows);
+   res.json(measurements);
-   });
 });
 
 router.get('/measurements/:id', (req, res) => {
-   const measurementId = req.params.id;
+   const measurement = database_manager.measurement.get_measurement_by_id(req.params.id);
-   if (!measurementId || isNaN(measurementId)) {
+   if (!measurement) {
-      return res.status(400).json({ error: 'Invalid measurement ID' });
+      return res.status(404).json({ error: 'Measurement not found' });
    }
-   const query = 'SELECT * FROM public.measurements WHERE id = $1';
+   res.json(measurement);
-   db.query(query, [measurementId], (err, results) => {
-      if (err) {
-         serverError.sendError('Erreur lors de la récupération de la mesure:', res, err, 500);
-      }
-      res.json(results.rows);
-   });
 });
 
 router.get('/measurements/:projectId/:orderId', async (req, res) => {
-   const projectId = req.params.projectId;
+   const measurement = await database_manager.measurement.get_measurement_by_project_and_order_id(req.params.projectId, req.params.orderId);
-   const orderId = req.params.orderId;
+   if (!measurement) {
-   if (!projectId || isNaN(projectId) || !orderId || isNaN(orderId)) {
+      return res.status(404).json({ error: 'Measurement not found' });
-      return res.status(400).json({ error: 'Invalid project ID or order ID' });
    }
-   try {
-      const measurement = await measureManager.getMeasurement(projectId, orderId);
    res.json(measurement);
-   } catch (error) {
-      serverError.sendError('Error getting measurement:', res, error, 500);
-   }
 });
 
 router.post('/measurements', (req, res) => {
-   const { project_id, timestamp, image_path, temperature, humidity } = req.body;
+   const { projectId, timestamp, imagePath, temperature, humidity, orderId } = req.body;
-   if (!project_id || !timestamp || !image_path || !temperature || !humidity) {
+   if (!projectId || !timestamp || !imagePath || !temperature || !humidity || !orderId) {
       return res.status(400).json({ error: 'All fields are required' });
    }
-   const query = 'INSERT INTO public.measurements (project_id, timestamp, image_path, temperature, humidity) VALUES ($1, $2, $3, $4, $5) RETURNING id';
+   const measurement = database_manager.measurement.add_measurement(projectId, timestamp, imagePath, temperature, humidity, orderId);
-   db.query(query, [project_id, timestamp, image_path, temperature, humidity], (err, results) => {
+   res.status(201).json(measurement);
-      if (err) {
-         serverError.sendError('Erreur lors de l\'ajout de la mesure:', res, err, 500);
-      }
-      res.status(201).json({ message: 'Mesure ajoutée avec succès', id: results.rows[0].id });
-   });
 });
 
 router.delete('/measurements/:id', async (req, res) => {
-   const measurementId = req.params.id;
+   const measurement = await database_manager.measurement.delete_measurement_by_id(req.params.id);
-   if (!measurementId || isNaN(measurementId)) {
+   if (!measurement) {
-      return res.status(400).json({ error: 'Invalid measurement ID' });
+      return res.status(404).json({ error: 'Measurement not found' });
-   }
-   try {
-      const measurement = await measureManager.deleteMeasurement(measurementId);
-      res.status(200).json({ message: 'Measurement deleted successfully', id: measurementId });
-   } catch (error) {
-      serverError.sendError('Error deleting measurement:', res, error, 500);
    }
+   res.json({ message: 'Measurement deleted successfully', id: measurement.id });
 });
 
 router.delete('/measurements/:projectId/:orderId', async (req, res) => {
-   const projectId = req.params.projectId;
+   const measurement = await database_manager.measurement.delete_measurement_by_project_and_order_id(req.params.projectId, req.params.orderId);
-   const orderId = req.params.orderId;
+   if (!measurement) {
-   if (!projectId || isNaN(projectId) || !orderId || isNaN(orderId)) {
+      return res.status(404).json({ error: 'Measurement not found' });
-      return res.status(400).json({ error: 'Invalid project ID or order ID' });
-   }
-   try {
-      const measurement = await measureManager.deleteMeasurementByOrderId(projectId, orderId);
-      res.status(200).json({ message: 'Measurement deleted successfully', id: measurement.id });
-   } catch (error) {
-      serverError.sendError('Error deleting measurement:', res, error, 500);
    }
+   res.json({ message: 'Measurement deleted successfully', id: measurement.id });
 });
 
 module.exports = router;

routes/projectRoutes.js

@@ -1,11 +1,12 @@
 const express = require('express');
 const router = express.Router();
-const projectManager = require('../src/project/projectManager');
 const serverError = require('../utils/serverError');
+const database_manager = require('../src/database/database_manager');
+const storage_manager = require('../src/data/storage_manager');
 
 router.get('/projects', async (req, res) => {
    try {
-      const projects = await projectManager.getAllProjects();
+      const projects = await database_manager.project.get_all_projects();
       res.json(projects);
    } catch (error) {
       serverError.sendError('Error getting all projects:', res, error, 500);
@@ -18,7 +19,7 @@ router.get('/projects/:id', async (req, res) => {
       return res.status(400).json({ error: 'Invalid project ID' });
    }
    try {
-      const project = await projectManager.getProjectById(projectId);
+      const project = await database_manager.project.get_project_by_id(projectId);
       res.json(project);
    } catch (error) {
       serverError.sendError('Error getting project by ID:', res, error, 500);
@@ -31,7 +32,10 @@ router.get('/projects/:id/videos', async (req, res) => {
       return res.status(400).json({ error: 'Invalid project ID' });
    }
    try {
-      const videos = await projectManager.getVideosByProjectId(projectId);
+      const videos = await database_manager.video.get_videos_by_project_id(projectId);
+      if (videos.length === 0) {
+         return res.status(404).json({ error: 'No videos found for this project' });
+      }
       res.json(videos);
    } catch (error) {
       serverError.sendError('Error getting videos by project ID:', res, error, 500);
@@ -44,7 +48,10 @@ router.get('/projects/:id/measurements', async (req, res) => {
       return res.status(400).json({ error: 'Invalid project ID' });
    }
    try {
-      const measurements = await projectManager.getMeasurementsByProjectId(projectId);
+      const measurements = await database_manager.measurement.get_measurements_by_project_id(projectId);
+      if (measurements.length === 0) {
+         return res.status(404).json({ error: 'No measurements found for this project' });
+      }
       res.json(measurements);
    } catch (error) {
       serverError.sendError('Error getting measurements by project ID:', res, error, 500);
@@ -57,8 +64,10 @@ router.post('/projects', async (req, res) => {
       return res.status(400).json({ error: 'Name and description are required' });
    }
    try {
-      const project = await projectManager.createProject(name, description, new Date(), 0);
+      const date = new Date();
-      projectManager.createProjectDirectory(project.id);
+      const default_status = 0;
+      const project = await database_manager.project.create_project(name, description, date, default_status);
+      storage_manager.project.createProjectDirectory(project.id);
       res.status(201).json({ message: 'Project added successfully', id: project.id });
    } catch (error) {
       serverError.sendError('Error creating project:', res, error, 500);
@@ -71,8 +80,8 @@ router.delete('/projects/:id', async (req, res) => {
       return res.status(400).json({ error: 'Invalid project ID' });
    }
    try {
-      projectManager.deleteProjectDirectory(projectId);
+      storage_manager.project.deleteProjectDirectory(projectId);
-      projectManager.deleteProjectById(projectId);
+      await database_manager.project.delete_project(projectId);
       res.status(200).json({ message: 'Project deleted successfully', id: projectId });
    } catch (error) {
       serverError.sendError('Error deleting project:', res, error, 500);

routes/uploadRoutes.js

@@ -1,7 +1,8 @@
 const express = require('express');
 const router = express.Router();
 const multer = require('multer');
-const measureManager = require('../src/measure/measureManager');
+const database_manager = require('../src/database/database_manager');
+const storage_manager = require('../src/data/storage_manager');
 const serverError = require('../utils/serverError');
 
 const upload = multer({ storage: multer.memoryStorage() });
@@ -17,7 +18,10 @@ router.post('/uploadmeasurement', upload.single('image'), async (req, res) => {
   }
 
   try {
-    const nextOrderId = await measureManager.getNextOrderId(projectId);
+    const nextOrderId = await database_manager.measurement.get_next_order_id(projectId);
+    if (nextOrderId === null) {
+      return res.status(404).json({ error: 'Project not found' });
+    }
 
     // Log types for debugging
     console.log('Types:', {
@@ -26,8 +30,14 @@ router.post('/uploadmeasurement', upload.single('image'), async (req, res) => {
       nextOrderId: typeof nextOrderId
     });
 
-    const imagePath = await measureManager.uploadMeasureImage(image, projectId, nextOrderId);
+    const imagePath = await storage_manager.measurement.upload_measurement_image(image, projectId, nextOrderId);
-    const measurement = await measureManager.addMeasureToProject(projectId, timestamp, imagePath, temperature, humidity, nextOrderId);
+    if (!imagePath) {
+      return res.status(500).json({ error: 'Failed to upload image' });
+    }
+    const measurement = await database_manager.measurement.add_measurement(projectId, timestamp, imagePath, temperature, humidity, nextOrderId);
+    if (!measurement) {
+      return res.status(500).json({ error: 'Failed to add measurement' });
+    }
     res.json({ message: 'Measurement uploaded successfully', path: imagePath, id: measurement.id });
   } catch (error) {
     serverError.sendError('Error uploading measurement:', res, error, 500);

routes/videoRoutes.js

@@ -3,10 +3,10 @@ const router = express.Router();
 const db = require('../db');
 const fs = require('fs');
 const rangeParser = require('range-parser');
-const path = require('path');
 const serverError = require('../utils/serverError');
 const videoManager = require('../src/video/videoManager');
-const measureManager = require('../src/measure/measureManager');
+const database_manager = require('../src/database/database_manager');
+const storage_manager = require('../src/data/storage_manager');
 const dbTester = require('../test/tester');
 
 router.get('/videos', (req, res) => {
@@ -56,7 +56,10 @@ router.post('/videos', async (req, res) => {
       }
 
       const { duration: videoDuration, measurement_ids: videoMeasurementIds, project_id: videoProjectId } = result.rows[0];
-      const pathList = await measureManager.getPathList(videoMeasurementIds, videoProjectId);
+      const pathList = await storage_manager.measurement.get_path_list(videoMeasurementIds, project_id);
+      if (!pathList || pathList.length === 0) {
+         return res.status(404).json({ error: 'Aucun chemin trouvé pour les mesures' });
+      }
       
       // parser la résolution (ex: 1920x1080)
       const [res_width, res_height] = resolution.split('x').map(Number);
@@ -68,7 +71,7 @@ router.post('/videos', async (req, res) => {
       videoManager.createVideoWithList(videoProjectId, pathList, videoDuration, videoId, res_width, res_height)
          .then(videoFile => {
             console.log('Rendu vidéo terminé:', videoFile);
-            return videoManager.updateVideoFile(videoId, videoFile);
+            return database_manager.video.update_video_file_path_by_id(videoId, videoFile);
          })
          .catch(error => {
             console.error('Échec du rendu vidéo:', error);
@@ -228,15 +231,15 @@ router.get('/videos/progress/:video_id', async (req, res) => {
    }
 });
 
-function getStatusLabel(status) {
+// function getStatusLabel(status) {
-   const statusMap = {
+//    const statusMap = {
-       0: 'En attente',
+//        0: 'En attente',
-       1: 'Terminé',
+//        1: 'Terminé',
-       2: 'Échec',
+//        2: 'Échec',
-       3: 'En cours'
+//        3: 'En cours'
-   };
+//    };
-   return statusMap[status] || 'Inconnu';
+//    return statusMap[status] || 'Inconnu';
-}
+// }
 
 
 router.get('/cat', (_, res) => {

server.js

@@ -1,7 +1,6 @@
 // server.js
 const express = require('express');
 const cors = require('cors'); 
-const sharp = require('sharp');
 const app = express();
 const port = 3000;
 

server_local.js

@@ -0,0 +1,68 @@
+const devlock = require('./devlock.js');
+devlock.is_dev = true; // Set to true for development mode
+
+// server.js version locale
+const express = require('express');
+const cors = require('cors'); 
+const app = express();
+const port = 3000;
+
+// Middleware pour gérer les requêtes JSON
+app.use(express.json());
+
+// Cors accès à tout
+app.use(cors({
+  origin: ['http://127.0.0.1:5500', 'http://localhost:5500', 'http://localhost:3000'],
+  methods: ['GET', 'POST', 'PUT', 'DELETE'],
+  allowedHeaders: ['Content-Type'],
+  credentials: true,
+}));
+
+// Importer les routes
+const apiRoutes = require('./api');
+app.use('/api', apiRoutes);
+
+// Swagger dependencies
+const swaggerUi = require('swagger-ui-express');
+const swaggerJsdoc = require('swagger-jsdoc');
+
+// Configuration de Swagger
+const swaggerOptions = {
+  definition: {
+    openapi: '3.0.0',
+    info: {
+      title: 'API Documentation',
+      version: '1.0.0',
+      description: 'Documentation de l\'API avec Swagger',
+    },
+    servers: [
+      {
+        url: 'https://timelapse.kerboul.me/api',
+      },
+      {
+        url: 'http://localhost:3000/api',
+      }
+    ],
+  },
+  apis: ['./routes/*.js'], // Prend en compte tous les fichiers de routes pour générer la documentation
+};
+
+// Initialisation de swagger-jsdoc
+const swaggerDocs = swaggerJsdoc(swaggerOptions);
+
+// Route Swagger UI
+app.use('/api-docs', swaggerUi.serve, swaggerUi.setup(swaggerDocs));
+
+// Route de base pour tester le serveur
+app.get('/', (req, res) => {
+  res.setHeader('Access-Control-Allow-Origin', 'http://localhost:5500');
+  res.setHeader('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE');
+  res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
+  res.send('Bienvenue sur mon API Node.js!');
+});
+
+// Démarrer le serveur
+app.listen(port, () => {
+  console.log(`[SERVER] Serveur démarré sur http://localhost:${port}`);
+  console.log(`[SERVER] Swagger documentation disponible sur http://localhost:${port}/api-docs`);
+});

src/data/filewatcher.js

@@ -1,7 +1,6 @@
-import db from '../../db.js';
+const db = require('../../db.js');
-import path from 'path';
+const storage_manager = require('./storage_manager.js');
-import storageManager from '../data/storageManager.js';
+const fs = require('fs');
-import fs from 'fs';
 
 let localCounter = 0;
 
@@ -17,9 +16,7 @@ async function checkAndRemoveInvalidEntries() {
          }
       }
 
-      // Scan all images in storage
+      const allImages = await storage_manager.scanAllImages();
-      const allImages = await storageManager.scanAllImages();
-      //console.log('Scanned all images:', allImages);
       for (const imagePath of allImages) {
          const entryRes = await db.query('SELECT id FROM measurements WHERE path = $1', [imagePath]);
          if (entryRes.rows.length === 0) {
@@ -30,6 +27,7 @@ async function checkAndRemoveInvalidEntries() {
       }
       if (localCounter > 0) {
          console.log(`[INFO] ${localCounter} entrées ont été modifiées`);
+         localCounter = 0; // Reset the counter after logging
       }
    } catch (err) {
       console.error('Error checking and removing invalid entries:', err);

src/data/storageManager.js

@@ -1,87 +0,0 @@
-const fs = require('fs').promises;
-const path = require('path');
-const PROJECTS_DIR = path.join('.');
-
-async function createFolder(name) {
-   const projectDir = path.join(PROJECTS_DIR, `${name}`);
-   try {
-      await fs.access(projectDir);
-   } catch (error) {
-      if (error.code === 'ENOENT') {
-         await fs.mkdir(projectDir, { recursive: true });
-      } else {
-         throw error;
-      }
-   }
-   return projectDir;
-}
-
-async function deleteFolder(name) {
-   const projectDir = path.join(PROJECTS_DIR, `${name}`);
-   try {
-      await fs.access(projectDir);
-      await fs.rm(projectDir, { recursive: true, force: true });
-   } catch (error) {
-      if (error.code !== 'ENOENT') {
-         throw error;
-      }
-   }
-}
-
-async function scanAllImages(dir = 'storage') {
-   const projectDir = path.join(PROJECTS_DIR, dir);
-   let results = [];
-
-   async function scanDirectory(directory) {
-      const files = await fs.readdir(directory);
-      for (const file of files) {
-         const filePath = path.join(directory, file);
-         const stat = await fs.stat(filePath);
-         if (stat.isDirectory()) {
-            await scanDirectory(filePath);
-         } else if (file.endsWith('.jpg')) {
-            results.push(filePath);
-         }
-      }
-   }
-
-   await scanDirectory(projectDir);
-   return results;
-}
-
-async function saveFile(filePath, content) {
-   if (Buffer.isBuffer(content)) {
-      await fs.writeFile(filePath, content);
-   } else {
-      throw new Error('Content must be a buffer');
-   }
-}
-
-async function getFile(name) {
-   const filePath = path.join(PROJECTS_DIR, `${name}`);
-   return await fs.readFile(filePath);
-}
-
-async function deleteFile(name) {
-   const filePath = path.join(PROJECTS_DIR, `${name}`);
-   try {
-       await fs.access(filePath); // Vérifie si le fichier existe
-       await fs.rm(filePath); // Supprime le fichier
-       return `File ${filePath} deleted successfully.`;
-   } catch (error) {
-       if (error.code === 'ENOENT') {
-           return `File ${filePath} does not exist.`;
-       } else {
-           throw error; // Relance l'erreur si ce n'est pas une erreur de fichier introuvable
-       }
-   }
-}
-
-module.exports = {
-   createFolder,
-   deleteFolder,
-   scanAllImages,
-   saveFile,
-   getFile,
-   deleteFile
-};

src/data/storage_manager.js

@@ -0,0 +1,196 @@
+const fs = require('fs').promises;
+const path = require('path');
+const PROJECTS_DIR = path.join('.');
+const database_manager = require('../database/database_manager.js');
+
+async function createFolder(name) {
+   const projectDir = path.join(PROJECTS_DIR, `${name}`);
+   try {
+      await fs.access(projectDir);
+   } catch (error) {
+      if (error.code === 'ENOENT') {
+         await fs.mkdir(projectDir, { recursive: true });
+      } else {
+         throw error;
+      }
+   }
+   return projectDir;
+}
+
+async function deleteFolder(name) {
+   const projectDir = path.join(PROJECTS_DIR, `${name}`);
+   try {
+      await fs.access(projectDir);
+      await fs.rm(projectDir, { recursive: true, force: true });
+   } catch (error) {
+      if (error.code !== 'ENOENT') {
+         throw error;
+      }
+   }
+}
+
+async function scanAllImages(dir = 'storage') {
+   const projectDir = path.join(PROJECTS_DIR, dir);
+   let results = [];
+
+   // check if the directory exists and create it if not
+   try {
+      await fs.access(projectDir);
+   } catch (error) {
+      if (error.code === 'ENOENT') {
+         await fs.mkdir(projectDir, { recursive: true });
+      } else {
+         throw error;
+      }
+   }
+
+   async function scanDirectory(directory) {
+      const files = await fs.readdir(directory);
+      for (const file of files) {
+         const filePath = path.join(directory, file);
+         const stat = await fs.stat(filePath);
+         if (stat.isDirectory()) {
+            await scanDirectory(filePath);
+         } else if (file.endsWith('.jpg')) {
+            results.push(filePath);
+         }
+      }
+   }
+
+   await scanDirectory(projectDir);
+   return results;
+}
+
+async function saveFile(filePath, content) {
+   let Buffer=Buffer.from(content, 'base64');
+   if (Buffer.isBuffer(content)) {
+      await fs.writeFile(filePath, content);
+   } else {
+      throw new Error('Content must be a buffer');
+   }
+}
+
+async function getFile(name) {
+   const filePath = path.join(PROJECTS_DIR, `${name}`);
+   return await fs.readFile(filePath);
+}
+
+async function deleteFile(name) {
+   const filePath = path.join(PROJECTS_DIR, `${name}`);
+   try {
+       await fs.access(filePath); // Vérifie si le fichier existe
+       await fs.rm(filePath); // Supprime le fichier
+       return `File ${filePath} deleted successfully.`;
+   } catch (error) {
+       if (error.code === 'ENOENT') {
+           return `File ${filePath} does not exist.`;
+       } else {
+           throw error; // Relance l'erreur si ce n'est pas une erreur de fichier introuvable
+       }
+   }
+}
+
+async function handleFileOperation(operation, ...args) {
+   try {
+      return await operation(...args);
+   } catch (error) {
+      console.error(`[FILE OPERATION ERROR] ${error.message}`);
+      throw error;
+   }
+}
+
+const project = {
+   createProjectDirectory: async function (projectId) {
+      const projectPath = `${projectId}`;
+      await handleFileOperation(createFolder, projectPath);
+      await handleFileOperation(createFolder, `${projectPath}/images`);
+      await handleFileOperation(createFolder, `${projectPath}/videos`);
+      console.log("[FILE] createProjectDirectory : " + projectPath);
+   },
+
+   deleteProjectDirectory: async function (projectId) {
+      const projectPath = `${projectId}`;
+      await handleFileOperation(deleteFolder, projectPath);
+      console.log("[FILE] deleteProjectDirectory : " + projectPath);
+   }
+};
+
+const measurement = {
+   get_measurement_image: async function (projectId, orderId) {
+      const projectPath = `${projectId}`;
+      const imagePath = `${projectPath}/images/${orderId}.jpg`;
+      console.log("[FILE] get_measurement_image : " + imagePath);
+      return await handleFileOperation(getFile, imagePath);
+   },
+
+   upload_measurement_image: async function (image, projectId, orderId) {
+      const projectPath = `${projectId}`;
+      const imagePath = `${projectPath}/images/${orderId}.jpg`;
+      console.log("[FILE] upload_measurement_image : " + imagePath);
+      await handleFileOperation(saveFile, imagePath, image.buffer);
+      return imagePath;
+   },
+
+   get_path_from_id: async function (projectId, orderId) {
+      const query = database_manager.measurement.get_measurement_by_project_and_order_id(projectId, orderId);
+      return query.path;
+   },
+
+   get_path_list: async function (IdList, projectId) {
+      let parsedIdList;
+      try {
+         parsedIdList = JSON.parse(IdList);
+      } catch (e) {
+         console.error("Error parsing IdList:", e);
+         return [];
+      }
+
+      const pathList = [];
+      for (const orderId of parsedIdList) {
+         const path = await this.get_path_from_id(projectId, orderId);
+         pathList.push(path);
+      }
+      return pathList;
+   },
+}
+
+const video = {
+   get_video: async function (projectId, orderId) {
+      const projectPath = `${projectId}`;
+      const videoPath = `${projectPath}/videos/${orderId}.mp4`;
+      console.log("[FILE] get_video : " + videoPath);
+      return await handleFileOperation(getFile, videoPath);
+   },
+
+   delete_video: async function (videoId) {
+      const query = database_manager.video.get_video_by_id(videoId);
+      const videoPath = query.video_file;
+      console.log("[FILE] delete_video : " + videoPath);
+      return await handleFileOperation(deleteFile, videoPath);
+   },
+
+   delete_unfinished_videos: async function () {
+      const unfinishedVideos = await database_manager.video.get_unfinished_videos();
+
+      for (const video of unfinishedVideos) {
+          try {
+              await this.delete_video(video.id);
+              console.log(`Deleted unfinished video with id: ${video.id}`);
+          } catch (error) {
+              console.error(`Error deleting unfinished video with id: ${video.id}`, error);
+          }
+      }
+   }
+}
+
+module.exports = {
+   createFolder,
+   deleteFolder,
+   scanAllImages,
+   saveFile,
+   getFile,
+   deleteFile,
+   project,
+   measurement,
+   video
+};

src/database/database_manager.js

@@ -0,0 +1,285 @@
+const db = require('../../db.js');
+
+// Fonctions de gestion de la base de données interne
+
+async function create_database() {
+   const queries = [
+      `CREATE TABLE IF NOT EXISTS projects (
+         id SERIAL PRIMARY KEY,
+         name VARCHAR(255) NOT NULL,
+         description TEXT,
+         start_date DATE,
+         status INTEGER NOT NULL CHECK (status = ANY (ARRAY [0, 1, 2, 3]))
+      );`,
+      `ALTER TABLE projects OWNER TO timelapse;`,
+      `CREATE TABLE IF NOT EXISTS measurements (
+         id SERIAL PRIMARY KEY,
+         project_id INTEGER REFERENCES projects ON DELETE CASCADE,
+         timestamp TIMESTAMP NOT NULL,
+         path VARCHAR(255),
+         temperature DOUBLE PRECISION,
+         humidity DOUBLE PRECISION,
+         order_id INTEGER NOT NULL,
+         CONSTRAINT unique_project_photo_order UNIQUE (project_id, order_id)
+      );`,
+      `ALTER TABLE measurements OWNER TO timelapse;`,
+      `CREATE TABLE IF NOT EXISTS videos (
+         id SERIAL PRIMARY KEY,
+         project_id INTEGER REFERENCES projects ON DELETE CASCADE,
+         measurement_ids TEXT NOT NULL,
+         video_file VARCHAR(255),
+         resolution VARCHAR(255),
+         duration INTEGER,
+         status INTEGER NOT NULL CHECK (status = ANY (ARRAY [0, 1, 2, 3])),
+         name VARCHAR(255),
+         progress DOUBLE PRECISION,
+         started_at TIMESTAMP,
+         updated_at TIMESTAMP,
+         eta DOUBLE PRECISION
+      );`,
+      `ALTER TABLE videos OWNER TO timelapse;`,
+      `CREATE TABLE IF NOT EXISTS camera (
+         id SERIAL PRIMARY KEY,
+         interval INTEGER NOT NULL,
+         maintenance INTEGER NOT NULL,
+         active INTEGER DEFAULT 0 NOT NULL
+      );`,
+      `ALTER TABLE camera OWNER TO timelapse;`
+   ];
+
+   try {
+      for (const query of queries) {
+         await db.query(query);
+      }
+      console.log('Database tables created or verified successfully.');
+   } catch (err) {
+      console.error('Error creating database tables:', err);
+      throw err;
+   }
+}
+
+async function check_database_existence() {
+   const query = `
+      SELECT table_name 
+      FROM information_schema.tables 
+      WHERE table_schema = 'public' 
+      AND table_name IN ('projects', 'measurements', 'videos', 'camera');
+   `;
+
+   try {
+      const result = await db.query(query);
+      const existingTables = result.rows.map(row => row.table_name);
+
+      const requiredTables = ['projects', 'measurements', 'videos', 'camera'];
+      const missingTables = requiredTables.filter(table => !existingTables.includes(table));
+
+      if (missingTables.length > 0) {
+         console.error('Missing or improperly constructed tables:', missingTables);
+         throw new Error(`The following tables are missing or not properly constructed: ${missingTables.join(', ')}`);
+      } else {
+         console.log('All required tables exist and are properly constructed.');
+      }
+   } catch (err) {
+      console.error('Error checking database tables:', err);
+      throw err;
+   }
+}
+
+async function delete_database() {
+   const queries = [
+      `DROP TABLE IF EXISTS videos;`,
+      `DROP TABLE IF EXISTS measurements;`,
+      `DROP TABLE IF EXISTS projects;`,
+      `DROP TABLE IF EXISTS camera;`
+   ];
+
+   try {
+      for (const query of queries) {
+         await db.query(query);
+      }
+      console.log('Database tables deleted successfully.');
+   } catch (err) {
+      console.error('Error deleting database tables:', err);
+      throw err;
+   }
+}
+
+async function init_function() {
+   try {
+      await check_database_existence();
+   } catch (err) {
+      console.error('Database check failed:', err);
+      try {
+         await delete_database();
+         await create_database();
+         console.log('Database initialized successfully.');
+      } catch (err) {
+         console.error('Error initializing database:', err);
+         throw err;
+      }
+   } finally {
+      console.log('Database initialization process completed.');
+   }
+}
+
+init_function()
+   .then(() => console.log('Database initialization completed.'))
+   .catch(err => console.error('Error during database initialization:', err));
+
+// Fonctions pour les projets
+function handleDatabaseOperation(operation) {
+   return async (...args) => {
+      try {
+         return await operation(...args);
+      } catch (err) {
+         console.error(`Error during database operation: ${operation.name}`, err);
+         throw err;
+      }
+   };
+}
+
+const project = {
+   get_all_projects: handleDatabaseOperation(async () => {
+      const query = `SELECT * FROM projects;`;
+      return (await db.query(query)).rows;
+   }),
+   get_project_by_id: handleDatabaseOperation(async (id) => {
+      const query = `SELECT * FROM projects WHERE id = $1;`;
+      return (await db.query(query, [id])).rows[0];
+   }),
+   create_project: handleDatabaseOperation(async (name, description, start_date, status) => {
+      const query = `INSERT INTO projects (name, description, start_date, status) VALUES ($1, $2, $3, $4) RETURNING *;`;
+      return (await db.query(query, [name, description, start_date, status])).rows[0];
+   }),
+   edit_project_by_id: handleDatabaseOperation(async (id, updates) => {
+      const fields = Object.keys(updates).map((key, index) => `${key} = $${index + 2}`).join(', ');
+      const values = [id, ...Object.values(updates)];
+      const query = `UPDATE projects SET ${fields} WHERE id = $1 RETURNING *;`;
+      return (await db.query(query, values)).rows[0];
+   }),
+   delete_project_by_id: handleDatabaseOperation(async (id) => {
+      const query = `DELETE FROM projects WHERE id = $1;`;
+      await db.query(query, [id]);
+   })
+};
+
+const measurement = {
+   get_all_measurements: handleDatabaseOperation(async () => {
+      const query = `SELECT * FROM measurements;`;
+      return (await db.query(query)).rows;
+   }),
+   get_measurement_by_id: handleDatabaseOperation(async (id) => {
+      const query = `SELECT * FROM measurements WHERE id = $1;`;
+      return (await db.query(query, [id])).rows[0];
+   }),
+   get_measurement_by_project_and_order_id: handleDatabaseOperation(async (project_id, order_id) => {
+      const query = `SELECT * FROM measurements WHERE project_id = $1 AND order_id = $2;`;
+      return (await db.query(query, [project_id, order_id])).rows[0];
+   }),
+   get_measurements_by_project_id: handleDatabaseOperation(async (project_id) => {
+      const query = `SELECT * FROM measurements WHERE project_id = $1;`;
+      return (await db.query(query, [project_id])).rows;
+   }),
+   create_measurement: handleDatabaseOperation(async (project_id, timestamp, path, temperature, humidity, order_id) => {
+      const query = `INSERT INTO measurements (project_id, timestamp, path, temperature, humidity, order_id) VALUES ($1, $2, $3, $4, $5, $6) RETURNING *;`;
+      return (await db.query(query, [project_id, timestamp, path, temperature, humidity, order_id])).rows[0];
+   }),
+   edit_measurement_by_id: handleDatabaseOperation(async (id, updates) => {
+      const fields = Object.keys(updates).map((key, index) => `${key} = $${index + 2}`).join(', ');
+      const values = [id, ...Object.values(updates)];
+      const query = `UPDATE measurements SET ${fields} WHERE id = $1 RETURNING *;`;
+      return (await db.query(query, values)).rows[0];
+   }),
+
+   edit_measurement_by_project_and_order_id: handleDatabaseOperation(async (project_id, order_id, updates) => {
+      const fields = Object.keys(updates).map((key, index) => `${key} = $${index + 3}`).join(', ');
+      const values = [project_id, order_id, ...Object.values(updates)];
+      const query = `UPDATE measurements SET ${fields} WHERE project_id = $1 AND order_id = $2 RETURNING *;`;
+      return (await db.query(query, values)).rows[0];
+   }),
+
+   delete_measurement_by_id: handleDatabaseOperation(async (id) => {
+      const query = `DELETE FROM measurements WHERE id = $1;`;
+      await db.query(query, [id]);
+   }),
+
+   get_next_order_id: handleDatabaseOperation(async (project_id) => {
+      const query = `SELECT COALESCE(MAX(order_id), 0) + 1 AS next_order_id FROM measurements WHERE project_id = $1;`;
+      const result = await db.query(query, [project_id]);
+      return result.rows[0].next_order_id;
+   })
+};
+
+const video = {
+   get_all_videos: handleDatabaseOperation(async () => {
+      const query = `SELECT * FROM videos;`;
+      return (await db.query(query)).rows;
+   }),
+
+   get_video_by_id: handleDatabaseOperation(async (id) => {
+      const query = `SELECT * FROM videos WHERE id = $1;`;
+      return (await db.query(query, [id])).rows[0];
+   }),
+
+   get_videos_by_project_id: handleDatabaseOperation(async (project_id) => {
+      const query = `SELECT * FROM videos WHERE project_id = $1;`;
+      return (await db.query(query, [project_id])).rows;
+   }),
+
+   create_video: handleDatabaseOperation(async (projectId, measurementIds, name, resolution, duration, status = 0) => {
+      const query = `INSERT INTO public.videos (project_id, measurement_ids, name, resolution, duration, status) VALUES ($1, $2, $3, $4, $5, $6) RETURNING id;`;
+      const values = [projectId, measurementIds, name, resolution, duration, status];
+      return (await db.query(query, values)).rows[0];
+   }),
+
+   edit_video_by_id: handleDatabaseOperation(async (id, updates) => {
+      const fields = Object.keys(updates).map((key, index) => `${key} = $${index + 2}`).join(', ');
+      const values = [id, ...Object.values(updates)];
+      const query = `UPDATE videos SET ${fields} WHERE id = $1 RETURNING *;`;
+      return (await db.query(query, values)).rows[0];
+   }),
+
+   update_video_file_path_by_id: handleDatabaseOperation(async (id, video_file) => {
+      const query = `UPDATE videos SET video_file = $1 WHERE id = $2 RETURNING *;`;
+      return (await db.query(query, [video_file, id])).rows[0];
+   }
+   ),
+
+   delete_video_by_id: handleDatabaseOperation(async (id) => {
+      const query = `DELETE FROM videos WHERE id = $1;`;
+      await db.query(query, [id]);
+   }),
+
+   get_unfinished_videos: handleDatabaseOperation(async () => {
+      // récupérer liste des vidéos dont le status est = 0, 2 ou 3
+      const query = `SELECT * FROM videos WHERE status IN (0, 2, 3);`;
+      return (await db.query(query)).rows;
+   }),
+};
+
+const camera = {
+   get_camera: handleDatabaseOperation(async () => {
+      const query = `SELECT * FROM camera;`;
+      return (await db.query(query)).rows;
+   }),
+
+   edit_camera: handleDatabaseOperation(async (id, updates) => {
+      const fields = Object.keys(updates).map((key, index) => `${key} = $${index + 2}`).join(', ');
+      const values = [id, ...Object.values(updates)];
+      const query = `UPDATE camera SET ${fields} WHERE id = $1 RETURNING *;`;
+      return (await db.query(query, values)).rows[0];
+   }),
+
+   delete_camera: handleDatabaseOperation(async (id) => {
+      const query = `DELETE FROM camera WHERE id = $1;`;
+      await db.query(query, [id]);
+   })
+};
+
+// Export des modules
+module.exports = {
+   project,
+   measurement,
+   video,
+   camera
+};

src/measure/measureManager.js

@@ -1,130 +0,0 @@
-import db from '../../db.js';
-import path from 'path';
-import storageManager from '../data/storageManager.js';
-
-async function uploadMeasureImage(image, projectId, orderId) {
-   try {
-     // Ensure that folder creation and file saving are awaited
-     const projectDir = await storageManager.createFolder('./storage/' + projectId.toString());
-     const imagesDir = await storageManager.createFolder(path.join(projectDir, 'images'));
-     const imagePath = path.join(imagesDir, `${orderId}.jpg`);
- 
-     // Save the file and await completion
-     await storageManager.saveFile(imagePath, image.buffer);
- 
-     console.log("[FILE] uploadMeasureImage - Image saved to: " + imagePath);
-     return imagePath;
-   } catch (error) {
-     console.error('Error in uploadMeasureImage:', error);
-     throw error;
-   }
- }
-
-async function getMeasureImage(projectId, orderId) {
-   const projectPath = `${projectId}`;
-   const imagePath = `${projectPath}/${orderId}.jpg`;
-   console.log("[FILE] getMeasureImage - Image path: " + imagePath);
-   return storageManager.getFile(imagePath);
-}
-
-async function getNextOrderId(projectId) {
-   const query = 'SELECT MAX(order_id) FROM public.measurements WHERE project_id = $1';
-   const values = [projectId];
-   const res = await db.query(query, values);
-   console.log("[DB] getNextOrderId - Max order_id: " + res.rows[0].max);
-   return res.rows[0].max + 1;
-}
-
-async function addMeasureToProject(projectId, orderId, timestamp, path, temperature, humidity) {
-   const query = 'INSERT INTO public.measurements (project_id, timestamp, path, temperature, humidity, order_id) VALUES ($1, $2, $3, $4, $5, $6) RETURNING *';
-   const values = [projectId, orderId, timestamp, path, temperature, humidity];
-   const res = await db.query(query, values);
-   return res.rows[0];
-}
-
-async function getMeasurements(projectId) {
-   const query = 'SELECT * FROM public.measurements WHERE project_id = $1';
-   const values = [projectId];
-   const res = await db.query(query, values);
-   return res.rows;
-}
-
-async function getMeasurement(projectId, orderId) {
-   const query = 'SELECT * FROM public.measurements WHERE project_id = $1 AND order_id = $2';
-   const values = [projectId, orderId];
-   const res = await db.query(query, values);
-   return res.rows[0];
-}
-
-async function getMeasurementById(id) {
-   const query = 'SELECT * FROM public.measurements WHERE id = $1';
-   const values = [id];
-   const res = await db.query(query, values);
-   return res.rows[0];
-}
-
-async function updateMeasurement(projectId, orderId, timestamp, path, temperature, humidity) {
-   const query = 'UPDATE public.measurements SET timestamp = $3, path = $4, temperature = $5, humidity = $6 WHERE project_id = $1 AND order_id = $2 RETURNING *';
-   const values = [projectId, orderId, timestamp, path, temperature, humidity];
-   const res = await db.query(query, values);
-   return res.rows[0];
-}
-
-async function updateMeasurementById(id, timestamp, path, temperature, humidity) {
-   const query = 'UPDATE public.measurements SET timestamp = $2, path = $3, temperature = $4, humidity = $5 WHERE id = $1 RETURNING *';
-   const values = [id, timestamp, path, temperature, humidity];
-   const res = await db.query(query, values);
-   return res.rows[0];
-}
-
-async function deleteMeasurement(id) {
-   const query = 'DELETE FROM public.measurements WHERE id = $1';
-   const values = [id];
-   const res = await db.query(query, values);
-   return res.rows[0];
-}
-
-async function getPathFromIds(projectId, orderId) {
-   console.log("Getting path from ids:", projectId, orderId);
-   const query = 'SELECT path FROM public.measurements WHERE project_id = $1 AND order_id = $2';
-   const values = [projectId, orderId];
-   const res = await db.query(query, values);
-   return res.rows[0].path;
-}
-
-async function getPathList(IdList, projectId) {
-   // Convertir la chaîne de caractères en tableau
-   let parsedIdList;
-   try {
-      parsedIdList = JSON.parse(IdList);
-   } catch (e) {
-      console.error("Erreur lors de la conversion de la chaîne en tableau:", e);
-      return [];
-   }
-
-   console.log(parsedIdList);
-   const pathList = [];
-   for (const orderId of parsedIdList) {
-      console.log(orderId);
-      const path = await getPathFromIds(projectId, orderId);
-      console.log(path);
-      pathList.push(path);
-   }
-   return pathList;
-}
-
-
-export {
-   uploadMeasureImage,
-   addMeasureToProject,
-   getNextOrderId,
-   getMeasurements,
-   getMeasurement,
-   updateMeasurement,
-   deleteMeasurement,
-   getMeasureImage,
-   getMeasurementById,
-   updateMeasurementById,
-   getPathFromIds,
-   getPathList
-}

src/project/projectManager.js

@@ -1,82 +0,0 @@
-import storageManager from '../data/storageManager.js';
-import db from '../../db.js';
-
-function createProjectDirectory(projectId) {
-   const projectPath = `${projectId}`;
-   storageManager.createFolder(projectPath);
-   storageManager.createFolder(`${projectPath}/images`);
-   storageManager.createFolder(`${projectPath}/videos`);
-   console.log("[FILE] createProjectDirectory : " + projectPath);
-}
-
-function deleteProjectDirectory(projectId) {
-   const projectPath = `${projectId}`;
-   storageManager.deleteFolder(projectPath);
-   console.log("[FILE] deleteProjectDirectory : " + projectPath);
-}
-
-async function getAllProjects() {
-   const query = 'SELECT * FROM public.projects';
-   const res = await db.query(query);
-   //console.log("[DB] getAllProjects : ", res.rows);
-   return res.rows;
-}
-
-async function getProjectById(projectId) {
-   const query = 'SELECT * FROM public.projects WHERE id = $1';
-   const values = [projectId];
-   const res = await db.query(query, values);
-   //console.log("[DB] getProjectById : ", res.rows[0]);
-   return res.rows[0];
-}
-
-async function createProject(name, description, start_date, status) {
-   const query = 'INSERT INTO public.projects (name, description, start_date, status) VALUES ($1, $2, $3, $4) RETURNING *';
-   const values = [name, description, start_date, status];
-   const res = await db.query(query, values);
-   //console.log("[DB] createProject : ", res.rows[0]);
-   return res.rows[0];
-}
-
-async function editProjectById(projectID, name, description, startDate, status) {
-   const query = 'UPDATE public.projects SET name = $1, description = $2, start_date = $3, status = $4 WHERE id = $5 RETURNING *';
-   const values = [name, description, startDate, status, projectID];
-   const res = await db.query(query, values);
-   //console.log("[DB] editProjectById : ", res.rows[0]);
-   return res.rows[0];
-}
-
-async function deleteProjectById(projectId) {
-   const query = 'DELETE FROM public.projects WHERE id = $1';
-   const values = [projectId];
-   //console.log("[DB] deleteProjectById : ", values);
-   await db.query(query, values);
-}
-
-async function getVideosByProjectId(projectId) {
-   const query = 'SELECT * FROM public.videos WHERE project_id = $1';
-   const values = [projectId];
-   const res = await db.query(query, values);
-   //console.log("[DB] getVideosByProjectId : ", res.rows);
-   return res.rows;
-}
-
-async function getMeasurementsByProjectId(projectId) {
-   const query = 'SELECT * FROM public.measurements WHERE project_id = $1';
-   const values = [projectId];
-   const res = await db.query(query, values);
-   //console.log("[DB] getMeasurementsByProjectId : ", res.rows);
-   return res.rows;
-}
-
-export {
-   createProjectDirectory,
-   deleteProjectDirectory,
-   getAllProjects,
-   getProjectById,
-   createProject,
-   editProjectById,
-   deleteProjectById,
-   getVideosByProjectId,
-   getMeasurementsByProjectId
-};

src/video/videoManager.js

@@ -1,60 +1,11 @@
 const fs = require('fs');
 const path = require('path');
-const { execSync } = require('child_process');
-const { exec } = require('child_process');
-const util = require('util');
-const execPromise = util.promisify(exec);
 const { spawn } = require('child_process');
-let globalProgress = {};
 
-const serverError = require('../../utils/serverError');
+const database_manager = require('../database/database_manager');
-const db = require('../../db');
-const storageManager = require('../data/storageManager');
-const measureManager = require('../measure/measureManager');
 
 const PROJECTS_DIR = path.join('.');
 
-async function deleteUnfinishedVideos() {
-    // Au démarrage du backend, supprimer les vidéos inachevées (donc en status 1)
-    const unfinishedVideos = await db.query(`
-        SELECT id FROM public.videos 
-        WHERE status = 0 OR status = 2 OR status = 3
-    `);
-
-    for (const video of unfinishedVideos.rows) {
-        try {
-            await deleteVideoProject(video.id);
-            console.log(`Deleted unfinished video with id: ${video.id}`);
-        } catch (error) {
-            console.error(`Error deleting unfinished video with id: ${video.id}`, error);
-        }
-    }
-}
-
-async function cleanVideoFiles() {
-    //supprimer les fichiers vidéos qui ne sont pas associés à une vidéo de la base de données
-}
-
-deleteUnfinishedVideos();
-
-async function createVideoProject(projectId, measurementIds, name, resolution, duration) {
-   // insérer une nouvelle vidéo dans la base de données
-   const status = 0; // 0 = en cours, 1 = terminé, 2 = erreur, 3 = en cours de création
-   const query = 'INSERT INTO public.videos (project_id, measurement_ids, name, resolution, duration, status) VALUES ($1, $2, $3, $4, $5, $6) RETURNING id';
-   const values = [projectId, measurementIds, name, resolution, duration, status];
-   const res = await db.query(query, values);
-   console.log('New video created with id:', res.rows[0].id);
-   return res.rows[0].id;
-}
-
-async function deleteVideoProject(videoId) {
-   const query = 'DELETE FROM public.videos WHERE id = $1';
-   const values = [videoId];
-   const res = await db.query(query, values);
-   console.log('Video deleted:', res.rows[0]);
-   return res.rows[0];
-}
-
 async function createVideoWithList(projectId, pathList, duration, videoId, res_width, res_height) {
    const tempFile = path.join('temp.txt');
    let ffmpegProcess;
@@ -89,16 +40,14 @@ async function createVideoWithList(projectId, pathList, duration, videoId, res_w
        );
 
        // Mise à jour initiale de la base de données
-       await db.query(`
+       let edit_video = {
-           UPDATE public.videos 
+              status: 3,
-           SET 
+                progress: 0,
-               status = 3, 
+                started_at: new Date(),
-               progress = 0, 
+                updated_at: new Date(),
-               started_at = NOW(), 
+                eta: null
-               updated_at = NOW(), 
+       }
-               eta = NULL 
+       await database_manager.video.edit_video_by_id(videoId, edit_video)
-           WHERE id = $1
-       `, [videoId]);
        const scale = res_width && res_height ? `scale=${res_width}:${res_height}` : 'scale=854:480'; // Redimensionne la vidéo en 480p par défaut
 
        // Configuration de FFmpeg
@@ -138,14 +87,12 @@ async function createVideoWithList(projectId, pathList, duration, videoId, res_w
 
                // Mise à jour max toutes les 500ms
                if (now - lastUpdate > 500) {
-                   db.query(`
+                    let update_video = {
-                       UPDATE public.videos 
+                        progress: progress,
-                       SET 
+                        eta: Math.round(eta),
-                           progress = $1, 
+                        updated_at: new Date()
-                           eta = $2, 
+                    }
-                           updated_at = NOW() 
+                    database_manager.video.edit_video_by_id(videoId, update_video)
-                       WHERE id = $3
-                   `, [progress, Math.round(eta), videoId]).catch(console.error);
                    
                    console.log('Progress:', progress.toFixed(2), '%, ETA:', eta.toFixed(0), 's');
                    lastUpdate = now;
@@ -159,16 +106,24 @@ async function createVideoWithList(projectId, pathList, duration, videoId, res_w
                if (code === 0) {
                    try {
                        // Mise à jour finale
-                       await db.query(`
+                    //    await db.query(`
-                           UPDATE public.videos 
+                    //        UPDATE public.videos 
-                           SET 
+                    //        SET 
-                               status = 1, 
+                    //            status = 1, 
-                               progress = 100, 
+                    //            progress = 100, 
-                               eta = 0, 
+                    //            eta = 0, 
-                               video_file = $1, 
+                    //            video_file = $1, 
-                               updated_at = NOW() 
+                    //            updated_at = NOW() 
-                           WHERE id = $2
+                    //        WHERE id = $2
-                       `, [outputVideo, videoId]);
+                    //    `, [outputVideo, videoId]);
+                        let latest_update = {
+                            status: 1,
+                            progress: 100,
+                            eta: 0,
+                            video_file: outputVideo,
+                            updated_at: new Date()
+                        }
+                        await database_manager.video.edit_video_by_id(videoId, latest_update)
                        resolve();
                    } catch (e) {
                        reject(e);
@@ -188,15 +143,14 @@ async function createVideoWithList(projectId, pathList, duration, videoId, res_w
        console.error('Error in video creation:', error);
        
        try {
-           await db.query(`
+              // Mise à jour de la base de données en cas d'erreur
-               UPDATE public.videos 
+              let error_video = {
-               SET 
+                status: 0,
-                   status = 2, 
+                progress: 0,
-                   progress = 0, 
+                eta: null,
-                   eta = 0, 
+                updated_at: new Date()
-                   updated_at = NOW() 
+              }
-               WHERE id = $1
+              await database_manager.video.edit_video_by_id(videoId, error_video)
-           `, [videoId]);
        } catch (dbError) {
            console.error('Database update error:', dbError);
        }
@@ -217,60 +171,4 @@ async function createVideoWithList(projectId, pathList, duration, videoId, res_w
    }
 }
 
-
+module.exports = { createVideoWithList };
-async function createVideo(projectId) {
-   const tempFile = path.join('temp.txt');
-   try {
-      // Trouver tous les fichiers image pour le projet donné
-      const workdir = path.join(PROJECTS_DIR, 'storage', `${projectId}`);
-      const dir = path.join(PROJECTS_DIR, 'storage', `${projectId}`, 'images');
-      console.log('dir:', dir);
-      const images = storageManager.scanAllImages(dir);
-      console.log('images:', images);
-
-      // Trier les images numériquement
-      const sortedImages = images.sort((a, b) => {
-         const numA = parseInt(path.basename(a).match(/\d+/)[0], 10);
-         const numB = parseInt(path.basename(b).match(/\d+/)[0], 10);
-         return numA - numB;
-      });
-
-      // En déduire l'id de la première et dernière image utilisée
-      const firstImageId = parseInt(path.basename(sortedImages[0]).match(/\d+/)[0], 10);
-      const lastImageId = parseInt(path.basename(sortedImages[sortedImages.length - 1]).match(/\d+/)[0], 10);
-
-      console.log('firstImageId:', firstImageId);
-      console.log('lastImageId:', lastImageId);
-
-      // Créer un fichier temporaire pour la liste des images
-      fs.writeFileSync(tempFile, sortedImages.map(image => `file '${image}'`).join('\n'));
-
-      const frameRate = 10;
-      const outputVideo = path.join(workdir, 'video.mp4');
-
-      // Commande ffmpeg pour créer la vidéo
-      const ffmpegCommand = `ffmpeg -r ${frameRate} -f concat -safe 0 -i ${tempFile} -vsync vfr -pix_fmt yuv420p ${outputVideo}`;
-      console.log('Running ffmpeg command:', ffmpegCommand);
-      spawn(ffmpegCommand);
-      console.log('Video created successfully:', outputVideo);
-   } catch (error) {
-      console.error('Error creating video:', error);
-      serverError(error);
-   } finally {
-      // Supprimer le fichier temporaire
-      if (fs.existsSync(tempFile)) {
-         fs.unlinkSync(tempFile);
-         console.log('Temporary file deleted:', tempFile);
-      }
-   }
-}
-
-async function updateVideoFile(videoId, video_file) {
-   const query = 'UPDATE public.videos SET video_file = $2 WHERE id = $1 RETURNING *';
-   const values = [videoId, video_file];
-   const res = await db.query(query, values);
-   console.log('Video updated:', res.rows[0]);
-   return res.rows[0];
-}
-
-module.exports = { createVideo, createVideoWithList, createVideoProject, deleteVideoProject, updateVideoFile };

test/tester.js

@@ -1,4 +1,7 @@
-const path = require('path');
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
 function getSmileImage() {
    return path.join(__dirname, '../sample/smile.png');
@@ -8,5 +11,4 @@ function getCatVideo() {
    return path.join(__dirname, '../sample/cat.mp4');
 }
 
-exports.getSmileImage = getSmileImage;
+export { getSmileImage, getCatVideo };
-exports.getCatVideo = getCatVideo;