Supprimer l'importation du gestionnaire de stockage dans le gestionnaire de vidéos

C'est pour lancer la pipeline

.gitlab-ci.yml

@@ -1,15 +0,0 @@
-stages:
-  - deploy
-
-deploy_timelapse:
-  stage: deploy
-  script:
-    - apt-get update && apt-get install -y openssh-client
-    - mkdir -p ~/.ssh
-    - chmod 700 ~/.ssh
-    - echo "$SSH_PRIVATE_KEY" > ~/.ssh/id_rsa
-    - chmod 600 ~/.ssh/id_rsa
-    - ssh-keyscan 172.17.0.1 >> ~/.ssh/known_hosts
-    - ssh kerboul@172.17.0.1 "cd /home/kerboul/scripts/timelapse && ./update_timelapse.sh"
-  only:
-    - main

Dockerfile

@@ -0,0 +1,24 @@
+# Utiliser une image de base officielle de Node.js
+FROM node:latest
+
+# Installer ffmpeg
+RUN apt-get update && apt-get install -y ffmpeg
+
+# Définir le répertoire de travail dans le conteneur
+WORKDIR /backend
+
+# Copier le fichier package.json et package-lock.json (si disponible)
+COPY package*.json ./
+
+# Installer les dépendances Node.js
+RUN npm install
+RUN npm install -g pm2
+
+# Copier le reste de l'application
+COPY . .
+
+# Exposer le port sur lequel l'application va tourner
+EXPOSE 3000
+
+# Commande pour démarrer l'application avec PM2
+CMD ["pm2-runtime", "start", "backend.config.js"]

api.js

