363 lines
12 KiB
JavaScript
363 lines
12 KiB
JavaScript
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');
|
|
|
|
//const minInterval = 3; // Minutes
|
|
//const maxInterval = 60; // Minutes
|
|
|
|
var defaultCaptureInterval = 5; // minutes
|
|
var defaultMaintenance = 0;
|
|
var defaultActive = 0; // 0 = pas de capture, 1 = capture en cours
|
|
|
|
function initCamera() {
|
|
const query = 'SELECT * FROM public.camera WHERE id = $1';
|
|
const values = [1];
|
|
|
|
db.query(query, values, (err, result) => {
|
|
if (err) {
|
|
console.error('Erreur lors de la vérification de l\'entrée caméra:', err);
|
|
return;
|
|
}
|
|
|
|
if (result.rows.length === 0) {
|
|
const insertQuery = `
|
|
INSERT INTO public.camera (id, interval, maintenance, active)
|
|
VALUES ($1, $2, $3, $4)
|
|
`;
|
|
const insertValues = [1, defaultCaptureInterval, defaultMaintenance, defaultActive];
|
|
|
|
db.query(insertQuery, insertValues, (err) => {
|
|
if (err) {
|
|
console.error('Erreur lors de l\'initialisation de la caméra:', err);
|
|
} else {
|
|
console.log('Caméra initialisée avec les valeurs par défaut.');
|
|
}
|
|
});
|
|
} else {
|
|
console.log('L\'entrée caméra avec l\'ID 1 existe déjà. Aucune initialisation nécessaire.');
|
|
}
|
|
});
|
|
}
|
|
|
|
async function getCamera() {
|
|
// retourner l'état de la caméra
|
|
const query = 'SELECT * FROM public.camera WHERE id = $1';
|
|
const values = [1];
|
|
|
|
try {
|
|
const result = await db.query(query, values);
|
|
if (result.rows.length === 0) {
|
|
console.log('Aucune entrée caméra trouvée.');
|
|
return null;
|
|
} else {
|
|
const camera = result.rows[0];
|
|
console.log('État de la caméra récupéré avec succès:', camera);
|
|
return {
|
|
captureInterval: camera.interval,
|
|
captureProjectID: camera.active,
|
|
captureStatus: camera.active,
|
|
maintenance: camera.maintenance
|
|
};
|
|
}
|
|
} catch (err) {
|
|
console.error('Erreur lors de la récupération de l\'état de la caméra:', err);
|
|
throw err;
|
|
}
|
|
}
|
|
|
|
function printCameraStatus() {
|
|
let camera = getCamera();
|
|
console.log('Statut de la caméra:');
|
|
console.log('Intervalle de capture:', camera.captureInterval, 'minutes');
|
|
console.log('Maintenance:', camera.maintenance === 1 ? 'En cours' : 'Aucune');
|
|
console.log('Statut de la capture:', camera.active === 1 ? 'En cours' : 'Arrêté');
|
|
console.log('-----------------------------------');
|
|
}
|
|
|
|
function isCameraOccupied() {
|
|
try {
|
|
const query = 'SELECT id FROM public.projects WHERE status = $1 LIMIT 1';
|
|
const values = [1];
|
|
|
|
return new Promise((resolve, reject) => {
|
|
db.query(query, values, (err, result) => {
|
|
if (err) {
|
|
console.error('Erreur lors de la vérification de l\'occupation de la caméra:', err);
|
|
reject(err);
|
|
} else {
|
|
const isOccupied = result.rows.length > 0 ? result.rows[0].id : null;
|
|
resolve(isOccupied);
|
|
}
|
|
});
|
|
});
|
|
|
|
} catch (err) {
|
|
console.error('Erreur inattendue lors de la vérification de l\'occupation de la caméra:', err);
|
|
}
|
|
}
|
|
|
|
function getCurrentProject() {
|
|
// retourner le projet en cours (status 1)
|
|
try {
|
|
const query = 'SELECT * FROM public.projects WHERE status = $1 LIMIT 1';
|
|
const values = [1];
|
|
|
|
return new Promise((resolve, reject) => {
|
|
db.query(query, values, (err, result) => {
|
|
if (err) {
|
|
console.error('Erreur lors de la récupération du projet en cours:', err);
|
|
reject(err);
|
|
} else if (result.rows.length === 0) {
|
|
console.log('Aucun projet en cours trouvé.');
|
|
resolve(null);
|
|
} else {
|
|
const currentProject = result.rows[0];
|
|
console.log('Projet en cours récupéré avec succès:', currentProject);
|
|
resolve(currentProject);
|
|
}
|
|
});
|
|
});
|
|
} catch (err) {
|
|
console.error('Erreur inattendue lors de la récupération du projet en cours:', err);
|
|
}
|
|
}
|
|
|
|
function resetProjectStatus() {
|
|
// repasser tous les projets en status 1 à 0 (stopped)
|
|
const query = 'UPDATE public.projects SET status = $1 WHERE status = $2';
|
|
const values = [0, 1];
|
|
|
|
db.query(query, values, (err) => {
|
|
if (err) {
|
|
console.error('Erreur lors de la réinitialisation du statut des projets:', err);
|
|
} else {
|
|
console.log('Statut des projets réinitialisé avec succès.');
|
|
}
|
|
});
|
|
}
|
|
|
|
function activateCamera() {
|
|
// activer la caméra (status 1)
|
|
const query = 'UPDATE public.camera SET active = $1 WHERE id = $2';
|
|
const values = [1, 1];
|
|
|
|
db.query(query, values, (err) => {
|
|
if (err) {
|
|
console.error('Erreur lors de l\'activation de la caméra:', err);
|
|
} else {
|
|
console.log('Caméra activée avec succès.');
|
|
}
|
|
});
|
|
}
|
|
|
|
function deactivateCamera() {
|
|
// désactiver la caméra (status 0)
|
|
const query = 'UPDATE public.camera SET active = $1 WHERE id = $2';
|
|
const values = [0, 1];
|
|
|
|
db.query(query, values, (err) => {
|
|
if (err) {
|
|
console.error('Erreur lors de la désactivation de la caméra:', err);
|
|
} else {
|
|
console.log('Caméra désactivée avec succès.');
|
|
}
|
|
});
|
|
}
|
|
|
|
function changeProjectStatus(projectId, status) {
|
|
try {
|
|
const query = 'UPDATE public.projects SET status = $1 WHERE id = $2';
|
|
const values = [status, projectId];
|
|
|
|
db.query(query, values, (err) => {
|
|
if (err) {
|
|
console.error('Erreur lors de la modification du statut du projet:', err);
|
|
} else {
|
|
console.log(`Statut du projet ID ${projectId} modifié avec succès à ${status}.`);
|
|
}
|
|
});
|
|
} catch (err) {
|
|
console.error('Une erreur inattendue s\'est produite lors de la modification du statut du projet:', err);
|
|
}
|
|
}
|
|
|
|
initCamera();
|
|
printCameraStatus();
|
|
|
|
/**
|
|
* @swagger
|
|
* /camera/status:
|
|
* get:
|
|
* summary: Get the current status of the camera
|
|
* tags:
|
|
* - Camera
|
|
* responses:
|
|
* 200:
|
|
* description: Successfully retrieved the camera status
|
|
* content:
|
|
* application/json:
|
|
* schema:
|
|
* type: object
|
|
* properties:
|
|
* captureInterval:
|
|
* type: integer
|
|
* description: Capture interval in minutes
|
|
* captureProjectID:
|
|
* type: integer
|
|
* description: ID of the project currently being captured
|
|
* captureStatus:
|
|
* type: integer
|
|
* description: Capture status (0 = stopped, 1 = ongoing)
|
|
* maintenance:
|
|
* type: integer
|
|
* description: Maintenance status (0 = none, 1 = ongoing)
|
|
* 500:
|
|
* description: Internal server error
|
|
*/
|
|
router.get('/camera/status', async (req, res) => {
|
|
try {
|
|
const cameraStatus = await getCamera();
|
|
res.status(200).json(cameraStatus);
|
|
} catch (err) {
|
|
serverError.sendError('Erreur lors de la récupération de l\'état de la caméra:', res, err, 500);
|
|
}
|
|
});
|
|
|
|
function setCameraSettings(interval, maintenance) {
|
|
try {
|
|
const query = `
|
|
UPDATE public.camera
|
|
SET interval = $1, maintenance = $2
|
|
WHERE id = $3
|
|
`;
|
|
const values = [interval, maintenance, 1];
|
|
|
|
db.query(query, values, (err) => {
|
|
if (err) {
|
|
console.error('Erreur lors de la mise à jour des paramètres de la caméra:', err);
|
|
} else {
|
|
console.log('Paramètres de la caméra mis à jour avec succès.');
|
|
captureInterval = interval;
|
|
maintenance = maintenance;
|
|
}
|
|
});
|
|
} catch (err) {
|
|
console.error('Une erreur inattendue s\'est produite lors de la mise à jour des paramètres de la caméra:', err);
|
|
}
|
|
}
|
|
|
|
async function startProcedure(projectId, interval, maintenance) {
|
|
if (isNaN(projectId) || isNaN(interval) || isNaN(maintenance)) {
|
|
return { error: 'Invalid parameters' };
|
|
}
|
|
const cameraOccupied = await isCameraOccupied();
|
|
if (cameraOccupied) {
|
|
return { error: 'Camera is occupied by another project' };
|
|
} else {
|
|
activateCamera();
|
|
setCameraSettings(interval, maintenance);
|
|
changeProjectStatus(projectId, 1); // changer le statut du projet en cours à 1 (en cours)
|
|
console.log('Procédure de capture démarrée avec succès.');
|
|
return { message: 'Capture procedure started successfully' };
|
|
}
|
|
}
|
|
|
|
function stopProcedure() {
|
|
var project = getCurrentProject();
|
|
if (project) {
|
|
//resetProjectStatus(); // réinitialiser le statut du projet en cours
|
|
deactivateCamera(); // désactiver la caméra
|
|
changeProjectStatus(project.id, 2); // changer le statut du projet en cours à 2 (terminé)
|
|
console.log('Procédure de capture arrêtée avec succès.');
|
|
return { message: 'Capture procedure stopped successfully' };
|
|
} else {
|
|
return { error: 'No project is currently being captured' };
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @swagger
|
|
* /procedure/start/:
|
|
* post:
|
|
* summary: Start the capture procedure
|
|
* tags:
|
|
* - Procedure
|
|
* requestBody:
|
|
* required: true
|
|
* content:
|
|
* application/json:
|
|
* schema:
|
|
* type: object
|
|
* properties:
|
|
* projectId:
|
|
* type: integer
|
|
* description: ID of the project to start capturing
|
|
* interval:
|
|
* type: integer
|
|
* description: Capture interval in minutes
|
|
* maintenance:
|
|
* type: integer
|
|
* description: Maintenance status (0 = none, 1 = ongoing)
|
|
* responses:
|
|
* 200:
|
|
* description: Successfully started the capture procedure
|
|
* content:
|
|
* application/json:
|
|
* schema:
|
|
* type: object
|
|
* properties:
|
|
* message:
|
|
* type: string
|
|
* description: Success message
|
|
* error:
|
|
* type: string
|
|
* description: Error message, if any
|
|
* 500:
|
|
* description: Internal server error
|
|
* /procedure/stop/:
|
|
* post:
|
|
* summary: Stop the capture procedure
|
|
* tags:
|
|
* - Procedure
|
|
* responses:
|
|
* 200:
|
|
* description: Successfully stopped the capture procedure
|
|
* content:
|
|
* application/json:
|
|
* schema:
|
|
* type: object
|
|
* properties:
|
|
* message:
|
|
* type: string
|
|
* description: Success message
|
|
* error:
|
|
* type: string
|
|
* description: Error message, if any
|
|
* 500:
|
|
* description: Internal server error
|
|
*/
|
|
router.post('/procedure/start/', async (req, res) => {
|
|
const { projectId, interval, maintenance } = req.body;
|
|
try {
|
|
const result = await startProcedure(projectId, interval, maintenance);
|
|
res.status(200).json(result);
|
|
} catch (err) {
|
|
serverError.sendError('Erreur lors du démarrage de la procédure de capture:', res, err, 500);
|
|
}
|
|
});
|
|
|
|
router.post('/procedure/stop/', async (req, res) => {
|
|
try {
|
|
const result = stopProcedure();
|
|
res.status(200).json(result);
|
|
} catch (err) {
|
|
serverError.sendError('Erreur lors de l\'arrêt de la procédure de capture:', res, err, 500);
|
|
}
|
|
});
|
|
|
|
module.exports = router;
|