timelapse-backend/routes/imageRoutes.js

const express = require('express');
const router = express.Router();
const path = require('path');
const fs = require('fs');
const dbTester = require('../test/tester');
const db = require('../db');
const serverError = require('../utils/serverError');

/**
 * @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) => {
      if (err) {
         console.error('Image not found:', err);
         return res.status(404).json({ error: 'Image not found' });
      }
      res.sendFile(imagePath);
   });
});

/**
 * @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);
         }
         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);
         });
    });
});


/**
 * @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
 */
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);
        }
        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 minInterval = 3; // Minutes
const maxInterval = 60; // Minutes

var captureProjectID = -1;
var captureInterval = 0; // Minutes

/**
 * @swagger
 * /procedure/start/:
 *   post:
 *     summary: Start the capture procedure
 *     description: Starts the capture procedure with the given project ID and interval.
 *     requestBody:
 *       required: true
 *       content:
 *         application/json:
 *           schema:
 *             type: object
 *             properties:
 *               projectId:
 *                 type: integer
 *                 description: The ID of the project to start capturing.
 *               interval:
 *                 type: integer
 *                 description: The interval in minutes for the capture.
 *     responses:
 *       200:
 *         description: Capture procedure started successfully.
 *         content:
 *           application/json:
 *             schema:
 *               type: object
 *               properties:
 *                 message:
 *                   type: string
 *                   example: "Procédure de capture démarrée avec succès, projet ID: 1, interval: 10 minutes."
 *       500:
 *         description: Internal server error.
 */
router.post('/procedure/start/', async (req, res) => {
   const { projectId, interval } = req.body;
    try {
         const result = startProcedure(projectId, interval);
         res.status(200).json(result);
    } catch (err) {
         serverError(res, err);
    }
});

function startProcedure(projectId, interval) {
   console.log('Démarrage de la procédure de capture');
   captureProjectID = projectId;
   if (interval < minInterval) {
      throw new Error('L\'intervalle de capture doit être supérieur ou égal à ' + minInterval + ' minutes.');
   }
   if (interval > maxInterval) {
      throw new Error('L\'intervalle de capture doit être inférieur ou égal à ' + maxInterval + ' minutes.');
   }
   captureInterval = interval;
   console.log('Procédure de capture démarrée avec succès, projet ID: ' + projectId + ', interval: ' + interval + ' minutes.');
   return { message: 'Procédure de capture démarrée avec succès, projet ID: ' + projectId + ', interval: ' + interval + ' minutes.' };
}

/**
 * @swagger
 * /procedure/stop/:
 *   get:
 *     summary: Stop the capture procedure
 *     description: Stops the capture procedure.
 *     responses:
 *       200:
 *         description: Capture procedure stopped successfully.
 *         content:
 *           application/json:
 *             schema:
 *               type: object
 *               properties:
 *                 message:
 *                   type: string
 *                   example: "Procédure de capture arrêtée avec succès."
 *       500:
 *         description: Internal server error.
 */
router.get('/procedure/stop/', async (req, res) => {
   try {
      const result = stopProcedure();
      res.status(200).json(result);
   } catch (err) {
      serverError(res, err);
   }
});

function stopProcedure() {
   console.log('Arrêt de la procédure de capture');
   return { message: 'Procédure de capture arrêtée avec succès.' };
}

module.exports = router;