feat(database): Implement DatabaseManager for managing database structure and initialization

feat(routes): Add camera, image, measurement, project, and video routes with Swagger documentation

feat(services): Create storageService and videoService for file management and video processing

fix(errorHandler): Enhance error handling with standardized responses and database operation wrappers

src/controllers/cameraController.js

@@ -0,0 +1,152 @@
+// src/controllers/cameraController.js
+const Camera = require('../models/Camera');
+const Project = require('../models/Project');
+const { sendError, asyncHandler } = require('../utils/errorHandler');
+const config = require('../config');
+
+/**
+ * Contrôleur pour les opérations liées à la caméra
+ */
+class CameraController {
+  /**
+   * Récupère le statut actuel de la caméra
+   */
+  static getCameraStatus = asyncHandler(async (req, res) => {
+    try {
+      const settings = await Camera.getCamera();
+      
+      if (!settings) {
+        // Initialise la caméra si elle n'existe pas
+        const cameraSettings = await Camera.initializeCamera();
+        return res.json(cameraSettings);
+      }
+      
+      res.json(settings);
+    } catch (error) {
+      sendError('Erreur lors de la récupération du statut de la caméra', res, error, 500);
+    }
+  });
+
+  /**
+   * Démarre une procédure de capture
+   */
+  static startProcedure = asyncHandler(async (req, res) => {
+    const { project_id, interval, nb_images } = req.body;
+    
+    if (!interval || !nb_images) {
+      return sendError('L\'intervalle et le nombre d\'images sont requis', res, null, 400);
+    }
+    
+    try {
+      // Vérifie qu'aucune procédure n'est déjà en cours
+      const existingProject = await Project.findCurrentRenderingProject();
+      
+      if (existingProject) {
+        return sendError('Un projet est déjà en cours de capture. Veuillez l\'arrêter avant d\'en démarrer un nouveau.', res, null, 400);
+      }
+      
+      // Met à jour les paramètres de la caméra
+      const newSettings = {
+        interval: interval,
+        nb_images: nb_images,
+        stop_flag: false,
+        active: 1 // active = 1 (idle = 0)
+      };
+      
+      await Camera.updateCamera(1, newSettings);
+      
+      // Met à jour le statut du projet
+      await Project.updateProject(project_id, { status: config.status.inProgress });
+      
+      console.log(`[CAMERA] Procédure démarrée pour le projet : ${project_id}`);
+      
+      res.json({ 
+        message: 'Procédure de capture démarrée avec succès', 
+        settings: { interval, nb_images } 
+      });
+    } catch (error) {
+      sendError('Erreur lors du démarrage de la procédure de capture', res, error, 500);
+    }
+  });
+
+  /**
+   * Initie l'arrêt de la procédure de capture
+   */
+  static stopProcedure = asyncHandler(async (req, res) => {
+    try {
+      // Marque le drapeau d'arrêt
+      await Camera.updateCamera(1, { stop_flag: true });
+      
+      console.log('[CAMERA] Arrêt de la caméra demandé, en attente de confirmation...');
+      
+      res.json({ message: 'Procédure d\'arrêt de la caméra initiée avec succès' });
+    } catch (error) {
+      sendError('Erreur lors de l\'arrêt de la procédure de capture', res, error, 500);
+    }
+  });
+
+  /**
+   * Confirme l'arrêt de la caméra (appelé par la caméra)
+   */
+  static confirmStopProcedure = asyncHandler(async (req, res) => {
+    try {
+      // Réinitialise les paramètres de la caméra
+      const newSettings = {
+        interval: null,
+        nb_images: null,
+        stop_flag: false,
+        active: 0 // idle = true
+      };
+      
+      await Camera.updateCamera(1, newSettings);
+      
+      // Réinitialise le statut du projet en cours
+      const currentProject = await Project.findCurrentRenderingProject();
+      
+      if (currentProject) {
+        await Project.updateProject(currentProject.id, { status: config.status.waiting });
+        console.log(`[CAMERA] Projet : ${currentProject.id} arrêté.`);
+      } else {
+        console.log('[CAMERA] Aucun projet à arrêter.');
+      }
+      
+      console.log('[CAMERA] Caméra arrêtée.');
+      
+      res.json({ message: 'Caméra arrêtée avec succès' });
+    } catch (error) {
+      sendError('Erreur lors de la confirmation de l\'arrêt de la caméra', res, error, 500);
+    }
+  });
+
+  /**
+   * Active le mode maintenance
+   */
+  static activateMaintenance = asyncHandler(async (req, res) => {
+    try {
+      await Camera.updateCamera(1, { maintenance: 1 });
+      
+      console.log('[CAMERA] Mode maintenance activé.');
+      
+      res.json({ message: 'Caméra en mode maintenance' });
+    } catch (error) {
+      sendError('Erreur lors de l\'activation du mode maintenance', res, error, 500);
+    }
+  });
+
+  /**
+   * Désactive le mode maintenance
+   */
+  static deactivateMaintenance = asyncHandler(async (req, res) => {
+    try {
+      await Camera.updateCamera(1, { maintenance: 0 });
+      
+      console.log('[CAMERA] Mode maintenance désactivé.');
+      
+      res.json({ message: 'Caméra sortie du mode maintenance' });
+    } catch (error) {
+      sendError('Erreur lors de la désactivation du mode maintenance', res, error, 500);
+    }
+  });
+}
+
+module.exports = CameraController;