@@ -5,8 +5,10 @@ const projectRoutes = require('./routes/projectRoutes');
 const measurementRoutes = require('./routes/measurementRoutes');
 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 database_manager = require('./src/database/database_manager');
 
 router.use(cors({
   origin: ['http://127.0.0.1:5500', 'http://localhost:5500', 'http://localhost:3000'],
@@ -20,5 +22,6 @@ router.use('/', measurementRoutes);
 router.use('/', videoRoutes);
 router.use('/', imageRoutes);
 router.use('/', uploadRoutes);
+router.use('/', cameraRoutes);
 
 module.exports = router;

backend.config.js

@@ -0,0 +1,10 @@
+module.exports = {
+  apps: [{
+    name: "backend",
+    script: "server.js",
+    out_file: "/dev/stdout",
+    error_file: "/dev/stderr",
+    log_date_format: "YYYY-MM-DD HH:mm:ss",
+    combine_logs: true, // Combine les logs stdout et stderr
+  }]
+};

db.js

@@ -1,25 +1,39 @@
 const { Client } = require('pg');
+const devlock = require('./devlock.js');
 
-const local = true;
+let dev = devlock.is_dev;
-// Connexion à la base de données PostgreSQL
+console.log('[INFO] Environment:', dev ? 'Development Local' : 'Development Remote');
-const client = new Client({
+
-  host: local ? 'mikoshi' : '172.30.0.2',
+let client = new Client({
-  port: local ? 54322 : 5432,
+  host: '192.168.192.3',
+  port: 5432,
   user: 'timelapse',
   password: 'timelapse',
   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); // Réessayer après 30 secondes
+      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
+}

docker-compose.yml

@@ -0,0 +1,29 @@
+services:
+  timelapse-api:
+    build:
+      context: .  # Chemin vers le répertoire contenant le Dockerfile
+      dockerfile: Dockerfile  # Nom du Dockerfile, par défaut c'est "Dockerfile"
+    container_name: timelapse-api
+    ports:
+      - "8053:3000"
+    volumes:
+      - /home/timelapse/backend:/backend
+      - /home/timelapse/storage:/storage
+      - node_modules:/backend/node_modules
+    environment:
+      - NODE_VERSION=22.9.0
+      - YARN_VERSION=1.22.22
+    working_dir: /backend
+    restart: always
+    networks:
+      - bridge
+      - timelapse_network
+
+networks:
+  bridge:
+    driver: bridge
+  timelapse_network:
+    driver: bridge
+
+volumes:
+  node_modules:

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": "",
@@ -16,11 +17,16 @@
     "multer": "^1.4.5-lts.1",
     "mysql2": "^3.11.3",
     "pg": "^8.13.0",
+    "range-parser": "^1.2.1",
+    "sharp": "^0.33.5",
     "swagger-jsdoc": "^6.2.8",
     "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/_swaggerRoutes.js

@@ -0,0 +1,700 @@
+// Routes SWAGGER - Documentation API
+// Documentation: https://swagger.io/docs/specification/2-0/basic-structure/
+// Les documentations sont volontairement séparées du code source pour des raisons de lisibilité et de maintenabilité.
+
+/**
+ * @swagger
+ * /projects/{id}:
+ *   delete:
+ *     summary: Supprimer un projet par son ID
+ *     description: Supprime un projet spécifique en utilisant son ID.
+ *     parameters:
+ *       - in: path
+ *         name: id
+ *         schema:
+ *           type: integer
+ *         required: true
+ *         description: ID du projet
+ *     responses:
+ *       200:
+ *         description: Projet supprimé avec succès.
+ *       400:
+ *         description: ID de projet invalide.
+ *       500:
+ *         description: Erreur serveur.
+ */
+/**
+ * @swagger
+ * /projects:
+ *   get:
+ *     summary: Récupérer tous les projets
+ *     description: Récupère tous les projets disponibles.
+ *     responses:
+ *       200:
+ *         description: Une liste de projets.
+ *         content:
+ *           application/json:
+ *             schema:
+ *               type: array
+ *               items:
+ *                 type: object
+ *       500:
+ *         description: Erreur serveur.
+ */
+/**
+ * @swagger
+ * /projects/{id}:
+ *   get:
+ *     summary: Récupérer un projet par ID
+ *     description: Récupère un projet spécifique en utilisant son ID.
+ *     parameters:
+ *       - in: path
+ *         name: id
+ *         schema:
+ *           type: integer
+ *         required: true
+ *         description: ID du projet
+ *     responses:
+ *       200:
+ *         description: Un projet.
+ *         content:
+ *           application/json:
+ *             schema:
+ *               type: object
+ *       400:
+ *         description: ID de projet invalide.
+ *       500:
+ *         description: Erreur serveur.
+ */
+/**
+ * @swagger
+ * /projects/{id}/videos:
+ *   get:
+ *     summary: Récupérer les vidéos d'un projet par ID
+ *     description: Récupère les vidéos associées à un projet spécifique en utilisant son ID.
+ *     parameters:
+ *       - in: path
+ *         name: id
+ *         schema:
+ *           type: integer
+ *         required: true
+ *         description: ID du projet
+ *     responses:
+ *       200:
+ *         description: Une liste de vidéos.
+ *         content:
+ *           application/json:
+ *             schema:
+ *               type: array
+ *               items:
+ *                 type: object
+ *       400:
+ *         description: ID de projet invalide.
+ *       500:
+ *         description: Erreur serveur.
+ */
+/**
+ * @swagger
+ * /projects/{id}/measurements:
+ *   get:
+ *     summary: Récupérer les mesures d'un projet par ID
+ *     description: Récupère les mesures associées à un projet spécifique en utilisant son ID.
+ *     parameters:
+ *       - in: path
+ *         name: id
+ *         schema:
+ *           type: integer
+ *         required: true
+ *         description: ID du projet
+ *     responses:
+ *       200:
+ *         description: Une liste de mesures.
+ *         content:
+ *           application/json:
+ *             schema:
+ *               type: array
+ *               items:
+ *                 type: object
+ *       400:
+ *         description: ID de projet invalide.
+ *       500:
+ *         description: Erreur serveur.
+ */
+/**
+ * @swagger
+ * /projects:
+ *   post:
+ *     summary: Ajouter un nouveau projet
+ *     description: Ajoute un nouveau projet à la base de données.
+ *     requestBody:
+ *       required: true
+ *       content:
+ *         application/json:
+ *           schema:
+ *             type: object
+ *             properties:
+ *               name:
+ *                 type: string
+ *               description:
+ *                 type: string
+ *     responses:
+ *       201:
+ *         description: Projet ajouté avec succès.
+ *       400:
+ *         description: Le nom et la description sont requis.
+ *       500:
+ *         description: Erreur serveur.
+ */
+
+/**
+ * @swagger
+ * /smile:
+ *   get:
+ *     summary: Retrieve a smile image
+ *     responses:
+ *       200:
+ *         description: A smile image
+ *         content:
+ *           image/jpeg:
+ *             schema:
+ *               type: string
+ *               format: binary
+ *       404:
+ *         description: Image not found
+ */
+
+/**
+ * @swagger
+ * /images/{projectId}/{orderId}:
+ *   get:
+ *     summary: Retrieve an image by project and order ID
+ *     parameters:
+ *       - in: path
+ *         name: projectId
+ *         required: true
+ *         schema:
+ *           type: string
+ *         description: The project ID
+ *       - in: path
+ *         name: orderId
+ *         required: true
+ *         schema:
+ *           type: string
+ *         description: The order ID
+ *     responses:
+ *       200:
+ *         description: An image file
+ *         content:
+ *           application/octet-stream:
+ *             schema:
+ *               type: string
+ *               format: binary
+ *       404:
+ *         description: Image not found
+ */
+/**
+ * @swagger
+ * /images/{measurementId}:
+ *   get:
+ *     summary: Retrieve an image by measurement ID
+ *     parameters:
+ *       - in: path
+ *         name: measurementId
+ *         required: true
+ *         schema:
+ *           type: string
+ *         description: The measurement ID
+ *     responses:
+ *       200:
+ *         description: An image file
+ *         content:
+ *           application/octet-stream:
+ *             schema:
+ *               type: string
+ *               format: binary
+ *       404:
+ *         description: Image not found
+ */
+/**
+ * @swagger
+ * /preview/{projectId}/{orderId}:
+ *   get:
+ *     summary: Retrieve a preview of an image by project and order ID
+ *     parameters:
+ *       - in: path
+ *         name: projectId
+ *         required: true
+ *         schema:
+ *           type: string
+ *         description: The project ID
+ *       - in: path
+ *         name: orderId
+ *         required: true
+ *         schema:
+ *           type: string
+ *         description: The order ID
+ *     responses:
+ *       200:
+ *         description: A resized preview of the image
+ *         content:
+ *           image/jpeg:
+ *             schema:
+ *               type: string
+ *               format: binary
+ *       404:
+ *         description: Image not found
+ *       500:
+ *         description: Internal Server Error
+ */
+/**
+ * @swagger
+ * /measurements:
+ *   get:
+ *     summary: Récupérer toutes les mesures
+ *     description: Récupère toutes les mesures de la base de données.
+ *     responses:
+ *       200:
+ *         description: Une liste de mesures.
+ *         content:
+ *           application/json:
+ *             schema:
+ *               type: array
+ *               items:
+ *                 type: object
+ *                 properties:
+ *                   id:
+ *                     type: integer
+ *                   project_id:
+ *                     type: integer
+ *                   timestamp:
+ *                     type: string
+ *                     format: date-time
+ *                   image_path:
+ *                     type: string
+ *                   temperature:
+ *                     type: number
+ *                   humidity:
+ *                     type: number
+ *       500:
+ *         description: Erreur serveur.
+ */
+/**
+ * @swagger
+ * /measurements/{id}:
+ *   get:
+ *     summary: Récupérer une mesure par ID
+ *     description: Récupère une mesure spécifique en utilisant son ID.
+ *     parameters:
+ *       - in: path
+ *         name: id
+ *         schema:
+ *           type: integer
+ *         required: true
+ *         description: ID de la mesure
+ *     responses:
+ *       200:
+ *         description: Une mesure.
+ *         content:
+ *           application/json:
+ *             schema:
+ *               type: object
+ *               properties:
+ *                 id:
+ *                   type: integer
+ *                 project_id:
+ *                   type: integer
+ *                 timestamp:
+ *                   type: string
+ *                   format: date-time
+ *                 image_path:
+ *                   type: string
+ *                 temperature:
+ *                   type: number
+ *                 humidity:
+ *                   type: number
+ *       400:
+ *         description: ID de mesure invalide.
+ *       500:
+ *         description: Erreur serveur.
+ */
+/**
+ * @swagger
+ * /measurements/{projectId}/{orderId}:
+ *   get:
+ *     summary: Récupérer une mesure par project ID et order ID
+ *     description: Récupère une mesure spécifique en utilisant le project ID et order ID.
+ *     parameters:
+ *       - in: path
+ *         name: projectId
+ *         schema:
+ *           type: integer
+ *         required: true
+ *         description: ID du projet
+ *       - in: path
+ *         name: orderId
+ *         schema:
+ *           type: integer
+ *         required: true
+ *         description: ID de la commande
+ *     responses:
+ *       200:
+ *         description: Une mesure.
+ *         content:
+ *           application/json:
+ *             schema:
+ *               type: object
+ *               properties:
+ *                 id:
+ *                   type: integer
+ *                 project_id:
+ *                   type: integer
+ *                 timestamp:
+ *                   type: string
+ *                   format: date-time
+ *                 image_path:
+ *                   type: string
+ *                 temperature:
+ *                   type: number
+ *                 humidity:
+ *                   type: number
+ *       400:
+ *         description: ID de projet ou de commande invalide.
+ *       500:
+ *         description: Erreur serveur.
+ */
+/**
+ * @swagger
+ * /measurements:
+ *   post:
+ *     summary: Ajouter une nouvelle mesure
+ *     description: Ajoute une nouvelle mesure à la base de données.
+ *     requestBody:
+ *       required: true
+ *       content:
+ *         application/json:
+ *           schema:
+ *             type: object
+ *             properties:
+ *               project_id:
+ *                 type: integer
+ *               timestamp:
+ *                 type: string
+ *                 format: date-time
+ *               image_path:
+ *                 type: string
+ *               temperature:
+ *                 type: number
+ *               humidity:
+ *                 type: number
+ *     responses:
+ *       201:
+ *         description: Mesure ajoutée avec succès.
+ *       400:
+ *         description: Tous les champs sont requis.
+ *       500:
+ *         description: Erreur serveur.
+ */
+/**
+ * @swagger
+ * /measurements/{id}:
+ *   delete:
+ *     summary: Supprimer une mesure par ID
+ *     description: Supprime une mesure spécifique en utilisant son ID.
+ *     parameters:
+ *       - in: path
+ *         name: id
+ *         schema:
+ *           type: integer
+ *         required: true
+ *         description: ID de la mesure
+ *     responses:
+ *       200:
+ *         description: Mesure supprimée avec succès.
+ *       400:
+ *         description: ID de mesure invalide.
+ *       500:
+ *         description: Erreur serveur.
+ */
+/**
+ * @swagger
+ * /measurements/{projectId}/{orderId}:
+ *   delete:
+ *     summary: Supprimer une mesure par project ID et order ID
+ *     description: Supprime une mesure spécifique en utilisant le project ID et order ID.
+ *     parameters:
+ *       - in: path
+ *         name: projectId
+ *         schema:
+ *           type: integer
+ *         required: true
+ *         description: ID du projet
+ *       - in: path
+ *         name: orderId
+ *         schema:
+ *           type: integer
+ *         required: true
+ *         description: ID de la commande
+ *     responses:
+ *       200:
+ *         description: Mesure supprimée avec succès.
+ *       400:
+ *         description: ID de projet ou de commande invalide.
+ *       500:
+ *         description: Erreur serveur.
+ */
+/**
+ * @swagger
+ * /uploadmeasurement:
+ *   post:
+ *     summary: Télécharger une mesure avec une image
+ *     description: Télécharge une mesure avec une image pour un projet spécifique.
+ *     requestBody:
+ *       content:
+ *         multipart/form-data:
+ *           schema:
+ *             type: object
+ *             properties:
+ *               image:
+ *                 type: string
+ *                 format: binary
+ *                 description: Fichier image à télécharger
+ *               projectId:
+ *                 type: integer
+ *                 description: ID du projet
+ *               timestamp:
+ *                 type: string
+ *                 format: date-time
+ *                 description: Horodatage de la mesure
+ *               temperature:
+ *                 type: number
+ *                 description: Température mesurée
+ *               humidity:
+ *                 type: number
+ *                 description: Humidité mesurée
+ *     responses:
+ *       200:
+ *         description: Mesure téléchargée avec succès.
+ *         content:
+ *           application/json:
+ *             schema:
+ *               type: object
+ *               properties:
+ *                 message:
+ *                   type: string
+ *                 path:
+ *                   type: string
+ *                 id:
+ *                   type: integer
+ *       400:
+ *         description: Tous les champs sont requis.
+ *       500:
+ *         description: Erreur serveur.
+ */
+/**
+ * @swagger
+ * /videos:
+ *   get:
+ *     summary: Récupérer toutes les vidéos
+ *     description: Récupère toutes les vidéos de la base de données.
+ *     responses:
+ *       200:
+ *         description: Une liste de vidéos.
+ *         content:
+ *           application/json:
+ *             schema:
+ *               type: array
+ *               items:
+ *                 type: object
+ *                 properties:
+ *                   id:
+ *                     type: integer
+ *                   project_id:
+ *                     type: integer
+ *                   measurement_ids:
+ *                     type: string
+ *                   video_path:
+ *                     type: string
+ *                   start_timestamp:
+ *                     type: string
+ *                   end_timestamp:
+ *                     type: string
+ *                   image_count:
+ *                     type: integer
+ *                   resolution:
+ *                     type: string
+ *                   duration:
+ *                     type: number
+ *                   fps:
+ *                     type: number
+ *                   status:
+ *                     type: integer
+ *                   name:
+ *                     type: string
+ *       500:
+ *         description: Erreur serveur.
+ */
+/**
+ * @swagger
+ * /videos/{id}:
+ *   get:
+ *     summary: Récupérer une vidéo par ID
+ *     description: Récupère une vidéo spécifique en utilisant son ID.
+ *     parameters:
+ *       - in: path
+ *         name: id
+ *         schema:
+ *           type: integer
+ *         required: true
+ *         description: ID de la vidéo
+ *     responses:
+ *       200:
+ *         description: Une vidéo.
+ *         content:
+ *           application/json:
+ *             schema:
+ *               type: object
+ *               properties:
+ *                 id:
+ *                   type: integer
+ *                 project_id:
+ *                   type: integer
+ *                 measurement_ids:
+ *                   type: string
+ *                 video_path:
+ *                   type: string
+ *                 start_timestamp:
+ *                   type: string
+ *                 end_timestamp:
+ *                   type: string
+ *                 image_count:
+ *                   type: integer
+ *                 resolution:
+ *                   type: string
+ *                 duration:
+ *                   type: number
+ *                 fps:
+ *                   type: number
+ *                 status:
+ *                   type: integer
+ *                 name:
+ *                   type: string
+ *       400:
+ *         description: ID de vidéo invalide.
+ *       500:
+ *         description: Erreur serveur.
+ */
+/**
+ * @swagger
+ * /videos:
+ *   post:
+ *     summary: Créer une nouvelle vidéo
+ *     description: Crée une nouvelle vidéo avec les informations fournies.
+ *     requestBody:
+ *       required: true
+ *       content:
+ *         application/json:
+ *           schema:
+ *             type: object
+ *             properties:
+ *               project_id:
+ *                 type: integer
+ *               measurement_ids:
+ *                 type: string
+ *               name:
+ *                 type: string
+ *               resolution:
+ *                 type: string
+ *               duration:
+ *                 type: number
+ *     responses:
+ *       200:
+ *         description: Vidéo créée avec succès.
+ *         content:
+ *           application/json:
+ *             schema:
+ *               type: object
+ *               properties:
+ *                 message:
+ *                   type: string
+ *                 video:
+ *                   type: object
+ *                   properties:
+ *                     project_id:
+ *                       type: integer
+ *                     measurement_ids:
+ *                       type: string
+ *                     name:
+ *                       type: string
+ *                     resolution:
+ *                       type: string
+ *                     duration:
+ *                       type: number
+ *       400:
+ *         description: Tous les champs sont requis.
+ *       500:
+ *         description: Erreur serveur.
+ */
+/**
+ * @swagger
+ * /videos/{id}:
+ *   delete:
+ *     summary: Supprimer une vidéo par ID
+ *     description: Supprime une vidéo spécifique en utilisant son ID.
+ *     parameters:
+ *       - in: path
+ *         name: id
+ *         schema:
+ *           type: integer
+ *         required: true
+ *         description: ID de la vidéo
+ *     responses:
+ *       200:
+ *         description: Vidéo supprimée avec succès.
+ *       400:
+ *         description: ID de vidéo invalide.
+ *       404:
+ *         description: Aucune vidéo trouvée avec cet ID.
+ *       500:
+ *         description: Erreur serveur.
+ */
+/**
+ * @swagger
+ * /videos/file/{video_id}:
+ *   get:
+ *     summary: Retrieve a video by video ID
+ *     parameters:
+ *       - in: path
+ *         name: video_id
+ *         required: true
+ *         schema:
+ *           type: string
+ *         description: The video ID
+ *     responses:
+ *       200:
+ *         description: A video file
+ *         content:
+ *           application/octet-stream:
+ *             schema:
+ *               type: string
+ *               format: binary
+ *       404:
+ *         description: Video not found
+ *       400:
+ *         description: Video not yet produced
+ */
+/**
+ * @swagger
+ * /cat:
+ *   get:
+ *     summary: Retrieve a cat video
+ *     responses:
+ *       200:
+ *         description: A cat video
+ *         content:
+ *           application/octet-stream:
+ *             schema:
+ *               type: string
+ *               format: binary
+ *       404:
+ *         description: Video not found
+ */

routes/cameraRoutes.js

@@ -0,0 +1,359 @@
+const express = require('express');
+const router = express.Router();
+const db = require('../db');
+const serverError = require('../utils/serverError');
+const { start } = require('repl');
+
+//const minInterval = 3; // Minutes
+//const maxInterval = 60; // Minutes
+
+var defaultCaptureInterval = 5; // minutes
+var defaultMaintenance = 0;
+var defaultActive = 0; // 0 = pas de capture, 1 = capture en cours
+
+async function initCamera() {
+   const query = 'SELECT * FROM public.camera WHERE id = $1';
+   const values = [1];
+
+   db.query(query, values, (err, result) => {
+      if (err) {
+         console.error('Erreur lors de la vérification de l\'entrée caméra:', err);
+         return;
+      }
+
+      if (result.rows.length === 0) {
+         const insertQuery = `
+            INSERT INTO public.camera (id, interval, maintenance, active)
+            VALUES ($1, $2, $3, $4)
+         `;
+         const insertValues = [1, defaultCaptureInterval, defaultMaintenance, defaultActive];
+
+         db.query(insertQuery, insertValues, (err) => {
+            if (err) {
+               console.error('Erreur lors de l\'initialisation de la caméra:', err);
+            } else {
+               console.log('Caméra initialisée avec les valeurs par défaut.');
+            }
+         });
+      } else {
+         console.log('L\'entrée caméra avec l\'ID 1 existe déjà. Aucune initialisation nécessaire.');
+      }
+   });
+}
+
+async function getCamera() {
+   // retourner l'état de la caméra
+   const query = 'SELECT * FROM public.camera WHERE id = $1';
+   const values = [1];
+
+   try {
+      const result = await db.query(query, values);
+      if (result.rows.length === 0) {
+         console.log('Aucune entrée caméra trouvée.');
+         return null;
+      } else {
+         const camera = result.rows[0];
+         console.log('État de la caméra récupéré avec succès:', camera);
+         return {
+            captureInterval: camera.interval,
+            captureProjectID: camera.active,
+            captureStatus: camera.active,
+            maintenance: camera.maintenance
+         };
+      }
+   } catch (err) {
+      console.error('Erreur lors de la récupération de l\'état de la caméra:', err);
+      throw err;
+   }
+}
+
+async function printCameraStatus() {
+   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');
+   console.log('Statut de la capture:', camera.active === 1 ? 'En cours' : 'Arrêté');
+   console.log('-----------------------------------');
+}
+
+async function isCameraOccupied() {
+   try {
+      const query = 'SELECT id FROM public.projects WHERE status = $1 LIMIT 1';
+      const values = [1];
+
+      return new Promise((resolve, reject) => {
+         db.query(query, values, (err, result) => {
+            if (err) {
+               console.error('Erreur lors de la vérification de l\'occupation de la caméra:', err);
+               reject(err);
+            } else {
+               const isOccupied = result.rows.length > 0 ? result.rows[0].id : null;
+               resolve(isOccupied);
+            }
+         });
+      });
+
+   } catch (err) {
+      console.error('Erreur inattendue lors de la vérification de l\'occupation de la caméra:', err);
+   }
+}
+
+async function getCurrentProject() {
+   try {
+   const query = 'SELECT * FROM public.projects WHERE status = $1 LIMIT 1';
+   const values = [1];
+
+   return new Promise((resolve, reject) => {
+      db.query(query, values, (err, result) => {
+         if (err) {
+            console.error('Erreur lors de la récupération du projet en cours:', err);
+            reject(err);
+         } else if (result.rows.length === 0) {
+            console.log('Aucun projet en cours trouvé.');
+            resolve(null);
+         } else {
+            const currentProject = result.rows[0];
+            console.log('Projet en cours récupéré avec succès:', currentProject);
+            resolve(currentProject);
+         }
+      });
+   });
+   } catch (err) {
+      console.error('Erreur inattendue lors de la récupération du projet en cours:', err);
+   }
+}
+
+async function resetProjectStatus() {
+   const query = 'UPDATE public.projects SET status = $1 WHERE status = $2';
+   const values = [2, 1];
+
+   db.query(query, values, (err) => {
+      if (err) {
+         console.error('Erreur lors de la réinitialisation du statut des projets:', err);
+      } else {
+         console.log('Statut des projets réinitialisé avec succès.');
+      }
+   });
+}
+
+async function activateCamera() {
+   const query = 'UPDATE public.camera SET active = $1 WHERE id = $2';
+   const values = [1, 1];
+
+   db.query(query, values, (err) => {
+      if (err) {
+         console.error('Erreur lors de l\'activation de la caméra:', err);
+      } else {
+         console.log('Caméra activée avec succès.');
+      }
+   });
+}
+
+async function deactivateCamera() {
+   const query = 'UPDATE public.camera SET active = $1 WHERE id = $2';
+   const values = [0, 1];
+
+   db.query(query, values, (err) => {
+      if (err) {
+         console.error('Erreur lors de la désactivation de la caméra:', err);
+      } else {
+         console.log('Caméra désactivée avec succès.');
+      }
+   });
+}
+
+async function changeProjectStatus(projectId, status) {
+   try {
+      const query = 'UPDATE public.projects SET status = $1 WHERE id = $2';
+      const values = [status, projectId];
+
+      await db.query(query, values);
+      console.log(`Statut du projet ID ${projectId} modifié avec succès à ${status}.`);
+   } catch (err) {
+      console.error('Une erreur inattendue s\'est produite lors de la modification du statut du projet:', err);
+   }
+}
+
+async function startup() {
+   await initCamera();
+   await printCameraStatus();
+}
+
+startup()
+   .catch(err => {
+      console.error('Erreur lors de l\'initialisation de la caméra:', err);
+   });
+
+/**
+ * @swagger
+ * /camera/status:
+ *   get:
+ *     summary: Get the current status of the camera
+ *     tags:
+ *       - Camera
+ *     responses:
+ *       200:
+ *         description: Successfully retrieved the camera status
+ *         content:
+ *           application/json:
+ *             schema:
+ *               type: object
+ *               properties:
+ *                 captureInterval:
+ *                   type: integer
+ *                   description: Capture interval in minutes
+ *                 captureProjectID:
+ *                   type: integer
+ *                   description: ID of the project currently being captured
+ *                 captureStatus:
+ *                   type: integer
+ *                   description: Capture status (0 = stopped, 1 = ongoing)
+ *                 maintenance:
+ *                   type: integer
+ *                   description: Maintenance status (0 = none, 1 = ongoing)
+ *       500:
+ *         description: Internal server error
+ */
+router.get('/camera/status', async (req, res) => {
+   try {
+      const cameraStatus = await getCamera();
+      res.status(200).json(cameraStatus);
+   } catch (err) {
+      serverError.sendError('Erreur lors de la récupération de l\'état de la caméra:', res, err, 500);
+   }
+});
+
+async function setCameraSettings(interval, maintenance) {
+   try {
+      const query = `
+         UPDATE public.camera
+         SET interval = $1, maintenance = $2
+         WHERE id = $3
+      `;
+      const values = [interval, maintenance, 1];
+
+      db.query(query, values, (err) => {
+         if (err) {
+            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;
+            //maintenance = maintenance;
+         }
+      });
+   } catch (err) {
+      console.error('Une erreur inattendue s\'est produite lors de la mise à jour des paramètres de la caméra:', err);
+   }
+}
+
+async function startProcedure(projectId, interval, maintenance) {
+   if (isNaN(projectId) || isNaN(interval) || isNaN(maintenance)) {
+      return { error: 'Invalid parameters' };
+   }
+   const cameraOccupied = await isCameraOccupied();
+   if (cameraOccupied) {
+      return { error: 'Camera is occupied by another project' };
+   } else {
+      await activateCamera();
+      await setCameraSettings(interval, maintenance);
+      await changeProjectStatus(projectId, 1); // changer le statut du projet en cours à 1 (en cours)
+      console.log('Procédure de capture démarrée avec succès.');
+      return { message: 'Capture procedure started successfully' };
+   }
+}
+
+async function stopProcedure() {
+   var project = await getCurrentProject();
+   console.log(project);
+   if (project) {
+      await resetProjectStatus(); // réinitialiser le statut du projet en cours
+      await deactivateCamera(); // désactiver la caméra
+      await changeProjectStatus(project.id, 2); // changer le statut du projet en cours à 2 (terminé)
+      console.log('Procédure de capture arrêtée avec succès.');
+      return { message: 'Capture procedure stopped successfully' };
+   } else {
+      return { error: 'No project is currently being captured' };
+   }
+}
+
+/**
+ * @swagger
+ * /procedure/start/:
+ *   post:
+ *     summary: Start the capture procedure
+ *     tags:
+ *       - Procedure
+ *     requestBody:
+ *       required: true
+ *       content:
+ *         application/json:
+ *           schema:
+ *             type: object
+ *             properties:
+ *               projectId:
+ *                 type: integer
+ *                 description: ID of the project to start capturing
+ *               interval:
+ *                 type: integer
+ *                 description: Capture interval in minutes
+ *               maintenance:
+ *                 type: integer
+ *                 description: Maintenance status (0 = none, 1 = ongoing)
+ *     responses:
+ *       200:
+ *         description: Successfully started the capture procedure
+ *         content:
+ *           application/json:
+ *             schema:
+ *               type: object
+ *               properties:
+ *                 message:
+ *                   type: string
+ *                   description: Success message
+ *                 error:
+ *                   type: string
+ *                   description: Error message, if any
+ *       500:
+ *         description: Internal server error
+ * /procedure/stop/:
+ *   post:
+ *     summary: Stop the capture procedure
+ *     tags:
+ *       - Procedure
+ *     responses:
+ *       200:
+ *         description: Successfully stopped the capture procedure
+ *         content:
+ *           application/json:
+ *             schema:
+ *               type: object
+ *               properties:
+ *                 message:
+ *                   type: string
+ *                   description: Success message
+ *                 error:
+ *                   type: string
+ *                   description: Error message, if any
+ *       500:
+ *         description: Internal server error
+ */
+router.post('/procedure/start/', async (req, res) => {
+   const { projectId, interval, maintenance } = req.body;
+    try {
+         const result = await startProcedure(projectId, interval, maintenance);
+         res.status(200).json(result);
+    } catch (err) {
+         serverError.sendError('Erreur lors du démarrage de la procédure de capture:', res, err, 500);
+    }
+});
+
+router.post('/procedure/stop/', async (req, res) => {
+   try {
+      const result = await stopProcedure();
+      res.status(200).json(result);
+   } catch (err) {
+      serverError.sendError('Erreur lors de l\'arrêt de la procédure de capture:', res, err, 500);
+   }
+});
+
+module.exports = router;

routes/imageRoutes.js

@@ -1,27 +1,11 @@
 const express = require('express');
 const router = express.Router();
-const path = require('path');
+const sharp = require('sharp');
 const fs = require('fs');
 const dbTester = require('../test/tester');
 const db = require('../db');
 const serverError = require('../utils/serverError');
 
-/**
- * @swagger
- * /smile:
- *   get:
- *     summary: Retrieve a smile image
- *     responses:
- *       200:
- *         description: A smile image
- *         content:
- *           image/jpeg:
- *             schema:
- *               type: string
- *               format: binary
- *       404:
- *         description: Image not found
- */
 router.get('/smile', (req, res) => {
    const imagePath = dbTester.getSmileImage();
    fs.access(imagePath, fs.constants.F_OK, (err) => {
@@ -33,42 +17,13 @@ router.get('/smile', (req, res) => {
    });
 });
 
-/**
- * @swagger
- * /images/{projectId}/{orderId}:
- *   get:
- *     summary: Retrieve an image by project and order ID
- *     parameters:
- *       - in: path
- *         name: projectId
- *         required: true
- *         schema:
- *           type: string
- *         description: The project ID
- *       - in: path
- *         name: orderId
- *         required: true
- *         schema:
- *           type: string
- *         description: The order ID
- *     responses:
- *       200:
- *         description: An image file
- *         content:
- *           application/octet-stream:
- *             schema:
- *               type: string
- *               format: binary
- *       404:
- *         description: Image not found
- */
 router.get('/images/:projectId/:orderId', (req, res) => {
     const projectId = req.params.projectId;
     const orderId = req.params.orderId;
     const query = 'SELECT path FROM public.measurements WHERE project_id = $1 AND order_id = $2';
     db.query(query, [projectId, orderId], (err, results) => {
          if (err) {
-             return serverError.sendError('Error getting image:', res, err);
+             return serverError.sendError('Error getting image:', res, err, 500);
          }
          if (results.rows.length === 0) {
              return res.status(404).json({ error: 'Image not found' });
@@ -84,4 +39,77 @@ router.get('/images/:projectId/:orderId', (req, res) => {
     });
 });
 
+
+router.get('/images/:measurementId', (req, res) => {
+    const measurementId = req.params.measurementId;
+    const query = 'SELECT path FROM public.measurements WHERE id = $1';
+    db.query(query, [measurementId], (err, results) => {
+        if (err) {
+            return serverError.sendError('Error getting image:', res, err, 500);
+        }
+        if (results.rows.length === 0) {
+            return res.status(404).json({ error: 'Image not found' });
+        }
+        const imagePath = results.rows[0].path;
+        fs.access(imagePath, fs.constants.F_OK, (err) => {
+            if (err) {
+                console.error('Image not found:', err);
+                return res.status(404).json({ error: 'Image not found' });
+            }
+            res.download(imagePath);
+        });
+    });
+});
+
+const getImagePath = async (projectId, orderId) => {
+    const query = 'SELECT path FROM public.measurements WHERE project_id = $1 AND order_id = $2';
+    const result = await db.query(query, [projectId, orderId]);
+    if (result.rows.length === 0) {
+        throw new Error('Image not found');
+    }
+    return result.rows[0].path;
+};
+
+const checkImageExists = (imagePath) => {
+    return new Promise((resolve, reject) => {
+        fs.access(imagePath, fs.constants.F_OK, (err) => {
+            if (err) {
+                reject(new Error('Image not found'));
+            } else {
+                resolve();
+            }
+        });
+    });
+};
+
+const resizeImage = async (imagePath) => {
+    const metadata = await sharp(imagePath).metadata();
+    const width = Math.floor(metadata.width / 7);
+    const height = Math.floor(metadata.height / 7);
+    return sharp(imagePath)
+        .resize(width, height)
+        .jpeg({ quality: 65 })
+        .toBuffer();
+};
+
+router.get('/preview/:projectId/:orderId', async (req, res) => {
+    const projectId = req.params.projectId;
+    const orderId = req.params.orderId;
+
+    try {
+        const imagePath = await getImagePath(projectId, orderId);
+        await checkImageExists(imagePath);
+        const resizedImage = await resizeImage(imagePath);
+
+        res.set('Content-Type', 'image/jpeg');
+        res.send(resizedImage);
+    } catch (err) {
+        console.error('Error getting image preview:', err);
+        if (err.message === 'Image not found') {
+            return res.status(404).json({ error: 'Image not found' });
+        }
+        return res.status(500).json({ error: 'Internal Server Error' });
+    }
+});
+
 module.exports = router;

routes/measurementRoutes.js

@@ -1,282 +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');
 
-/**
- * @swagger
- * /measurements:
- *   get:
- *     summary: Récupérer toutes les mesures
- *     description: Récupère toutes les mesures de la base de données.
- *     responses:
- *       200:
- *         description: Une liste de mesures.
- *         content:
- *           application/json:
- *             schema:
- *               type: array
- *               items:
- *                 type: object
- *                 properties:
- *                   id:
- *                     type: integer
- *                   project_id:
- *                     type: integer
- *                   timestamp:
- *                     type: string
- *                     format: date-time
- *                   image_path:
- *                     type: string
- *                   temperature:
- *                     type: number
- *                   humidity:
- *                     type: number
- *       500:
- *         description: Erreur serveur.
- */
 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);
    }
-      res.json(results.rows);
+   res.json(measurements);
-   });
 });
 
-/**
- * @swagger
- * /measurements/{id}:
- *   get:
- *     summary: Récupérer une mesure par ID
- *     description: Récupère une mesure spécifique en utilisant son ID.
- *     parameters:
- *       - in: path
- *         name: id
- *         schema:
- *           type: integer
- *         required: true
- *         description: ID de la mesure
- *     responses:
- *       200:
- *         description: Une mesure.
- *         content:
- *           application/json:
- *             schema:
- *               type: object
- *               properties:
- *                 id:
- *                   type: integer
- *                 project_id:
- *                   type: integer
- *                 timestamp:
- *                   type: string
- *                   format: date-time
- *                 image_path:
- *                   type: string
- *                 temperature:
- *                   type: number
- *                 humidity:
- *                   type: number
- *       400:
- *         description: ID de mesure invalide.
- *       500:
- *         description: Erreur serveur.
- */
 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' });
+   }
+   res.json(measurement);
+});
+
+router.get('/measurements/:projectId/:orderId', async (req, res) => {
+   const measurement = await database_manager.measurement.get_measurement_by_project_and_order_id(req.params.projectId, req.params.orderId);
+   if (!measurement) {
+      return res.status(404).json({ error: 'Measurement not found' });
    }
-   const query = 'SELECT * FROM public.measurements WHERE id = $1';
-   db.query(query, [measurementId], (err, results) => {
-      if (err) {
-         serverError.sendError('Erreur lors de la récupération de la mesure:', res, err);
-      }
-      res.json(results.rows);
-   });
-});
-
-/**
- * @swagger
- * /measurements/{projectId}/{orderId}:
- *   get:
- *     summary: Récupérer une mesure par project ID et order ID
- *     description: Récupère une mesure spécifique en utilisant le project ID et order ID.
- *     parameters:
- *       - in: path
- *         name: projectId
- *         schema:
- *           type: integer
- *         required: true
- *         description: ID du projet
- *       - in: path
- *         name: orderId
- *         schema:
- *           type: integer
- *         required: true
- *         description: ID de la commande
- *     responses:
- *       200:
- *         description: Une mesure.
- *         content:
- *           application/json:
- *             schema:
- *               type: object
- *               properties:
- *                 id:
- *                   type: integer
- *                 project_id:
- *                   type: integer
- *                 timestamp:
- *                   type: string
- *                   format: date-time
- *                 image_path:
- *                   type: string
- *                 temperature:
- *                   type: number
- *                 humidity:
- *                   type: number
- *       400:
- *         description: ID de projet ou de commande invalide.
- *       500:
- *         description: Erreur serveur.
- */
-router.get('/measurements/:projectId/:orderId', async (req, res) => {
-   const projectId = req.params.projectId;
-   const orderId = req.params.orderId;
-   if (!projectId || isNaN(projectId) || !orderId || isNaN(orderId)) {
-      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);
-   }
 });
 
