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 serverError = require('../utils/serverError');
const videoManager = require('../src/video/videoManager');
const database_manager = require('../src/database/database_manager');
const storage_manager = require('../src/data/storage_manager');
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)
.then(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 => {
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`;
console.log("[FILE] get_video : " + 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;`;
return (await db.query(query)).rows;
}),
get_video_by_id: handleDatabaseOperation(async (id) => {
const query = `SELECT * FROM videos WHERE id = $1;`;
return (await db.query(query, [id])).rows[0];
}),
get_videos_by_project_id: handleDatabaseOperation(async (project_id) => {
const query = `SELECT * FROM videos WHERE project_id = $1;`;
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 *;`;
return (await db.query(query, [project_id, measurement_ids, video_file, resolution, duration, status, name, progress, started_at, updated_at, eta])).rows[0];
create_video: handleDatabaseOperation(async (projectId, measurementIds, name, resolution, duration, status = 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) => {
const fields = Object.keys(updates).map((key, index) => `${key} = $${index + 2}`).join(', ');
const values = [id, ...Object.values(updates)];
const query = `UPDATE videos SET ${fields} WHERE id = $1 RETURNING *;`;
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) => {
const query = `DELETE FROM videos WHERE id = $1;`;
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 = {
@@ -244,12 +262,14 @@ const camera = {
const query = `SELECT * FROM camera;`;
return (await db.query(query)).rows;
}),
edit_camera: handleDatabaseOperation(async (id, updates) => {
const fields = Object.keys(updates).map((key, index) => `${key} = $${index + 2}`).join(', ');
const values = [id, ...Object.values(updates)];
const query = `UPDATE camera SET ${fields} WHERE id = $1 RETURNING *;`;
return (await db.query(query, values)).rows[0];
}),
delete_camera: handleDatabaseOperation(async (id) => {
const query = `DELETE FROM camera WHERE id = $1;`;
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 { spawn } = require('child_process');
const serverError = require('../../utils/serverError');
const db = require('../../db');
const database_manager = require('../database/database_manager');
const storage_manager = require('../data/storage_manager');
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) {
const tempFile = path.join('temp.txt');
let ffmpegProcess;
@@ -83,16 +41,14 @@ async function createVideoWithList(projectId, pathList, duration, videoId, res_w
);
// Mise à jour initiale de la base de données
await db.query(`
UPDATE public.videos
SET
status = 3,
progress = 0,
started_at = NOW(),
updated_at = NOW(),
eta = NULL
WHERE id = $1
`, [videoId]);
let edit_video = {
status: 3,
progress: 0,
started_at: new Date(),
updated_at: new Date(),
eta: null
}
await database_manager.video.edit_video_by_id(videoId, edit_video)
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
@@ -132,14 +88,12 @@ async function createVideoWithList(projectId, pathList, duration, videoId, res_w
// Mise à jour max toutes les 500ms
if (now - lastUpdate > 500) {
db.query(`
UPDATE public.videos
SET
progress = $1,
eta = $2,
updated_at = NOW()
WHERE id = $3
`, [progress, Math.round(eta), videoId]).catch(console.error);
let update_video = {
progress: progress,
eta: Math.round(eta),
updated_at: new Date()
}
database_manager.video.edit_video_by_id(videoId, update_video)
console.log('Progress:', progress.toFixed(2), '%, ETA:', eta.toFixed(0), 's');
lastUpdate = now;
@@ -153,16 +107,24 @@ async function createVideoWithList(projectId, pathList, duration, videoId, res_w
if (code === 0) {
try {
// Mise à jour finale
await db.query(`
UPDATE public.videos
SET
status = 1,
progress = 100,
eta = 0,
video_file = $1,
updated_at = NOW()
WHERE id = $2
`, [outputVideo, videoId]);
// await db.query(`
// UPDATE public.videos
// SET
// status = 1,
// progress = 100,
// eta = 0,
// video_file = $1,
// updated_at = NOW()
// WHERE id = $2
// `, [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();
} catch (e) {
reject(e);
@@ -182,15 +144,14 @@ async function createVideoWithList(projectId, pathList, duration, videoId, res_w
console.error('Error in video creation:', error);
try {
await db.query(`
UPDATE public.videos
SET
status = 2,
progress = 0,
eta = 0,
updated_at = NOW()
WHERE id = $1
`, [videoId]);
// Mise à jour de la base de données en cas d'erreur
let error_video = {
status: 0,
progress: 0,
eta: null,
updated_at: new Date()
}
await database_manager.video.edit_video_by_id(videoId, error_video)
} catch (dbError) {
console.error('Database update error:', dbError);
}
@@ -211,60 +172,4 @@ async function createVideoWithList(projectId, pathList, duration, videoId, res_w
}
}
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 };
module.exports = { createVideoWithList };