timelapse-backend/routes/measurementRoutes.js

const express = require('express');
const router = express.Router();
const db = require('../db');
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:
 *                 $ref: '#/components/schemas/Measurement'
 *       500:
 *         description: Erreur serveur.
 */
router.get('/measurements', (req, res) => {
  const query = 'SELECT * FROM public.measurements';
  db.query(query, (err, results) => {
    if (err) {
      serverError.sendError('Erreur lors de la récupération des mesures:', res, err);
    }
    res.json(results.rows);
  });
});

/**
 * @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:
 *               $ref: '#/components/schemas/Measurement'
 *       400:
 *         description: ID de mesure invalide.
 *       500:
 *         description: Erreur serveur.
 */
router.get('/measurements/:id', (req, res) => {
  const measurementId = req.params.id;
  if (!measurementId || isNaN(measurementId)) {
    return res.status(400).json({ error: 'Invalid measurement ID' });
  }
  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:
 *               $ref: '#/components/schemas/Measurement'
 *       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;
  if (!project_id || !timestamp || !image_path || !temperature || !humidity) {
    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';
  db.query(query, [project_id, timestamp, image_path, temperature, humidity], (err, results) => {
    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;
  if (!measurementId || isNaN(measurementId)) {
    return res.status(400).json({ error: 'Invalid measurement ID' });
  }
  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);
  }
});

/**
 * @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 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.deleteMeasurementByOrderId(projectId, orderId);
    res.status(200).json({ message: 'Measurement deleted successfully', id: measurement.id });
  } catch (error) {
    serverError.sendError('Error deleting measurement:', res, error);
  }
});

module.exports = router;