-/**
- * @swagger
- * /measurements:
- *   post:
- *     summary: Ajouter une nouvelle mesure
- *     description: Ajoute une nouvelle mesure à la base de données.
- *     requestBody:
- *       required: true
- *       content:
- *         application/json:
- *           schema:
- *             type: object
- *             properties:
- *               project_id:
- *                 type: integer
- *               timestamp:
- *                 type: string
- *                 format: date-time
- *               image_path:
- *                 type: string
- *               temperature:
- *                 type: number
- *               humidity:
- *                 type: number
- *     responses:
- *       201:
- *         description: Mesure ajoutée avec succès.
- *       400:
- *         description: Tous les champs sont requis.
- *       500:
- *         description: Erreur serveur.
- */
 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);
-      }
-      res.status(201).json({ message: 'Mesure ajoutée avec succès', id: results.rows[0].id });
-   });
 });
 
-/**
- * @swagger
- * /measurements/{id}:
- *   delete:
- *     summary: Supprimer une mesure par ID
- *     description: Supprime une mesure spécifique en utilisant son ID.
- *     parameters:
- *       - in: path
- *         name: id
- *         schema:
- *           type: integer
- *         required: true
- *         description: ID de la mesure
- *     responses:
- *       200:
- *         description: Mesure supprimée avec succès.
- *       400:
- *         description: ID de mesure invalide.
- *       500:
- *         description: Erreur serveur.
- */
 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);
    }
