timelapse/timelapse-backend
4
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Ajout de la gestion des vidéos inachevées et mise à jour des fonctions de création et de mise à jour des vidéos dans le gestionnaire de base de données.

Browse Source
This commit is contained in:
Kerboul
2025-04-03 11:27:11 +02:00
parent 6077dfd716
commit 03ec179590
4 changed files with 88 additions and 142 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
routes/videoRoutes.js
View File

@@ -5,6 +5,7 @@ const fs = require('fs');
const rangeParser = require('range-parser'); const rangeParser = require('range-parser');
const serverError = require('../utils/serverError'); const serverError = require('../utils/serverError');
const videoManager = require('../src/video/videoManager'); const videoManager = require('../src/video/videoManager');
const database_manager = require('../src/database/database_manager');
const storage_manager = require('../src/data/storage_manager'); const storage_manager = require('../src/data/storage_manager');
const dbTester = require('../test/tester'); const dbTester = require('../test/tester');
@@ -70,7 +71,7 @@ router.post('/videos', async (req, res) => {
videoManager.createVideoWithList(videoProjectId, pathList, videoDuration, videoId, res_width, res_height) videoManager.createVideoWithList(videoProjectId, pathList, videoDuration, videoId, res_width, res_height)
.then(videoFile => { .then(videoFile => {
console.log('Rendu vidéo terminé:', videoFile); console.log('Rendu vidéo terminé:', videoFile);
return videoManager.updateVideoFile(videoId, videoFile); return database_manager.video.update_video_file_path_by_id(videoId, videoFile);
}) })
.catch(error => { .catch(error => {
console.error('Échec du rendu vidéo:', error); console.error('Échec du rendu vidéo:', error);

20
src/data/storage_manager.js
View File

@@ -160,6 +160,26 @@ const video = {
const videoPath = `${projectPath}/videos/${orderId}.mp4`; const videoPath = `${projectPath}/videos/${orderId}.mp4`;
console.log("[FILE] get_video : " + videoPath); console.log("[FILE] get_video : " + videoPath);
return await handleFileOperation(getFile, 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);
}
}
} }
} }

28
src/database/database_manager.js
View File

@@ -215,28 +215,46 @@ const video = {
const query = `SELECT * FROM videos;`; const query = `SELECT * FROM videos;`;
return (await db.query(query)).rows; return (await db.query(query)).rows;
}), }),
get_video_by_id: handleDatabaseOperation(async (id) => { get_video_by_id: handleDatabaseOperation(async (id) => {
const query = `SELECT * FROM videos WHERE id = $1;`; const query = `SELECT * FROM videos WHERE id = $1;`;
return (await db.query(query, [id])).rows[0]; return (await db.query(query, [id])).rows[0];
}), }),
get_videos_by_project_id: handleDatabaseOperation(async (project_id) => { get_videos_by_project_id: handleDatabaseOperation(async (project_id) => {
const query = `SELECT * FROM videos WHERE project_id = $1;`; const query = `SELECT * FROM videos WHERE project_id = $1;`;
return (await db.query(query, [project_id])).rows; return (await db.query(query, [project_id])).rows;
}), }),
create_video: handleDatabaseOperation(async (project_id, measurement_ids, video_file, resolution, duration, status, name, progress, started_at, updated_at, eta) => {
const query = `INSERT INTO videos (project_id, measurement_ids, video_file, resolution, duration, status, name, progress, started_at, updated_at, eta) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11) RETURNING *;`; create_video: handleDatabaseOperation(async (projectId, measurementIds, name, resolution, duration, status = 0) => {
return (await db.query(query, [project_id, measurement_ids, video_file, resolution, duration, status, name, progress, started_at, updated_at, eta])).rows[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) => { edit_video_by_id: handleDatabaseOperation(async (id, updates) => {
const fields = Object.keys(updates).map((key, index) => `${key} = $${index + 2}`).join(', '); const fields = Object.keys(updates).map((key, index) => `${key} = $${index + 2}`).join(', ');
const values = [id, ...Object.values(updates)]; const values = [id, ...Object.values(updates)];
const query = `UPDATE videos SET ${fields} WHERE id = $1 RETURNING *;`; const query = `UPDATE videos SET ${fields} WHERE id = $1 RETURNING *;`;
return (await db.query(query, values)).rows[0]; 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) => { delete_video_by_id: handleDatabaseOperation(async (id) => {
const query = `DELETE FROM videos WHERE id = $1;`; const query = `DELETE FROM videos WHERE id = $1;`;
await db.query(query, [id]); 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 = { const camera = {
@@ -244,12 +262,14 @@ const camera = {
const query = `SELECT * FROM camera;`; const query = `SELECT * FROM camera;`;
return (await db.query(query)).rows; return (await db.query(query)).rows;
}), }),
edit_camera: handleDatabaseOperation(async (id, updates) => { edit_camera: handleDatabaseOperation(async (id, updates) => {
const fields = Object.keys(updates).map((key, index) => `${key} = $${index + 2}`).join(', '); const fields = Object.keys(updates).map((key, index) => `${key} = $${index + 2}`).join(', ');
const values = [id, ...Object.values(updates)]; const values = [id, ...Object.values(updates)];
const query = `UPDATE camera SET ${fields} WHERE id = $1 RETURNING *;`; const query = `UPDATE camera SET ${fields} WHERE id = $1 RETURNING *;`;
return (await db.query(query, values)).rows[0]; return (await db.query(query, values)).rows[0];
}), }),
delete_camera: handleDatabaseOperation(async (id) => { delete_camera: handleDatabaseOperation(async (id) => {
const query = `DELETE FROM camera WHERE id = $1;`; const query = `DELETE FROM camera WHERE id = $1;`;
await db.query(query, [id]); await db.query(query, [id]);

179
src/video/videoManager.js
View File

@@ -2,53 +2,11 @@ const fs = require('fs');
const path = require('path'); const path = require('path');
const { spawn } = 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 storage_manager = require('../data/storage_manager'); const storage_manager = require('../data/storage_manager');
const PROJECTS_DIR = path.join('.'); const PROJECTS_DIR = path.join('.');
async function deleteUnfinishedVideos() {
// Au démarrage du backend, supprimer les vidéos inachevées (donc en status 1)
const unfinishedVideos = await db.query(`
SELECT id FROM public.videos
WHERE status = 0 OR status = 2 OR status = 3
`);
for (const video of unfinishedVideos.rows) {
try {
await deleteVideoProject(video.id);
console.log(`Deleted unfinished video with id: ${video.id}`);
} catch (error) {
console.error(`Error deleting unfinished video with id: ${video.id}`, error);
}
}
}
// async function cleanVideoFiles() {
// //supprimer les fichiers vidéos qui ne sont pas associés à une vidéo de la base de données
// }
deleteUnfinishedVideos();
async function createVideoProject(projectId, measurementIds, name, resolution, duration) {
// insérer une nouvelle vidéo dans la base de données
const status = 0; // 0 = en cours, 1 = terminé, 2 = erreur, 3 = en cours de création
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];
const res = await db.query(query, values);
console.log('New video created with id:', res.rows[0].id);
return res.rows[0].id;
}
async function deleteVideoProject(videoId) {
const query = 'DELETE FROM public.videos WHERE id = $1';
const values = [videoId];
const res = await db.query(query, values);
console.log('Video deleted:', res.rows[0]);
return res.rows[0];
}
async function createVideoWithList(projectId, pathList, duration, videoId, res_width, res_height) { async function createVideoWithList(projectId, pathList, duration, videoId, res_width, res_height) {
const tempFile = path.join('temp.txt'); const tempFile = path.join('temp.txt');
let ffmpegProcess; let ffmpegProcess;
@@ -83,16 +41,14 @@ async function createVideoWithList(projectId, pathList, duration, videoId, res_w
); );
// Mise à jour initiale de la base de données // Mise à jour initiale de la base de données
await db.query(` let edit_video = {
UPDATE public.videos status: 3,
SET progress: 0,
status = 3, started_at: new Date(),
progress = 0, updated_at: new Date(),
started_at = NOW(), eta: null
updated_at = NOW(), }
eta = NULL await database_manager.video.edit_video_by_id(videoId, edit_video)
WHERE id = $1
`, [videoId]);
const scale = res_width && res_height ? `scale=${res_width}:${res_height}` : 'scale=854:480'; // Redimensionne la vidéo en 480p par défaut 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 // Configuration de FFmpeg
@@ -132,14 +88,12 @@ async function createVideoWithList(projectId, pathList, duration, videoId, res_w
// Mise à jour max toutes les 500ms // Mise à jour max toutes les 500ms
if (now - lastUpdate > 500) { if (now - lastUpdate > 500) {
db.query(` let update_video = {
UPDATE public.videos progress: progress,
SET eta: Math.round(eta),
progress = $1, updated_at: new Date()
eta = $2, }
updated_at = NOW() database_manager.video.edit_video_by_id(videoId, update_video)
WHERE id = $3
`, [progress, Math.round(eta), videoId]).catch(console.error);
console.log('Progress:', progress.toFixed(2), '%, ETA:', eta.toFixed(0), 's'); console.log('Progress:', progress.toFixed(2), '%, ETA:', eta.toFixed(0), 's');
lastUpdate = now; lastUpdate = now;
@@ -153,16 +107,24 @@ async function createVideoWithList(projectId, pathList, duration, videoId, res_w
if (code === 0) { if (code === 0) {
try { try {
// Mise à jour finale // Mise à jour finale
await db.query(` // await db.query(`
UPDATE public.videos // UPDATE public.videos
SET // SET
status = 1, // status = 1,
progress = 100, // progress = 100,
eta = 0, // eta = 0,
video_file = $1, // video_file = $1,
updated_at = NOW() // updated_at = NOW()
WHERE id = $2 // WHERE id = $2
`, [outputVideo, videoId]); // `, [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(); resolve();
} catch (e) { } catch (e) {
reject(e); reject(e);
@@ -182,15 +144,14 @@ async function createVideoWithList(projectId, pathList, duration, videoId, res_w
console.error('Error in video creation:', error); console.error('Error in video creation:', error);
try { try {
await db.query(` // Mise à jour de la base de données en cas d'erreur
UPDATE public.videos let error_video = {
SET status: 0,
status = 2, progress: 0,
progress = 0, eta: null,
eta = 0, updated_at: new Date()
updated_at = NOW() }
WHERE id = $1 await database_manager.video.edit_video_by_id(videoId, error_video)
`, [videoId]);
} catch (dbError) { } catch (dbError) {
console.error('Database update error:', dbError); console.error('Database update error:', dbError);
} }
@@ -211,60 +172,4 @@ async function createVideoWithList(projectId, pathList, duration, videoId, res_w
} }
} }
module.exports = { createVideoWithList };
async function createVideo(projectId) {
const tempFile = path.join('temp.txt');
try {
// Trouver tous les fichiers image pour le projet donné
const workdir = path.join(PROJECTS_DIR, 'storage', `${projectId}`);
const dir = path.join(PROJECTS_DIR, 'storage', `${projectId}`, 'images');
console.log('dir:', dir);
const images = storage_manager.scanAllImages(dir);
console.log('images:', images);
// Trier les images numériquement
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);
spawn(ffmpegCommand);
console.log('Video created successfully:', 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 updateVideoFile(videoId, video_file) {
const query = 'UPDATE public.videos SET video_file = $2 WHERE id = $1 RETURNING *';
const values = [videoId, video_file];
const res = await db.query(query, values);
console.log('Video updated:', res.rows[0]);
return res.rows[0];
}
module.exports = { createVideo, createVideoWithList, createVideoProject, deleteVideoProject, updateVideoFile };