509 lines
15 KiB
JavaScript
509 lines
15 KiB
JavaScript
const express = require('express');
|
|
const router = express.Router();
|
|
const db = require('../db');
|
|
const path = require('path');
|
|
const fs = require('fs');
|
|
const ffmpeg = require('../ffmpeg');
|
|
const fileUtils = require('../utils/fileUtils');
|
|
const serverError = require('../utils/serverError');
|
|
const video = require('../utils/video');
|
|
const dbTester = require('../test/dbTester');
|
|
const cors = require('cors'); // Import the cors package
|
|
|
|
router.use(cors({
|
|
origin: 'http://127.0.0.1:5500',
|
|
methods: 'GET,POST,PUT,DELETE',
|
|
allowedHeaders: 'Content-Type',
|
|
}));
|
|
|
|
/**
|
|
* @swagger
|
|
* /projects:
|
|
* get:
|
|
* description: Use to request all projects
|
|
* responses:
|
|
* 200:
|
|
* description: A successful response
|
|
* 500:
|
|
* description: Internal server error
|
|
*/
|
|
router.get('/projects', async (req, res) => {
|
|
try {
|
|
const projects = await db.query('SELECT * FROM public.projects');
|
|
res.json(projects.rows);
|
|
} catch (error) {
|
|
serverError.sendError('Error getting projects:', res, error);
|
|
}
|
|
});
|
|
|
|
/**
|
|
* @swagger
|
|
* /projects/{id}/create-video:
|
|
* get:
|
|
* description: Create a video from images of a specific project by project id
|
|
* parameters:
|
|
* - in: path
|
|
* name: id
|
|
* required: true
|
|
* description: Numeric ID of the project to create video for.
|
|
* schema:
|
|
* type: integer
|
|
* responses:
|
|
* 200:
|
|
* description: Video created successfully
|
|
* 404:
|
|
* description: No images found for this project
|
|
* 500:
|
|
* description: Internal server error
|
|
*/
|
|
router.get('/projects/:id/create-video', async (req, res) => {
|
|
const projectId = req.params.id;
|
|
try {
|
|
const videoPath = await video.createVideo(projectId);
|
|
res.json(videoPath);
|
|
res.status(200).json({ message: 'Video created successfully', videoPath });
|
|
} catch (error) {
|
|
serverError.sendError('Error creating video:', res, error);
|
|
}
|
|
});
|
|
|
|
/**
|
|
* @swagger
|
|
* /projects/{id}:
|
|
* get:
|
|
* description: Use to request a specific project by id
|
|
* parameters:
|
|
* - in: path
|
|
* name: id
|
|
* required: true
|
|
* description: Numeric ID of the project to retrieve.
|
|
* schema:
|
|
* type: integer
|
|
* responses:
|
|
* 200:
|
|
* description: A successful response
|
|
* 500:
|
|
* description: Internal server error
|
|
*/
|
|
router.get('/projects/:id', async (req, res) => {
|
|
try {
|
|
const project = await projectModel.getProjectById(db, req.params.id);
|
|
if (!project) {
|
|
return res.status(404).json({ error: 'Projet non trouvé' });
|
|
}
|
|
res.json(project);
|
|
} catch (error) {
|
|
serverError.sendError('Erreur lors de la récupération du projet:', res, error);
|
|
}
|
|
});
|
|
|
|
/**
|
|
* @swagger
|
|
* /projects/{id}/videos:
|
|
* get:
|
|
* description: Use to request all videos for a specific project by project id
|
|
* parameters:
|
|
* - in: path
|
|
* name: id
|
|
* required: true
|
|
* description: Numeric ID of the project to retrieve videos for.
|
|
* schema:
|
|
* type: integer
|
|
* responses:
|
|
* 200:
|
|
* description: A successful response
|
|
* 500:
|
|
* description: Internal server error
|
|
*/
|
|
router.get('/projects/:id/videos', (req, res) => {
|
|
const projectId = req.params.id;
|
|
const query = 'SELECT * FROM public.videos WHERE project_id = $1';
|
|
db.query(query, [projectId], (err, results) => {
|
|
if (err) {
|
|
serverError.sendError('Erreur lors de la récupération des vidéos pour le projet:', res, err);
|
|
}
|
|
res.json(results.rows);
|
|
});
|
|
});
|
|
|
|
/**
|
|
* @swagger
|
|
* /projects/{id}/measurements:
|
|
* get:
|
|
* description: Use to request all measurements for a specific project by project id
|
|
* parameters:
|
|
* - in: path
|
|
* name: id
|
|
* required: true
|
|
* description: Numeric ID of the project to retrieve measurements for.
|
|
* schema:
|
|
* type: integer
|
|
* responses:
|
|
* 200:
|
|
* description: A successful response
|
|
* 500:
|
|
* description: Internal server error
|
|
*/
|
|
router.get('/projects/:id/measurements', (req, res) => {
|
|
const projectId = req.params.id;
|
|
const query = 'SELECT * FROM public.measurements WHERE project_id = $1';
|
|
db.query(query, [projectId], (err, results) => {
|
|
if (err) {
|
|
serverError.sendError('Erreur lors de la récupération des mesures pour le projet:', res, err);
|
|
}
|
|
res.json(results.rows);
|
|
});
|
|
});
|
|
|
|
/**
|
|
* @swagger
|
|
* /projects:
|
|
* post:
|
|
* description: Use to add a new project
|
|
* requestBody:
|
|
* required: true
|
|
* content:
|
|
* application/json:
|
|
* schema:
|
|
* type: object
|
|
* properties:
|
|
* name:
|
|
* type: string
|
|
* description:
|
|
* type: string
|
|
* responses:
|
|
* 201:
|
|
* description: Project added successfully
|
|
* 500:
|
|
* description: Internal server error
|
|
*/
|
|
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 query = `INSERT INTO public.projects (name, description, status) VALUES ('${name}', '${description}', 0) RETURNING id`;
|
|
const result = await db.query(query);
|
|
const projectId = result.rows[0].id;
|
|
|
|
fileUtils.createProjectDirectory(projectId);
|
|
res.status(201).json({ message: 'Project created successfully', projectId });
|
|
} catch (error) {
|
|
serverError.sendError('Error creating project:', res, error);
|
|
}
|
|
});
|
|
|
|
/**
|
|
* @swagger
|
|
* /projects/{id}:
|
|
* delete:
|
|
* description: Use to delete a project by ID
|
|
* parameters:
|
|
* - in: path
|
|
* name: id
|
|
* required: true
|
|
* description: Numeric ID of the project to delete.
|
|
* schema:
|
|
* type: integer
|
|
* responses:
|
|
* 200:
|
|
* description: Project deleted successfully
|
|
* 404:
|
|
* description: No project found with this ID
|
|
* 500:
|
|
* description: Internal server error
|
|
*/
|
|
router.delete('/projects/:id', async (req, res) => {
|
|
const projectId = req.params.id;
|
|
|
|
try {
|
|
const result = await db.query('DELETE FROM public.projects WHERE id = $1 RETURNING id', [projectId]);
|
|
if (result.rowCount === 0) {
|
|
return res.status(404).json({ error: 'No project found with this ID' });
|
|
}
|
|
|
|
fileUtils.deleteProjectDirectory(projectId);
|
|
res.status(200).json({ message: 'Project deleted successfully', id: projectId });
|
|
} catch (error) {
|
|
serverError.sendError('Error deleting project:', res, error);
|
|
}
|
|
});
|
|
|
|
/**
|
|
* @swagger
|
|
* /measurements:
|
|
* get:
|
|
* description: Use to request all measurements
|
|
* responses:
|
|
* 200:
|
|
* description: A successful response
|
|
* 500:
|
|
* description: Internal server error
|
|
*/
|
|
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:
|
|
* description: Use to request a specific measurement by id
|
|
* parameters:
|
|
* - in: path
|
|
* name: id
|
|
* required: true
|
|
* description: Numeric ID of the measurement to retrieve.
|
|
* schema:
|
|
* type: integer
|
|
* responses:
|
|
* 200:
|
|
* description: A successful response
|
|
* 500:
|
|
* description: Internal server error
|
|
*/
|
|
router.get('/measurements/:id', (req, res) => {
|
|
const measurementId = req.params.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:
|
|
* post:
|
|
* description: Use to add a new measurement
|
|
* responses:
|
|
* 201:
|
|
* description: Measurement added successfully
|
|
* 500:
|
|
* description: Internal server error
|
|
*/
|
|
router.post('/measurements', (req, res) => {
|
|
const query = 'INSERT INTO public.measurements (project_id, timestamp, image_path, temperature, humidity, completed) VALUES ($1, $2, $3, $4, $5, $6) RETURNING id';
|
|
db.query(query, [req.body.project_id, req.body.timestamp, req.body.image_path, req.body.temperature, req.body.humidity, req.body.completed], (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:
|
|
* description: Use to delete a measurement by ID
|
|
* parameters:
|
|
* - in: path
|
|
* name: id
|
|
* required: true
|
|
* description: Numeric ID of the measurement to delete.
|
|
* schema:
|
|
* type: integer
|
|
* responses:
|
|
* 200:
|
|
* description: Measurement deleted successfully
|
|
* 404:
|
|
* description: No measurement found with this ID
|
|
* 500:
|
|
* description: Internal server error
|
|
*/
|
|
router.delete('/measurements/:id', (req, res) => {
|
|
const measurementId = req.params.id;
|
|
const query = 'DELETE FROM public.measurements WHERE id = $1 RETURNING id';
|
|
db.query(query, [measurementId], (err, results) => {
|
|
if (err) {
|
|
serverError.sendError('Erreur lors de la suppression de la mesure:', res, err);
|
|
}
|
|
if (results.rowCount === 0) {
|
|
return res.status(404).json({ error: 'Aucune mesure trouvée avec cet ID.' });
|
|
}
|
|
res.status(200).json({ message: 'Mesure supprimée avec succès', id: measurementId });
|
|
});
|
|
});
|
|
|
|
/**
|
|
* @swagger
|
|
* /videos:
|
|
* get:
|
|
* description: Use to request all videos
|
|
* responses:
|
|
* 200:
|
|
* description: A successful response
|
|
* 500:
|
|
* description: Internal server error
|
|
*/
|
|
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);
|
|
}
|
|
res.json(results.rows);
|
|
});
|
|
});
|
|
|
|
/**
|
|
* @swagger
|
|
* /videos/{id}:
|
|
* get:
|
|
* description: Use to request a specific video by id
|
|
* parameters:
|
|
* - in: path
|
|
* name: id
|
|
* required: true
|
|
* description: Numeric ID of the video to retrieve.
|
|
* schema:
|
|
* type: integer
|
|
* responses:
|
|
* 200:
|
|
* description: A successful response
|
|
* 500:
|
|
* description: Internal server error
|
|
*/
|
|
router.get('/videos/:id', (req, res) => {
|
|
const videoId = req.params.id;
|
|
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);
|
|
}
|
|
res.json(results.rows);
|
|
});
|
|
});
|
|
|
|
/**
|
|
* @swagger
|
|
* /videos:
|
|
* post:
|
|
* description: Use to create a new video
|
|
* 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: Video created successfully
|
|
* 500:
|
|
* description: Internal server error
|
|
*/
|
|
router.post('/videos', (req, res) => {
|
|
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';
|
|
|
|
const list_ids = req.body.measurement_ids.split(',');
|
|
const image_count = list_ids.length;
|
|
const video_path = '/videos/' + req.body.name + '.mp4';
|
|
|
|
const query_first = 'SELECT timestamp FROM public.measurements WHERE id = $1';
|
|
const query_last = 'SELECT timestamp FROM public.measurements WHERE id = $1';
|
|
db.query(query_first, [list_ids[0]], (err, results) => {
|
|
if (err) {
|
|
serverError.sendError('Erreur lors de la récupération du timestamp de la première image:', res, err);
|
|
}
|
|
const start_timestamp = results.rows[0].timestamp;
|
|
|
|
db.query(query_last, [list_ids[image_count - 1]], (err, results) => {
|
|
if (err) {
|
|
serverError.sendError('Erreur lors de la récupération du timestamp de la dernière image:', res, err);
|
|
}
|
|
const end_timestamp = results.rows[0].timestamp;
|
|
const fps = image_count / req.body.duration;
|
|
|
|
db.query(query, [req.body.project_id, req.body.measurement_ids, video_path, start_timestamp, end_timestamp, image_count, req.body.resolution, req.body.duration, fps, 0, req.body.name], (err, results) => {
|
|
if (err) {
|
|
serverError.sendError('Erreur lors de l\'ajout de la vidéo:', res, err);
|
|
}
|
|
res.status(201).json({ message: 'Vidéo ajoutée avec succès', id: results.rows[0].id });
|
|
});
|
|
});
|
|
});
|
|
});
|
|
|
|
/**
|
|
* @swagger
|
|
* /videos/{id}:
|
|
* delete:
|
|
* description: Use to delete a video by ID
|
|
* parameters:
|
|
* - in: path
|
|
* name: id
|
|
* required: true
|
|
* description: Numeric ID of the video to delete.
|
|
* schema:
|
|
* type: integer
|
|
* responses:
|
|
* 200:
|
|
* description: Video deleted successfully
|
|
* 404:
|
|
* description: No video found with this ID
|
|
* 500:
|
|
* description: Internal server error
|
|
*/
|
|
router.delete('/videos/:id', (req, res) => {
|
|
const videoId = req.params.id;
|
|
const query = 'DELETE FROM public.videos WHERE id = $1 RETURNING id';
|
|
db.query(query, [videoId], (err, results) => {
|
|
if (err) {
|
|
serverError.sendError('Erreur lors de la suppression de la vidéo:', res, err);
|
|
}
|
|
if (results.rowCount === 0) {
|
|
return res.status(404).json({ error: 'Aucune vidéo trouvée avec cet ID.' });
|
|
}
|
|
res.status(200).json({ message: 'Vidéo supprimée avec succès', id: videoId });
|
|
});
|
|
});
|
|
|
|
// Test Image
|
|
/**
|
|
* @swagger
|
|
* /smile:
|
|
* get:
|
|
* description: Use to request the smile image
|
|
* responses:
|
|
* 200:
|
|
* description: A successful response
|
|
* 404:
|
|
* description: Image not found
|
|
*/
|
|
router.get('/smile', (req, res) => {
|
|
const imagePath = path.join(__dirname, '../storage/smile.jpg');
|
|
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);
|
|
});
|
|
});
|
|
|
|
module.exports = router;
|