+   res.json({ message: 'Measurement deleted successfully', id: measurement.id });
 });
 
-/**
- * @swagger
- * /measurements/{projectId}/{orderId}:
- *   delete:
- *     summary: Supprimer une mesure par project ID et order ID
- *     description: Supprime une mesure spécifique en utilisant le project ID et order ID.
- *     parameters:
- *       - in: path
- *         name: projectId
- *         schema:
- *           type: integer
- *         required: true
- *         description: ID du projet
- *       - in: path
- *         name: orderId
- *         schema:
- *           type: integer
- *         required: true
- *         description: ID de la commande
- *     responses:
- *       200:
- *         description: Mesure supprimée avec succès.
- *       400:
- *         description: ID de projet ou de commande invalide.
- *       500:
- *         description: Erreur serveur.
- */
 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);
    }
+   res.json({ message: 'Measurement deleted successfully', id: measurement.id });
 });
 
 module.exports = router;

routes/projectRoutes.js

@@ -1,224 +1,90 @@
 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');
 
-/**
- * @swagger
- * /projects:
- *   get:
- *     summary: Récupérer tous les projets
- *     description: Récupère tous les projets disponibles.
- *     responses:
- *       200:
- *         description: Une liste de projets.
- *         content:
- *           application/json:
- *             schema:
- *               type: array
- *               items:
- *                 type: object
- *       500:
- *         description: Erreur serveur.
- */
 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);
+      serverError.sendError('Error getting all projects:', res, error, 500);
    }
 });
 
-/**
- * @swagger
- * /projects/{id}:
- *   get:
- *     summary: Récupérer un projet par ID
- *     description: Récupère un projet spécifique en utilisant son ID.
- *     parameters:
- *       - in: path
- *         name: id
- *         schema:
- *           type: integer
- *         required: true
- *         description: ID du projet
- *     responses:
- *       200:
- *         description: Un projet.
- *         content:
- *           application/json:
- *             schema:
- *               type: object
- *       400:
- *         description: ID de projet invalide.
- *       500:
- *         description: Erreur serveur.
- */
 router.get('/projects/:id', async (req, res) => {
    const projectId = req.params.id;
    if (!projectId || isNaN(projectId)) {
       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);
+      serverError.sendError('Error getting project by ID:', res, error, 500);
    }
 });
 
-/**
- * @swagger
- * /projects/{id}/videos:
- *   get:
- *     summary: Récupérer les vidéos d'un projet par ID
- *     description: Récupère les vidéos associées à un projet spécifique en utilisant son ID.
- *     parameters:
- *       - in: path
- *         name: id
- *         schema:
- *           type: integer
- *         required: true
- *         description: ID du projet
- *     responses:
- *       200:
- *         description: Une liste de vidéos.
- *         content:
- *           application/json:
- *             schema:
- *               type: array
- *               items:
- *                 type: object
- *       400:
- *         description: ID de projet invalide.
- *       500:
- *         description: Erreur serveur.
- */
 router.get('/projects/:id/videos', async (req, res) => {
    const projectId = req.params.id;
    if (!projectId || isNaN(projectId)) {
       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);
+      serverError.sendError('Error getting videos by project ID:', res, error, 500);
    }
 });
 
-/**
- * @swagger
- * /projects/{id}/measurements:
- *   get:
- *     summary: Récupérer les mesures d'un projet par ID
- *     description: Récupère les mesures associées à un projet spécifique en utilisant son ID.
- *     parameters:
- *       - in: path
- *         name: id
- *         schema:
- *           type: integer
- *         required: true
- *         description: ID du projet
- *     responses:
- *       200:
- *         description: Une liste de mesures.
- *         content:
- *           application/json:
- *             schema:
- *               type: array
- *               items:
- *                 type: object
- *       400:
- *         description: ID de projet invalide.
- *       500:
- *         description: Erreur serveur.
- */
 router.get('/projects/:id/measurements', async (req, res) => {
    const projectId = req.params.id;
    if (!projectId || isNaN(projectId)) {
       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);
+      serverError.sendError('Error getting measurements by project ID:', res, error, 500);
    }
 });
 
-/**
- * @swagger
- * /projects:
- *   post:
- *     summary: Ajouter un nouveau projet
- *     description: Ajoute un nouveau projet à la base de données.
- *     requestBody:
- *       required: true
- *       content:
- *         application/json:
- *           schema:
- *             type: object
- *             properties:
- *               name:
- *                 type: string
- *               description:
- *                 type: string
- *     responses:
- *       201:
- *         description: Projet ajouté avec succès.
- *       400:
- *         description: Le nom et la description sont requis.
- *       500:
- *         description: Erreur serveur.
- */
 router.post('/projects', async (req, res) => {
    const { name, description } = req.body;
    if (!name || !description) {
       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);
+      serverError.sendError('Error creating project:', res, error, 500);
    }
 });
 
-/**
- * @swagger
- * /projects/{id}:
- *   delete:
- *     summary: Supprimer un projet par ID
- *     description: Supprime un projet spécifique en utilisant son ID.
- *     parameters:
- *       - in: path
- *         name: id
- *         schema:
- *           type: integer
- *         required: true
- *         description: ID du projet
- *     responses:
- *       200:
- *         description: Projet supprimé avec succès.
- *       400:
- *         description: ID de projet invalide.
- *       500:
- *         description: Erreur serveur.
- */
 router.delete('/projects/:id', async (req, res) => {
    const projectId = req.params.id;
    if (!projectId || isNaN(projectId)) {
       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);
+      serverError.sendError('Error deleting project:', res, error, 500);
    }
 });
 

routes/uploadRoutes.js

@@ -1,115 +1,15 @@
 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() });
 
-/**
- * @swagger
- * /upload:
- *   post:
- *     summary: Télécharger une image
- *     description: Télécharge une image pour un projet et un ordre spécifiques.
- *     requestBody:
- *       content:
- *         multipart/form-data:
- *           schema:
- *             type: object
- *             properties:
- *               image:
- *                 type: string
- *                 format: binary
- *                 description: Fichier image à télécharger
- *               projectId:
- *                 type: integer
- *                 description: ID du projet
- *               orderId:
- *                 type: integer
- *                 description: ID de la commande
- *     responses:
- *       200:
- *         description: Image téléchargée avec succès.
- *         content:
- *           application/json:
- *             schema:
- *               type: object
- *               properties:
- *                 message:
- *                   type: string
- *                 path:
- *                   type: string
- *       400:
- *         description: Tous les champs sont requis.
- *       500:
- *         description: Erreur serveur.
- */
-router.post('/upload', upload.single('image'), async (req, res) => {
-  const { projectId, orderId } = req.body;
-  const image = req.file;
-
-  if (!image || !projectId || !orderId) {
-    return res.status(400).json({ error: 'All fields are required' });
-  }
-
-  try {
-    const imagePath = await measureManager.uploadMeasureImage(image, projectId, orderId);
-    res.json({ message: 'Image uploaded successfully', path: imagePath });
-  } catch (error) {
-    serverError.sendError('Error uploading image:', res, error);
-  }
-});
-
-/**
- * @swagger
- * /uploadmeasurement:
- *   post:
- *     summary: Télécharger une mesure avec une image
- *     description: Télécharge une mesure avec une image pour un projet spécifique.
- *     requestBody:
- *       content:
- *         multipart/form-data:
- *           schema:
- *             type: object
- *             properties:
- *               image:
- *                 type: string
- *                 format: binary
- *                 description: Fichier image à télécharger
- *               projectId:
- *                 type: integer
- *                 description: ID du projet
- *               timestamp:
- *                 type: string
- *                 format: date-time
- *                 description: Horodatage de la mesure
- *               temperature:
- *                 type: number
- *                 description: Température mesurée
- *               humidity:
- *                 type: number
- *                 description: Humidité mesurée
- *     responses:
- *       200:
- *         description: Mesure téléchargée avec succès.
- *         content:
- *           application/json:
- *             schema:
- *               type: object
- *               properties:
- *                 message:
- *                   type: string
- *                 path:
- *                   type: string
- *                 id:
- *                   type: integer
- *       400:
- *         description: Tous les champs sont requis.
- *       500:
- *         description: Erreur serveur.
- */
 router.post('/uploadmeasurement', upload.single('image'), async (req, res) => {
+  //afficher le body de la requête
+  console.log(req.body);
   const { projectId, timestamp, temperature, humidity } = req.body;
   const image = req.file;
 
@@ -118,13 +18,31 @@ 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);
-    const imagePath = await measureManager.uploadMeasureImage(image, projectId, nextOrderId);
+    if (nextOrderId === null) {
-    const measurement = await measureManager.addMeasureToProject(projectId, timestamp, imagePath, temperature, humidity, nextOrderId);
+      return res.status(404).json({ error: 'Project not found' });
+    }
+
+    // Log types for debugging
+    console.log('Types:', {
+      image: typeof image,
+      projectId: typeof projectId,
+      nextOrderId: typeof nextOrderId
+    });
+
+    const imagePath = await storage_manager.measurement.upload_measurement_image(image, projectId, 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);
+    serverError.sendError('Error uploading measurement:', res, error, 500);
   }
 });
 
+
 module.exports = router;

routes/videoRoutes.js

@@ -1,112 +1,24 @@
 const express = require('express');
 const router = express.Router();
 const db = require('../db');
+const fs = require('fs');
+const rangeParser = require('range-parser');
 const serverError = require('../utils/serverError');
 const videoManager = require('../src/video/videoManager');
+const database_manager = require('../src/database/database_manager');
+const storage_manager = require('../src/data/storage_manager');
+const dbTester = require('../test/tester');
 
-/**
- * @swagger
- * /videos:
- *   get:
- *     summary: Récupérer toutes les vidéos
- *     description: Récupère toutes les vidéos de la base de données.
- *     responses:
- *       200:
- *         description: Une liste de vidéos.
- *         content:
- *           application/json:
- *             schema:
- *               type: array
- *               items:
- *                 type: object
- *                 properties:
- *                   id:
- *                     type: integer
- *                   project_id:
- *                     type: integer
- *                   measurement_ids:
- *                     type: string
- *                   video_path:
- *                     type: string
- *                   start_timestamp:
- *                     type: string
- *                   end_timestamp:
- *                     type: string
- *                   image_count:
- *                     type: integer
- *                   resolution:
- *                     type: string
- *                   duration:
- *                     type: number
- *                   fps:
- *                     type: number
- *                   status:
- *                     type: integer
- *                   name:
- *                     type: string
- *       500:
- *         description: Erreur serveur.
- */
 router.get('/videos', (req, res) => {
    const query = 'SELECT * FROM public.videos';
    db.query(query, (err, results) => {
       if (err) {
-         serverError.sendError('Erreur lors de la récupération des vidéos:', res, err);
+         serverError.sendError('Erreur lors de la récupération des vidéos:', res, err, 500);
       }
       res.json(results.rows);
    });
 });
 
-/**
- * @swagger
- * /videos/{id}:
- *   get:
- *     summary: Récupérer une vidéo par ID
- *     description: Récupère une vidéo spécifique en utilisant son ID.
- *     parameters:
- *       - in: path
- *         name: id
- *         schema:
- *           type: integer
- *         required: true
- *         description: ID de la vidéo
- *     responses:
- *       200:
- *         description: Une vidéo.
- *         content:
- *           application/json:
- *             schema:
- *               type: object
- *               properties:
- *                 id:
- *                   type: integer
- *                 project_id:
- *                   type: integer
- *                 measurement_ids:
- *                   type: string
- *                 video_path:
- *                   type: string
- *                 start_timestamp:
- *                   type: string
- *                 end_timestamp:
- *                   type: string
- *                 image_count:
- *                   type: integer
- *                 resolution:
- *                   type: string
- *                 duration:
- *                   type: number
- *                 fps:
- *                   type: number
- *                 status:
- *                   type: integer
- *                 name:
- *                   type: string
- *       400:
- *         description: ID de vidéo invalide.
- *       500:
- *         description: Erreur serveur.
- */
 router.get('/videos/:id', (req, res) => {
    const videoId = req.params.id;
    if (!videoId || isNaN(videoId)) {
@@ -115,119 +27,229 @@ router.get('/videos/:id', (req, res) => {
    const query = 'SELECT * FROM public.videos WHERE id = $1';
    db.query(query, [videoId], (err, results) => {
       if (err) {
-         serverError.sendError('Erreur lors de la récupération de la vidéo:', res, err);
+         serverError.sendError('Erreur lors de la récupération de la vidéo:', res, err, 500);
       }
       res.json(results.rows);
    });
 });
 
-/**
+router.post('/videos', async (req, res) => {
- * @swagger
+   const { project_id, measurement_ids, name, resolution, duration } = req.body;
- * /videos:
+   console.log('Creating video:', req.body);
- *   post:
+   if (!project_id || !measurement_ids || !name || !resolution || !duration) {
- *     summary: Ajouter une nouvelle vidéo
+      return res.status(400).json({ error: 'Tous les champs sont requis.' });
- *     description: Ajoute une nouvelle vidéo à la base de données.
- *     requestBody:
- *       required: true
- *       content:
- *         application/json:
- *           schema:
- *             type: object
- *             properties:
- *               project_id:
- *                 type: integer
- *               measurement_ids:
- *                 type: string
- *               video_path:
- *                 type: string
- *               duration:
- *                 type: number
- *               resolution:
- *                 type: string
- *               name:
- *                 type: string
- *     responses:
- *       201:
- *         description: Vidéo ajoutée avec succès.
- *       400:
- *         description: Tous les champs sont requis.
- *       500:
- *         description: Erreur serveur.
- */
-router.post('/videos', (req, res) => {
-   const { project_id, measurement_ids, video_path, duration, resolution, name } = req.body;
-   if (!project_id || !measurement_ids || !video_path || !duration || !resolution || !name) {
-      return res.status(400).json({ error: 'All fields are required' });
    }
 
-   const list_ids = measurement_ids.split(',');
+   console.log('Creating video with measurements:', measurement_ids);
-   const image_count = list_ids.length;
-   const videoPath = '/videos/' + name + '.mp4';
 
-   const query_first = 'SELECT timestamp FROM public.measurements WHERE id = $1';
+   try {
-   const query_last = 'SELECT timestamp FROM public.measurements WHERE id = $1';
+      const videoId = await videoManager.createVideoProject(project_id, measurement_ids, name, resolution, duration);
       
-   db.query(query_first, [list_ids[0]], (err, results) => {
+      // Start rendering the video immediately after creation
-      if (err) {
+      const result = await db.query(
-         serverError.sendError('Erreur lors de la récupération du timestamp de la première image:', res, err);
+         'SELECT measurement_ids, project_id, duration FROM public.videos WHERE id = $1',
+         [videoId]
+      );
+
+      if (result.rows.length === 0) {
+         return res.status(404).json({ error: 'Vidéo non trouvée' });
       }
-      const start_timestamp = results.rows[0].timestamp;
 
-      db.query(query_last, [list_ids[image_count - 1]], (err, results) => {
+      const { duration: videoDuration, measurement_ids: videoMeasurementIds, project_id: videoProjectId } = result.rows[0];
-         if (err) {
+      const pathList = await storage_manager.measurement.get_path_list(videoMeasurementIds, project_id);
-            serverError.sendError('Erreur lors de la récupération du timestamp de la dernière image:', res, err);
+      if (!pathList || pathList.length === 0) {
+         return res.status(404).json({ error: 'Aucun chemin trouvé pour les mesures' });
       }
-         const end_timestamp = results.rows[0].timestamp;
-         const fps = image_count / duration;
       
-         const query = 'INSERT INTO public.videos (project_id, measurement_ids, video_path, start_timestamp, end_timestamp, image_count, resolution, duration, fps, status, name) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11) RETURNING id';
+      // parser la résolution (ex: 1920x1080)
-         db.query(query, [project_id, measurement_ids, videoPath, start_timestamp, end_timestamp, image_count, resolution, duration, fps, 0, name], (err, results) => {
+      const [res_width, res_height] = resolution.split('x').map(Number);
-            if (err) {
+      if (isNaN(res_width) || isNaN(res_height)) {
-               serverError.sendError('Erreur lors de l\'ajout de la vidéo:', res, err);
+         return res.status(400).json({ error: 'Invalid resolution format. Use WIDTHxHEIGHT (e.g., 1920x1080)' });
       }
-            res.status(201).json({ message: 'Vidéo ajoutée avec succès', id: results.rows[0].id });
+
-         });
+      // Start background processing
-      });
+      videoManager.createVideoWithList(videoProjectId, pathList, videoDuration, videoId, res_width, res_height)
-   });
+         .then(videoFile => {
+            console.log('Rendu vidéo terminé:', videoFile);
+            return database_manager.video.update_video_file_path_by_id(videoId, videoFile);
+         })
+         .catch(error => {
+            console.error('Échec du rendu vidéo:', error);
          });
 
-/**
+      // Immediate response
- * @swagger
+      res.json({
- * /videos/{id}:
+         message: 'Vidéo créée avec succès et le rendu a démarré',
- *   delete:
+         id: videoId
- *     summary: Supprimer une vidéo par ID
+      });
- *     description: Supprime une vidéo spécifique en utilisant son ID.
+
- *     parameters:
+   } catch (err) {
- *       - in: path
+      console.error('Erreur lors de la création de la vidéo:', err);
- *         name: id
+      res.status(500).json({ error: 'Erreur lors de la création de la vidéo' });
- *         schema:
+   }
- *           type: integer
+});
- *         required: true
+
- *         description: ID de la vidéo
+
- *     responses:
- *       200:
- *         description: Vidéo supprimée avec succès.
- *       400:
- *         description: ID de vidéo invalide.
- *       404:
- *         description: Aucune vidéo trouvée avec cet ID.
- *       500:
- *         description: Erreur serveur.
- */
 router.delete('/videos/:id', (req, res) => {
    const videoId = req.params.id;
    if (!videoId || isNaN(videoId)) {
       return res.status(400).json({ error: 'Invalid video ID' });
    }
-   const query = 'DELETE FROM public.videos WHERE id = $1 RETURNING id';
+
+   const query = 'SELECT video_file FROM public.videos WHERE id = $1';
    db.query(query, [videoId], (err, results) => {
       if (err) {
-         serverError.sendError('Erreur lors de la suppression de la vidéo:', res, err);
+         return serverError.sendError('Error getting video:', res, err, 500);
       }
-      if (results.rowCount === 0) {
+      if (results.rows.length === 0) {
-         return res.status(404).json({ error: 'Aucune vidéo trouvée avec cet ID.' });
+         return res.status(404).json({ error: 'Video not found' });
       }
-      res.status(200).json({ message: 'Vidéo supprimée avec succès', id: videoId });
+
+      const videoFile = results.rows[0].video_file;
+      console.log('Deleting video file:', videoFile);
+
+      if(videoFile==null){
+         console.log('No video file to delete');
+         videoManager.deleteVideoProject(videoId).then(() => {
+            res.json({ message: 'Vidéo supprimée avec succès' });
+         }).catch(err => {
+            console.error('Erreur lors de la suppression de la vidéo:', err);
+            res.status(500).json({ error: 'Erreur lors de la suppression de la vidéo' });
+         });
+      } else {
+         fs.unlink(videoFile, (err) => {
+            if (err) {
+               console.error('Error deleting video file:', err);
+               return res.status(500).json({ error: 'Error deleting video file' });
+            }
+
+            videoManager.deleteVideoProject(videoId).then(() => {
+               res.json({ message: 'Vidéo supprimée avec succès' });
+            }).catch(err => {
+               console.error('Erreur lors de la suppression de la vidéo:', err);
+               res.status(500).json({ error: 'Erreur lors de la suppression de la vidéo' });
+            });
+         });
+      }
+   });
+});
+
+router.get('/videos/file/:video_id', (req, res) => {
+   const videoId = req.params.video_id;
+   const query = 'SELECT video_file, status FROM public.videos WHERE id = $1';
+
+   db.query(query, [videoId], (err, results) => {
+      if (err) {
+         console.error('Error getting video:', err);
+         return serveFallbackVideo(res);
+      }
+      if (results.rows.length === 0) {
+         console.error('Video not found');
+         return serveFallbackVideo(res);
+      }
+
+      const video = results.rows[0];
+      if (video.status === 0) {
+         return res.status(400).json({ error: 'Video not yet produced' });
+      }
+
+      let videoPath = video.video_file;
+
+      if (!videoPath) {
+         console.error('Video file path is null or undefined');
+         videoPath = dbTester.getCatVideo();
+      }
+
+      // Check if the video file exists
+      fs.access(videoPath, fs.constants.F_OK, (err) => {
+         if (err) {
+            console.error('Video file not found:', err);
+            videoPath = dbTester.getCatVideo();
+         }
+
+         const stat = fs.statSync(videoPath);
+         const fileSize = stat.size;
+         const range = req.headers.range;
+
+         if (range) {
+            const parts = rangeParser(fileSize, range);
+            const start = parts[0].start;
+            const end = parts[0].end;
+            const chunksize = (end - start) + 1;
+            const file = fs.createReadStream(videoPath, { start, end });
+            const head = {
+               'Content-Range': `bytes ${start}-${end}/${fileSize}`,
+               'Accept-Ranges': 'bytes',
+               'Content-Length': chunksize,
+               'Content-Type': 'video/mp4',
+            };
+            res.writeHead(206, head);
+            file.pipe(res);
+         } else {
+            const head = {
+               'Content-Length': fileSize,
+               'Content-Type': 'video/mp4',
+            };
+            res.writeHead(200, head);
+            fs.createReadStream(videoPath).pipe(res);
+         }
+      });
+   });
+});
+
+function serveFallbackVideo() {
+   return dbTester.getCatVideo();
+}
+
+router.get('/videos/progress/:video_id', async (req, res) => {
+   try {
+       const result = await db.query(`
+           SELECT 
+               progress, 
+               EXTRACT(EPOCH FROM (NOW() - started_at)) as elapsed,
+               eta,
+               status
+           FROM public.videos 
+           WHERE id = $1
+       `, [req.params.video_id]);
+
+       if (result.rows.length === 0) {
+           return res.status(404).json({ error: 'Vidéo non trouvée' });
+       }
+
+       const video = result.rows[0];
+       res.json({
+           progress: video.progress,
+           elapsed: video.elapsed,
+           eta: video.eta,
+           status: this.getStatusLabel(video.status)
+       });
+
+   } catch (error) {
+       console.error(error);
+       res.status(500).json({ error: 'Erreur de récupération' });
+   }
+});
+
+// function getStatusLabel(status) {
+//    const statusMap = {
+//        0: 'En attente',
+//        1: 'Terminé',
+//        2: 'Échec',
+//        3: 'En cours'
+//    };
+//    return statusMap[status] || 'Inconnu';
+// }
+
+
+router.get('/cat', (_, res) => {
+   const videoPath = dbTester.getCatVideo();
+   fs.access(videoPath, fs.constants.F_OK, (err) => {
+      if (err) {
+         console.error('Video not found:', err);
+         return res.status(404).json({ error: 'Video not found' });
+      }
+      res.download(videoPath);
    });
 });
 

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,18 +1,14 @@
-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;
 
 async function checkAndRemoveInvalidEntries() {
    localCounter = 0;
-   console.log('[INFO] Vérification et suppression des entrées invalides...');
    try {
       const measurementsRes = await db.query('SELECT id, path FROM measurements');
-      //console.log('Fetched measurements:', measurementsRes.rows);
       for (const row of measurementsRes.rows) {
-         //console.log('Checking file path:', row.path);
          if (!fs.existsSync(row.path)) {
             await db.query('DELETE FROM measurements WHERE id = $1', [row.id]);
             console.log(`Deleted invalid measurement entry with id: ${row.id}`);
@@ -20,22 +16,18 @@ 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) {
-            // Remove the file if the entry does not exist
             fs.unlinkSync(imagePath);
             console.log(`Deleted file at path: ${imagePath} as its database entry does not exist`);
-            localCounter++; // Increment counter if entry is deleted
+            localCounter++;
          }
       }
       if (localCounter > 0) {
          console.log(`[INFO] ${localCounter} entrées ont été modifiées`);
-      } else {
+         localCounter = 0; // Reset the counter after logging
-         console.log('[INFO] Aucune entrée n\'a été modifiée.');
       }
    } 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,97 +0,0 @@
-import db from '../../db.js';
-import path from 'path';
-import storageManager from '../data/storageManager.js';
-
-async function uploadMeasureImage(image, projectId, orderId) {
-   const projectDir = storageManager.createFolder('./storage/' + projectId.toString());
-   const imagesDir = storageManager.createFolder(path.join(projectDir, 'images'));
-   var imagePath = path.join(imagesDir, `${orderId}.jpg`);
-   storageManager.saveFile(imagePath, image.buffer);
-   console.log("[FILE] uploadMeasureImage - Image saved to: " + imagePath);
-   return imagePath;
-}
-
-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) {
-   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;
-}
-
-export {
-   uploadMeasureImage,
-   addMeasureToProject,
-   getNextOrderId,
-   getMeasurements,
-   getMeasurement,
-   updateMeasurement,
-   deleteMeasurement,
-   getMeasureImage,
-   getMeasurementById,
-   updateMeasurementById,
-   getPathFromIds
-}

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,111 +1,174 @@
 const fs = require('fs');
 const path = require('path');
-const { execSync } = require('child_process');
+const { spawn } = require('child_process');
 
-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 createVideoWithList(projectId, pathList) {
+async function createVideoWithList(projectId, pathList, duration, videoId, res_width, res_height) {
-   //pathList étant la liste des chemins déjà triés
    const tempFile = path.join('temp.txt');
-   try {
+   let ffmpegProcess;
-      // Trouver tous les fichiers image pour le projet donné
+   let cleanupDone = false;
-      const workdir = path.join(PROJECTS_DIR, 'storage', `${projectId}`);
-      const dir = path.join(PROJECTS_DIR, 'storage', `${projectId}`, 'images');
-      console.log('dir:', dir);
-      const images = pathList;
-      console.log('images:', images);
 
-      // Trier les images numériquement
+   try {
-      const sortedImages = images.sort((a, b) => {
+       // Configuration des chemins
+       const workdir = path.join(PROJECTS_DIR, 'storage', projectId.toString());
+       if (!fs.existsSync(workdir)) {
+           fs.mkdirSync(workdir, { recursive: true });
+       }
+
+       // Tri des images
+       const sortedImages = pathList.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
+       // Création du fichier temporaire
-      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;
+       // Calcul des paramètres vidéo
+       const totalFrames = sortedImages.length;
+       const frameRate = Math.ceil(totalFrames / parseInt(duration));
+       const timestamp = Date.now();
+       const firstImageId = path.basename(sortedImages[0]).match(/\d+/)[0];
+       const lastImageId = path.basename(sortedImages[sortedImages.length - 1]).match(/\d+/)[0];
+       const outputVideo = path.join(
+           workdir,
+           `${projectId}_${firstImageId}_${lastImageId}-${timestamp}.mp4`
+       );
 
-      // le fichier final prend cette forme : {projectId}_{firstImageId}_{lastImageId}-{timestamp}.mp4
+       // Mise à jour initiale de la base de données
-      const timestamp = new Date().getTime();
+       let edit_video = {
-      const outputVideo = path.join(workdir, `${projectId}_${firstImageId}_${lastImageId}-${timestamp}.mp4`);
+              status: 3,
+                progress: 0,
+                started_at: new Date(),
+                updated_at: new Date(),
+                eta: null
+       }
+       await database_manager.video.edit_video_by_id(videoId, edit_video)
+       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
+       const ffmpegArgs = [
+           '-y',
+           '-r', frameRate.toString(),
+           '-f', 'concat',
+           '-safe', '0',
+           '-i', tempFile,
+           '-vsync', 'vfr',
+           '-pix_fmt', 'yuv420p',
+           '-vf', scale,
+           '-b:v', '1500k', // Force un bitrate vidéo de 1500 kbps (ajuste si nécessaire)
+           outputVideo
+       ];
+
+       ffmpegProcess = spawn('ffmpeg', ffmpegArgs, { 
+           stdio: ['ignore', 'ignore', 'pipe'] 
+       });
+
+       let lastUpdate = 0;
+       const startTime = Date.now();
+
+       // Écoute de la sortie d'erreur pour la progression
+       ffmpegProcess.stderr.on('data', (data) => {
+           const output = data.toString();
+           const frameMatch = output.match(/frame=\s*(\d+)/);
+           
+           if (frameMatch) {
+               const currentFrame = parseInt(frameMatch[1], 10);
+               const progress = Math.min((currentFrame / totalFrames) * 100, 99.99);
+               const now = Date.now();
+               
+               // Calcul de l'ETA
+               const elapsedSeconds = (now - startTime) / 1000;
+               const eta = elapsedSeconds / (currentFrame / totalFrames) - elapsedSeconds;
+
+               // Mise à jour max toutes les 500ms
+               if (now - lastUpdate > 500) {
+                    let update_video = {
+                        progress: progress,
+                        eta: Math.round(eta),
+                        updated_at: new Date()
+                    }
+                    database_manager.video.edit_video_by_id(videoId, update_video)
+                   
+                   console.log('Progress:', progress.toFixed(2), '%, ETA:', eta.toFixed(0), 's');
+                   lastUpdate = now;
+               }
+           }
+       });
+
+       // Attente de la fin du processus
+       await new Promise((resolve, reject) => {
+           ffmpegProcess.on('close', async (code) => {
+               if (code === 0) {
+                   try {
+                       // Mise à jour finale
+                    //    await db.query(`
+                    //        UPDATE public.videos 
+                    //        SET 
+                    //            status = 1, 
+                    //            progress = 100, 
+                    //            eta = 0, 
+                    //            video_file = $1, 
+                    //            updated_at = NOW() 
+                    //        WHERE id = $2
+                    //    `, [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);
+                   }
+               } else {
+                   reject(new Error(`FFmpeg process exited with code ${code}`));
+               }
+           });
+
+           ffmpegProcess.on('error', reject);
+       });
 
-      // 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);
-      execSync(ffmpegCommand);
-      console.log('Video created successfully:', outputVideo);
        return 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 createVideo(projectId) {
+   } catch (error) {
-   const tempFile = path.join('temp.txt');
+       // Gestion des erreurs
+       console.error('Error in video creation:', error);
+       
        try {
-      // Trouver tous les fichiers image pour le projet donné
+              // Mise à jour de la base de données en cas d'erreur
-      const workdir = path.join(PROJECTS_DIR, 'storage', `${projectId}`);
+              let error_video = {
-      const dir = path.join(PROJECTS_DIR, 'storage', `${projectId}`, 'images');
+                status: 0,
-      console.log('dir:', dir);
+                progress: 0,
-      const images = storageManager.scanAllImages(dir);
+                eta: null,
-      console.log('images:', images);
+                updated_at: new Date()
+              }
+              await database_manager.video.edit_video_by_id(videoId, error_video)
+       } catch (dbError) {
+           console.error('Database update error:', dbError);
+       }
        
-      // Trier les images numériquement
+       throw error;
-      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);
-      execSync(ffmpegCommand);
-      console.log('Video created successfully:', outputVideo);
-   } catch (error) {
-      console.error('Error creating video:', error);
-      serverError(error);
    } finally {
-      // Supprimer le fichier temporaire
+       // Nettoyage
-      if (fs.existsSync(tempFile)) {
+       if (!cleanupDone) {
+           if (tempFile && fs.existsSync(tempFile)) {
                fs.unlinkSync(tempFile);
-         console.log('Temporary file deleted:', tempFile);
+           }
+           if (ffmpegProcess) {
+               ffmpegProcess.kill();
+           }
+           cleanupDone = true;
        }
    }
 }
 
-module.exports = { createVideo, createVideoWithList };
+module.exports = { createVideoWithList };

stuff.md

@@ -27,3 +27,4 @@ Routes :
 
 - /data/image/:id = image depuis le pool de stockage
 - /data/video/:id = vidéo depuis le pool de stockage
+- 

test/tester.js

@@ -1,51 +1,14 @@
-const storageManager = require('../src/data/storageManager');
+import path from 'path';
-const videoManager = require('../src/video/videoManager');
+import { fileURLToPath } from 'url';
-const measureManager = require('../src/measure/measureManager');
-const path = require('path');
 
-// console.log('Testing database functions...');
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
-
-try {
-   storageManager.createFolder('test_folder');
-   console.log('1 - Folder created');
-   storageManager.deleteFolder('test_folder');
-   console.log('2 - Folder deleted');
-} catch (error) {
-   console.error('Error testing database functions:', error);
-}
 
 function getSmileImage() {
    return path.join(__dirname, '../sample/smile.png');
 }
 
-//test de lancement d'une création de vidéo sur le projet 1
+function getCatVideo() {
-// videoManager.createVideo(1).then(res => {
+   return path.join(__dirname, '../sample/cat.mp4');
-//    console.log('3 - Video created:', res);
+}
-// }).catch(err => {
-//    console.error('Error creating video:', err);
-// });
-// async function run() {
-//    var Path = await measureManager.getPathFromIds(1, 1);
-//    console.log(Path);
-// }
 
-// run().catch(err => {
+export { getSmileImage, getCatVideo };
-//    console.error('Error:', err);
-// });
-
-var pathList = [
-   'storage/1/images/1.jpg',
-   'storage/1/images/10.jpg',
-   'storage/1/images/20.jpg',
-   'storage/1/images/30.jpg',
-];
-videoManager.createVideoWithList(1, pathList).then(res => {
-   console.log('3 - Video created:', res);
-   return storageManager.deleteFile(res);
-}).then(res => {
-   console.log('4 - Video deleted:', res);
-}).catch(err => {
-   console.error('Error:', err);
-});
-
-exports.getSmileImage = getSmileImage;

utils/serverError.js

@@ -1,6 +1,12 @@
-function sendError(comment, res, err) {
+function sendError(comment, res = { status: () => ({ json: () => {} }) }, err = null, code = 500) {
    console.error(comment, err);
-   res.status(500).send('Server error');
+   res.status(code).json({
+      error: {
+         message: comment,
+         code: code,
+         error: err
+      }
+   });
 }
 
 module.exports = {