À propos de ce cours
Objectifs du projet
- Concevoir et réaliser seul ou en binôme une application complète : API, base de données, client, tests, déploiement.
- Traduire des règles de gestion réelles en code, et les vérifier par des tests automatisés.
- Sécuriser l'application : authentification, rôles, validation, données privées.
- Travailler comme en entreprise : GitHub dès le premier jour, commits réguliers, README, mise en production.
Durée: 24 à 30 h (4 à 5 séances et du travail personnel) | Travail: seul ou en binôme | Prérequis: tout le cours, en particulier les TP 8, 9 et 10 et le chapitre 16 | Livrables: le dépôt GitHub (étiquette v1.0.0), l'adresse de l'application en ligne, une soutenance de 15 minutes.

Le résultat attendu : le planning d'une salle, ses réservations et le formulaire de réservation (capture réelle de la correction).
Le contexte
Un centre de formation dispose de plusieurs salles : salles de cours, laboratoire informatique, petites salles de réunion. Aujourd'hui, les formateurs réservent sur un tableau papier à l'accueil : doubles réservations, salles trop petites, réservations oubliées jamais annulées. La direction vous demande une application web de réservation de salles, utilisable depuis un ordinateur ou un téléphone.
L'architecture attendue : un client SPA, une API Express, MongoDB Atlas, des tests et un déploiement.
Cahier des charges
Les utilisateurs
| Profil | Peut… |
|---|---|
| Visiteur | créer un compte, se connecter (rien d'autre n'est visible sans connexion) |
| Utilisateur (formateur, personnel) | consulter les salles (filtres capacité et équipement), voir le planning d'une salle pour un jour, réserver, consulter et annuler ses réservations |
| Administrateur | tout ce que fait un utilisateur, plus : ajouter une salle, désactiver ou réactiver une salle, voir toutes les réservations à venir, annuler n'importe quelle réservation |
Les règles de gestion
| N° | Règle | Réponse de l'API si non respectée |
|---|---|---|
| R1 | Une salle ne peut pas être réservée deux fois sur des créneaux qui se chevauchent. Deux créneaux qui se touchent (l'un finit à 11 h, l'autre commence à 11 h) sont acceptés. | 409, avec le créneau en conflit |
| R2 | Le centre est ouvert de 8 h à 19 h (heure de Tunis) ; une réservation tient dans une seule journée. | 400 |
| R3 | Durée : de 30 minutes à 4 heures ; la fin est après le début. | 400 |
| R4 | On ne réserve pas dans le passé. | 400 |
| R5 | Le nombre de participants ne dépasse pas la capacité de la salle. | 400 |
| R6 | Une salle désactivée ne peut plus être réservée (ses réservations existantes restent). | 409 |
| R7 | Un utilisateur a au plus 5 réservations à venir. | 409 |
| R8 | Seul l'auteur ou un administrateur annule une réservation, et seulement avant son début. Une réservation annulée libère le créneau ; elle n'est pas supprimée. | 404 (réservation d'un autre), 409 |
| R9 | Dans le planning d'une salle, l'objet des réservations des autres est masqué (« Réservé »). | — |
Les exigences techniques
- API REST Express 5 en modules ES, organisée en routes, contrôleurs, services (séparation des couches) ; erreurs en JSON homogènes.
- MongoDB Atlas avec Mongoose ; mots de passe hachés avec bcrypt ; authentification JWT ; validation des entrées avec express-validator ;
helmetet limite des tentatives de connexion. - Client SPA en JavaScript sans framework, servi par Express (une seule origine), routes en
#/…, aucune insertion de données avecinnerHTML. - Tests automatisés avec
node:testet Supertest couvrant toutes les règles R1 à R9 ; workflow GitHub Actions. - Dépôt GitHub dès la première séance ; aucun secret dans le dépôt.
- Application en ligne, en HTTPS : VPS avec PM2 et nginx, ou plateforme cloud avec MongoDB Atlas (déployer une application Node.js).
- Bonus : planning mis à jour en temps réel avec Socket.IO (le temps réel avec Socket.IO).
L'API à réaliser
| Méthode | Route | Accès | Rôle |
|---|---|---|---|
| POST | /api/auth/inscription |
public | créer un compte (rôle utilisateur imposé) |
| POST | /api/auth/connexion |
public | renvoie { jeton, utilisateur } |
| GET | /api/auth/moi |
connecté | profil de l'utilisateur connecté |
| GET | /api/salles?capaciteMin=&equipement= |
connecté | salles actives (toutes avec ?toutes=oui pour l'administrateur) |
| GET | /api/salles/:id/planning?date=AAAA-MM-JJ |
connecté | créneaux occupés de la journée (R9) |
| POST / PATCH | /api/salles, /api/salles/:id |
admin | ajouter, modifier, désactiver une salle |
| POST | /api/reservations |
connecté | réserver (R1 à R7) |
| GET | /api/reservations/miennes |
connecté | ses réservations |
| PATCH | /api/reservations/:id/annuler |
auteur ou admin | annuler (R8) |
| GET | /api/reservations |
admin | toutes les réservations à venir |
Les trois collections et la condition de chevauchement (R1).
Déroulement
Le projet est découpé en neuf parties. À la fin de chacune, poussez votre travail sur GitHub avec un message de commit clair : votre enseignant suit l'avancement par l'historique du dépôt.
Partie 1 Initialiser le projet et le dépôt GitHub
- Créez un dépôt privé
reservation-sallessur GitHub (avec un README), invitez votre enseignant (et votre binôme), puis clonez-le. npm init -y,"type": "module","engines": { "node": ">=24" }. Installezexpress mongoose jsonwebtoken bcrypt express-validator helmet express-rate-limit cors morganet, en développement,supertest.- Créez l'arborescence
src/(config, models, services, controllers, routes, middlewares, utils),public/,test/,scripts/. - Fichiers
.gitignore(node_modules/,.env),.env.example(documenté, sans secret),.env(vos valeurs). - Sur MongoDB Atlas, créez un cluster gratuit, un utilisateur de base et autorisez votre adresse IP (MongoDB Atlas).
- Scripts
dev(node --watch --env-file-if-exists=.env src/server.js),start,test. Séparezsrc/app.js(création de l'application) etsrc/server.js(connexion à la base et écoute).
Point de contrôle: GET /api/sante répond { "statut": "ok" }. Commit : chore: initialisation du projet.
Partie 2 Modèles Mongoose et données de démonstration
- Écrivez les modèles
Utilisateur,SalleetReservation(schéma ci-dessus) avec leurs validations ; le mot de passe aselect: false. - Ajoutez un index
{ salle: 1, debut: 1, fin: 1 }sur les réservations : la recherche de chevauchement l'utilisera à chaque réservation. - Écrivez
scripts/seed.js(npm run seed) : 3 comptes (un administrateur), 5 salles dont une désactivée, quelques réservations pour demain. Le script refuse de s'exécuter en production.
Point de contrôle: les trois collections apparaissent dans Compass ou Atlas. Commit : feat: modèles et données de démonstration.
Partie 3 Authentification et rôles
- Service d'authentification : inscription (409 si l'e-mail existe, rôle toujours
utilisateur), connexion (même message 401 pour un e-mail inconnu ou un mauvais mot de passe), profil. - Middlewares
authentifier(jetonBearer) etautoriser(...roles)(middleware d'authentification). - Validation : e-mail valide, mot de passe d'au moins 8 caractères avec majuscule, minuscule et chiffre ; 10 tentatives de connexion par quart d'heure.
- Middleware d'erreurs centralisé : toutes les erreurs en JSON
{ erreur, details? }, jamais de pile d'appels envoyée au client.
Point de contrôle: avec un fichier .http, inscription, connexion et GET /api/auth/moi avec le jeton. Commit : feat: authentification JWT et rôles.
Partie 4 Les salles et leur planning
- Routes des salles, toutes protégées par
authentifier; création et modification réservées à l'administrateur ; filtrescapaciteMinetequipement. - Route du planning : les réservations confirmées de la salle qui recoupent la journée demandée, triées par heure. Appliquez R9.
- Attention aux fuseaux horaires : MongoDB stocke les dates en UTC. La « journée du 20 novembre » à Tunis va de
2026-11-19T23:00:00Zà2026-11-20T23:00:00Z. Écrivez danssrc/utils/dates.jsdes fonctions qui font ces conversions avecIntl.DateTimeFormatet le fuseauAfrica/Tunis, sans dépendre du fuseau du serveur (souvent UTC en production).
Point de contrôle: le planning de demain d'une salle du seed renvoie ses créneaux. Commit : feat: salles et planning.
Partie 5 Les réservations : le cœur du projet
- Dans
src/services/reservations.service.js, la fonctioncreer()applique R2 à R7, puis R1. Pour R1, une seule requête suffit : chercher une réservation confirmée de la même salle avecdebut < nouvelleFinetfin > nouveauDebut. - En cas de conflit, renvoyez 409 et le créneau en conflit dans
details, pour que le client puisse l'afficher. - Annulation (R8) : on passe le statut à
annulee(on garde l'historique). Pour la réservation d'un autre, répondez 404 et non 403, pour ne pas révéler son existence. - Routes
/miennes(utilisateur) et/(administrateur), avecpopulatepour afficher le nom de la salle et de l'auteur.
Point de contrôle: deux réservations qui se chevauchent avec deux comptes : la seconde reçoit 409. Commit : feat: réservations et règles de gestion.
Partie 6 Les tests automatisés
- Fichier
.env.test(base séparée, versionné) et script"test": "node --env-file=.env.test --test \"test/**/*.test.js\""(tester une API avec node:test). - Un fichier d'outils
test/aide.js: une base par fichier de test, création d'un compte et de son jeton, et une fonctioncreneau(dansJours, heureDebut, heureFin)qui fabrique des dates futures en heure de Tunis. - Au moins un test par règle R1 à R9, plus les cas 401, 403 et 404. Une boucle
forévite de répéter les tests des règles R2 et R3. - Workflow GitHub Actions avec un service
mongo:8.0; la coche verte doit apparaître sur chaque Pull Request.
Point de contrôle: npm test passe entièrement, en local et dans GitHub Actions. Commit : test: règles de gestion R1 à R9.
Partie 7 Le client SPA
public/index.html: une barre de navigation, un<main id="vue">, un scripttype="module". Le style danspublic/css/style.css. Aucun script dans la page : la CSP dehelmetl'interdit.public/js/api.js: une fonctionapi(chemin, options)qui ajoute le jeton, envoie et décode le JSON, transforme les réponses d'erreur en exceptions, et renvoie vers la connexion en cas de 401 (l'authentification côté client).public/js/app.js: un routeur sur l'événementhashchange; une table des routes, avec les routes publiques et la route réservée à l'administrateur.- Les vues : connexion, inscription, liste des salles avec filtres, planning d'une salle (grille de 8 h à 19 h, formulaire de réservation, message d'erreur de l'API), mes réservations (bouton Annuler), administration.
- Créez les éléments avec
document.createElementettextContent: un objet de réservation comme<img src=x onerror=alert(1)>doit s'afficher comme du texte.
Point de contrôle: le parcours complet dans le navigateur, avec deux comptes. Commit : feat: client SPA.
Partie 8 Bonus : le temps réel
- Les services émettent
reservation:modifiee(salle et date) sur unEventEmitterà chaque réservation ou annulation. - Le serveur Socket.IO, qui accepte uniquement les clients avec un jeton valide, diffuse
planning:modifie. - La vue planning se connecte en arrivant, recharge le planning si l'événement concerne la salle et le jour affichés, et ferme la connexion en quittant la vue.
Point de contrôle: deux navigateurs sur le même planning ; une réservation dans l'un apparaît dans l'autre sans rechargement. Commit : feat: planning en temps réel.
Partie 9 Mise en production
- Préparez la production :
HOTE,TRUST_PROXY, arrêt propre surSIGTERM, scriptadmin:creer(le seed est interdit en production). - Option A, VPS: utilisateur
deploy, Node.js 24, PM2 (ecosystem.config.cjs), nginx avec HTTPS et le bloc/socket.io/pour les WebSockets, scriptdeploiement/deployer.sh. - Option B, cloud: Render (Web Service relié au dépôt) + MongoDB Atlas, variables d'environnement saisies dans l'interface,
TRUST_PROXY=1. - Complétez le README : présentation, installation, comptes de démonstration, règles, tableau de l'API, adresse en ligne, badge de la CI. Créez l'étiquette
v1.0.0.
Point de contrôle: l'application répond en HTTPS ; le premier administrateur a été créé par le script. Commit : chore: déploiement, puis git tag v1.0.0 && git push --tags.
Soutenance (15 minutes)
- Démonstration (5 min) : inscription, réservation, conflit refusé, annulation, administration, sur l'application en ligne.
- Code (5 min) : la fonction qui applique les règles de réservation, un test, la gestion des dates.
- Questions (5 min) : par exemple « que se passe-t-il si deux personnes réservent le même créneau à la même milliseconde ? » (voir « Pour aller plus loin »).
Grille d'évaluation
| Critère | Points |
|---|---|
| Organisation du code (couches, configuration, erreurs JSON homogènes) | 2 |
| Authentification, rôles, validation, sécurité (bcrypt, JWT, helmet, limite de connexion, R9, 404 sur la réservation d'un autre) | 3 |
| Salles et planning (filtres, fuseau horaire correct) | 2 |
| Règles de réservation R1 à R8 toutes respectées | 4 |
| Tests automatisés couvrant les règles, CI GitHub Actions verte | 3 |
Client SPA complet, ergonomique, sans innerHTML pour les données |
3 |
| Application en ligne en HTTPS, secrets hors du dépôt, README | 2 |
| Historique Git (commits réguliers et clairs), soutenance | 1 |
| Bonus : temps réel avec Socket.IO | +1 |
| Total | 20 |
Pour aller plus loin
- Réservations simultanées: entre la recherche d'un conflit et l'enregistrement, une autre requête peut enregistrer le même créneau. Avec une seule instance, le risque est faible mais réel. Solutions : une transaction MongoDB (Atlas fonctionne en replica set, ce qui les rend possibles) avec un document « verrou » par salle et par jour, ou une file d'attente qui traite les réservations d'une salle une par une.
- Réservations récurrentes (« tous les mardis de 9 h à 11 h jusqu'en juin »), avec le rapport des conflits.
- E-mail de confirmation et de rappel la veille.
- Export du planning de la semaine en PDF ou au format iCalendar (
.ics) pour l'importer dans un agenda.
Correction
Correction réellement construite, testée et déployée: Node.js 24, Express 5, Mongoose 9, MongoDB 8.0, Socket.IO 4.8. Les 33 tests passent ; la couverture est de 96 % des lignes. Le déploiement a été fait sur un serveur de test Ubuntu 24.04 (adresse 192.0.2.2, domaine fictif reservations.exemple.tn, certificat de test à la place de Let's Encrypt). MongoDB était installé sur ce serveur, Atlas n'étant pas joignable depuis l'environnement de test : avec Atlas, seule la valeur de MONGODB_URI change. Le dépôt a été cloné depuis une copie locale du dépôt GitHub.
Arborescence
reservation-salles/
├── .github/
│ └── workflows/
│ └── tests.yml
├── deploiement/
│ ├── deployer.sh
│ └── nginx-reservation-salles.conf
├── public/
│ ├── css/
│ │ └── style.css
│ ├── js/
│ │ ├── vues/
│ │ │ ├── admin.js
│ │ │ ├── connexion.js
│ │ │ ├── planning.js
│ │ │ ├── reservations.js
│ │ │ └── salles.js
│ │ ├── api.js
│ │ ├── app.js
│ │ └── dom.js
│ └── index.html
├── scripts/
│ ├── creer-admin.js
│ └── seed.js
├── src/
│ ├── config/
│ │ ├── db.js
│ │ └── index.js
│ ├── controllers/
│ │ ├── auth.controller.js
│ │ ├── reservations.controller.js
│ │ └── salles.controller.js
│ ├── middlewares/
│ │ ├── auth.js
│ │ ├── erreurs.js
│ │ └── valider.js
│ ├── models/
│ │ ├── reservation.js
│ │ ├── salle.js
│ │ └── utilisateur.js
│ ├── routes/
│ │ ├── auth.routes.js
│ │ ├── reservations.routes.js
│ │ └── salles.routes.js
│ ├── services/
│ │ ├── auth.service.js
│ │ ├── reservations.service.js
│ │ └── salles.service.js
│ ├── utils/
│ │ ├── dates.js
│ │ └── erreur-api.js
│ ├── app.js
│ ├── evenements.js
│ ├── server.js
│ └── temps-reel.js
├── test/
│ ├── aide.js
│ ├── auth.test.js
│ ├── dates.test.js
│ ├── reservations.test.js
│ └── salles.test.js
├── .env.example
├── .env.test
├── .gitignore
├── README.md
├── ecosystem.config.cjs
├── package-lock.json
└── package.json
Les captures de la correction

Connexion : seule page accessible sans compte.

Liste des salles actives, avec filtres ; la salle désactivée n'apparaît pas.

R1 : le créneau 10 h – 11 h 30 chevauche la réservation de 9 h à 11 h ; l'API répond 409 et le client affiche le créneau en conflit.

Le même planning vu par Lina : les réservations des autres sont masquées (R9) ; celle de 11 h à 12 h 30 est apparue en temps réel, sans rechargement.

Mes réservations, avec le bouton Annuler (R8).

Administration : salles (dont une désactivée), ajout d'une salle, réservations à venir de tous les utilisateurs.
Configuration et dates
📄 package.json
{
"name": "reservation-salles",
"version": "1.0.0",
"description": "Application SPA Full Stack JS de réservation de salles (Express, MongoDB, Mongoose, JWT)",
"type": "module",
"main": "src/server.js",
"engines": {
"node": ">=24"
},
"scripts": {
"dev": "node --watch --env-file-if-exists=.env src/server.js",
"start": "node --env-file-if-exists=.env src/server.js",
"test": "node --env-file=.env.test --test \"test/**/*.test.js\"",
"test:watch": "node --env-file=.env.test --test --watch \"test/**/*.test.js\"",
"test:couverture": "node --env-file=.env.test --test --experimental-test-coverage --test-coverage-include=\"src/**\" \"test/**/*.test.js\"",
"seed": "node --env-file-if-exists=.env scripts/seed.js",
"admin:creer": "node --env-file-if-exists=.env scripts/creer-admin.js"
},
"dependencies": {
"bcrypt": "^6.0.0",
"cors": "^2.8.6",
"express": "^5.3.0",
"express-rate-limit": "^8.7.4",
"express-validator": "^7.3.2",
"helmet": "^8.3.0",
"jsonwebtoken": "^9.0.3",
"mongoose": "^9.12.1",
"morgan": "^1.12.1",
"socket.io": "^4.8.4"
},
"devDependencies": {
"socket.io-client": "^4.8.4",
"supertest": "^7.3.2"
}
}
📄 .env.example
NODE_ENV=development
PORT=3000
HOTE=0.0.0.0
# local : mongodb://127.0.0.1:27017/reservations
# Atlas : mongodb+srv://UTILISATEUR:MOT_DE_PASSE@cluster0.xxxxx.mongodb.net/reservations
MONGODB_URI=mongodb://127.0.0.1:27017/reservations
JWT_SECRET=remplacer-par-une-longue-chaine-aleatoire
JWT_DUREE=2h
# vide : client servi par la même origine (public/)
CORS_ORIGINES=
# fuseau horaire du centre (horaires d'ouverture)
FUSEAU=Africa/Tunis
# derrière nginx : loopback ; sur Render : 1
TRUST_PROXY=
📄 src/config/index.js
// Configuration lue une seule fois depuis les variables d'environnement
const obligatoire = (nom) => {
const valeur = process.env[nom];
if (!valeur) throw new Error(`Variable d'environnement manquante : ${nom}`);
return valeur;
};
export const config = {
env: process.env.NODE_ENV ?? 'development',
port: Number(process.env.PORT ?? 3000),
hote: process.env.HOTE ?? '0.0.0.0',
mongoUri: obligatoire('MONGODB_URI'),
jwtSecret: obligatoire('JWT_SECRET'),
jwtDuree: process.env.JWT_DUREE ?? '2h',
coutBcrypt: process.env.NODE_ENV === 'test' ? 4 : 12, // bcrypt est volontairement lent : moins en test
fuseau: process.env.FUSEAU ?? 'Africa/Tunis',
corsOrigines: (process.env.CORS_ORIGINES ?? '').split(',').filter(Boolean),
trustProxy: process.env.TRUST_PROXY ?? '',
};
📄 src/utils/dates.js
// Calculs de dates dans le fuseau du centre (Africa/Tunis par défaut), quel que soit le fuseau du serveur
import { config } from '../config/index.js';
function parties(date, fuseau = config.fuseau) {
const p = Object.fromEntries(new Intl.DateTimeFormat('en-GB', {
timeZone: fuseau, hourCycle: 'h23', year: 'numeric', month: '2-digit', day: '2-digit', hour: '2-digit', minute: '2-digit', second: '2-digit',
}).formatToParts(date).map(({ type, value }) => [type, value]));
return { annee: +p.year, mois: +p.month, jour: +p.day, heure: +p.hour, minute: +p.minute, seconde: +p.second };
}
// écart (ms) entre l'heure locale du fuseau et UTC à un instant donné
function decalage(date, fuseau) {
const p = parties(date, fuseau);
return Date.UTC(p.annee, p.mois - 1, p.jour, p.heure, p.minute, p.seconde) - Math.floor(date.getTime() / 1000) * 1000;
}
// « 2026-11-20 » → instants UTC du début et de la fin de cette journée locale
export function journeeLocale(texte, fuseau = config.fuseau) {
const m = /^(\d{4})-(\d{2})-(\d{2})$/.exec(texte ?? '');
if (!m) return null;
const minuitUtc = Date.UTC(+m[1], +m[2] - 1, +m[3]);
const debut = new Date(minuitUtc - decalage(new Date(minuitUtc), fuseau));
return { debut, fin: new Date(debut.getTime() + 24 * 3600 * 1000) };
}
// heure locale décimale (8.5 pour 8 h 30) et date locale « AAAA-MM-JJ »
export function heureLocale(date, fuseau = config.fuseau) {
const p = parties(date, fuseau);
return p.heure + p.minute / 60;
}
export function dateLocale(date, fuseau = config.fuseau) {
const p = parties(date, fuseau);
return `${p.annee}-${String(p.mois).padStart(2, '0')}-${String(p.jour).padStart(2, '0')}`;
}
Les modèles
src/models/ (3 fichiers)
📄 src/models/utilisateur.js
import mongoose from 'mongoose';
const utilisateurSchema = new mongoose.Schema(
{
nom: { type: String, required: true, trim: true, maxlength: 80 },
email: { type: String, required: true, unique: true, lowercase: true, trim: true },
motDePasse: { type: String, required: true, select: false },
role: { type: String, enum: ['utilisateur', 'admin'], default: 'utilisateur' },
},
{ timestamps: true, versionKey: false },
);
export const Utilisateur = mongoose.model('Utilisateur', utilisateurSchema);
📄 src/models/salle.js
import mongoose from 'mongoose';
const salleSchema = new mongoose.Schema(
{
nom: { type: String, required: [true, 'Le nom est obligatoire'], unique: true, trim: true, maxlength: 60 },
capacite: { type: Number, required: true, min: [1, 'Capacité minimale : 1'], max: [500, 'Capacité maximale : 500'] },
equipements: { type: [String], default: [] }, // ex. ['vidéoprojecteur', 'tableau blanc']
etage: { type: Number, default: 0 },
active: { type: Boolean, default: true }, // une salle désactivée ne peut plus être réservée
},
{ timestamps: true, versionKey: false },
);
export const Salle = mongoose.model('Salle', salleSchema);
📄 src/models/reservation.js
import mongoose from 'mongoose';
const reservationSchema = new mongoose.Schema(
{
salle: { type: mongoose.Schema.Types.ObjectId, ref: 'Salle', required: true },
utilisateur: { type: mongoose.Schema.Types.ObjectId, ref: 'Utilisateur', required: true },
debut: { type: Date, required: true },
fin: { type: Date, required: true },
objet: { type: String, required: true, trim: true, maxlength: 120 },
participants: { type: Number, min: 1, default: 1 },
statut: { type: String, enum: ['confirmee', 'annulee'], default: 'confirmee' },
},
{ timestamps: true, versionKey: false },
);
// recherche rapide des réservations d'une salle sur une période (contrôle des chevauchements)
reservationSchema.index({ salle: 1, debut: 1, fin: 1 });
reservationSchema.index({ utilisateur: 1, debut: -1 });
export const Reservation = mongoose.model('Reservation', reservationSchema);
Les règles de réservation
📄 src/services/reservations.service.js
import { Reservation } from '../models/reservation.js';
import { Salle } from '../models/salle.js';
import { ErreurApi } from '../utils/erreur-api.js';
import { heureLocale, dateLocale } from '../utils/dates.js';
import { verifierId } from './salles.service.js';
import { bus } from '../evenements.js';
// Règles de gestion du centre de formation
export const REGLES = { ouverture: 8, fermeture: 19, dureeMinMinutes: 30, dureeMaxHeures: 4, maxAVenir: 5 };
export async function creer({ salle: salleId, debut, fin, objet, participants = 1 }, moi) {
verifierId(salleId, 'Salle');
const d = new Date(debut);
const f = new Date(fin);
if (Number.isNaN(d.getTime()) || Number.isNaN(f.getTime())) throw new ErreurApi(400, 'Dates invalides');
// 1) règles sur le créneau
const minutes = (f - d) / 60000;
if (minutes <= 0) throw new ErreurApi(400, 'La fin doit être après le début');
if (minutes < REGLES.dureeMinMinutes) throw new ErreurApi(400, `Durée minimale : ${REGLES.dureeMinMinutes} minutes`);
if (minutes > REGLES.dureeMaxHeures * 60) throw new ErreurApi(400, `Durée maximale : ${REGLES.dureeMaxHeures} heures`);
if (d <= new Date()) throw new ErreurApi(400, 'Impossible de réserver dans le passé');
if (dateLocale(d) !== dateLocale(f) || heureLocale(d) < REGLES.ouverture || heureLocale(f) > REGLES.fermeture) {
throw new ErreurApi(400, `Le centre est ouvert de ${REGLES.ouverture} h à ${REGLES.fermeture} h`);
}
// 2) règles sur la salle
const salle = await Salle.findById(salleId).lean();
if (!salle) throw new ErreurApi(404, 'Salle introuvable');
if (!salle.active) throw new ErreurApi(409, "Cette salle n'est pas disponible à la réservation");
if (participants > salle.capacite) throw new ErreurApi(400, `Capacité de la salle dépassée (${salle.capacite} places)`);
// 3) règles sur l'utilisateur
const aVenir = await Reservation.countDocuments({ utilisateur: moi.id, statut: 'confirmee', debut: { $gt: new Date() } });
if (aVenir >= REGLES.maxAVenir) throw new ErreurApi(409, `Vous avez déjà ${REGLES.maxAVenir} réservations à venir`);
// 4) pas de chevauchement : une réservation existante commence avant notre fin ET finit après notre début
const conflit = await Reservation.findOne({ salle: salleId, statut: 'confirmee', debut: { $lt: f }, fin: { $gt: d } }).lean();
if (conflit) {
throw new ErreurApi(409, 'Créneau déjà réservé', { conflit: { debut: conflit.debut, fin: conflit.fin } });
}
const reservation = await Reservation.create({ salle: salleId, utilisateur: moi.id, debut: d, fin: f, objet, participants });
const resultat = await reservation.populate('salle', 'nom');
bus.emit('reservation:modifiee', { salle: salleId, date: dateLocale(d) });
return resultat.toObject();
}
export async function mesReservations(moi, { aVenir }) {
const filtre = { utilisateur: moi.id };
if (aVenir) Object.assign(filtre, { statut: 'confirmee', fin: { $gt: new Date() } });
return Reservation.find(filtre).sort({ debut: aVenir ? 1 : -1 }).limit(100).populate('salle', 'nom etage').lean();
}
export async function toutes({ date, salle }) {
const filtre = {};
if (salle) { verifierId(salle, 'Salle'); filtre.salle = salle; }
if (date) filtre.debut = { $gte: new Date(date) };
return Reservation.find(filtre).sort({ debut: 1 }).limit(200)
.populate('salle', 'nom').populate('utilisateur', 'nom email').lean();
}
export async function annuler(id, moi) {
verifierId(id);
const r = await Reservation.findById(id);
// 404 aussi si elle appartient à un autre : on ne révèle pas son existence
if (!r || (!r.utilisateur.equals(moi.id) && moi.role !== 'admin')) throw new ErreurApi(404, 'Réservation introuvable');
if (r.statut === 'annulee') throw new ErreurApi(409, 'Réservation déjà annulée');
if (r.debut <= new Date()) throw new ErreurApi(409, 'Une réservation commencée ou passée ne peut plus être annulée');
r.statut = 'annulee';
await r.save();
bus.emit('reservation:modifiee', { salle: r.salle.toString(), date: dateLocale(r.debut) });
return r.toObject();
}
L'ordre des contrôles est volontaire : d'abord les règles qui ne demandent aucune requête (dates, durée, horaires), puis celles qui lisent la base. Une requête mal formée est ainsi refusée sans solliciter MongoDB.
src/services/salles.service.js et auth.service.js
📄 src/services/salles.service.js
import mongoose from 'mongoose';
import { Salle } from '../models/salle.js';
import { Reservation } from '../models/reservation.js';
import { ErreurApi } from '../utils/erreur-api.js';
import { journeeLocale } from '../utils/dates.js';
export function verifierId(id, quoi = 'Identifiant') {
if (!mongoose.isValidObjectId(id)) throw new ErreurApi(400, `${quoi} invalide`);
}
export async function lister({ capaciteMin, equipement, toutes }) {
const filtre = toutes ? {} : { active: true };
if (capaciteMin) filtre.capacite = { $gte: Number(capaciteMin) };
if (equipement) filtre.equipements = equipement;
return Salle.find(filtre).sort({ etage: 1, nom: 1 }).lean();
}
export async function trouver(id) {
verifierId(id);
const salle = await Salle.findById(id).lean();
if (!salle) throw new ErreurApi(404, 'Salle introuvable');
return salle;
}
export async function creer(donnees) {
if (await Salle.exists({ nom: donnees.nom })) throw new ErreurApi(409, 'Une salle porte déjà ce nom');
return (await Salle.create(donnees)).toObject();
}
export async function modifier(id, donnees) {
verifierId(id);
const champs = ['nom', 'capacite', 'equipements', 'etage', 'active'];
const modifs = Object.fromEntries(Object.entries(donnees).filter(([k]) => champs.includes(k)));
const salle = await Salle.findByIdAndUpdate(id, modifs, { returnDocument: 'after', runValidators: true }).lean();
if (!salle) throw new ErreurApi(404, 'Salle introuvable');
return salle;
}
// Planning d'une salle pour une journée : créneaux occupés, sans révéler qui a réservé (sauf ses propres réservations)
export async function planning(id, date, moi) {
const salle = await trouver(id);
const jour = journeeLocale(date);
if (!jour) throw new ErreurApi(400, 'Date attendue au format AAAA-MM-JJ');
const reservations = await Reservation.find({ salle: id, statut: 'confirmee', debut: { $lt: jour.fin }, fin: { $gt: jour.debut } })
.sort({ debut: 1 }).lean();
return {
salle, date,
creneaux: reservations.map((r) => ({
id: r._id, debut: r.debut, fin: r.fin,
objet: r.utilisateur.equals(moi.id) || moi.role === 'admin' ? r.objet : 'Réservé',
aMoi: r.utilisateur.equals(moi.id),
})),
};
}
📄 src/services/auth.service.js
import bcrypt from 'bcrypt';
import jwt from 'jsonwebtoken';
import { Utilisateur } from '../models/utilisateur.js';
import { ErreurApi } from '../utils/erreur-api.js';
import { config } from '../config/index.js';
const profil = (u) => ({ id: u.id, nom: u.nom, email: u.email, role: u.role });
export async function inscrire({ nom, email, motDePasse }) {
if (await Utilisateur.exists({ email: email.toLowerCase() })) throw new ErreurApi(409, 'Cet e-mail est déjà utilisé');
const u = await Utilisateur.create({ nom, email, motDePasse: await bcrypt.hash(motDePasse, config.coutBcrypt) });
return profil(u);
}
export async function connecter({ email, motDePasse }) {
const u = await Utilisateur.findOne({ email: email.toLowerCase() }).select('+motDePasse');
if (!u || !(await bcrypt.compare(motDePasse, u.motDePasse))) throw new ErreurApi(401, 'Identifiants incorrects');
const jeton = jwt.sign({ sub: u.id, role: u.role, nom: u.nom }, config.jwtSecret, { expiresIn: config.jwtDuree });
return { jeton, utilisateur: profil(u) };
}
export async function moi(id) {
const u = await Utilisateur.findById(id);
if (!u) throw new ErreurApi(401, 'Compte introuvable');
return profil(u);
}
export function verifierJeton(jeton) {
return jwt.verify(jeton, config.jwtSecret);
}
Routes, contrôleurs et middlewares
📄 src/app.js
import express from 'express';
import helmet from 'helmet';
import cors from 'cors';
import morgan from 'morgan';
import { routesSalles } from './routes/salles.routes.js';
import { routesReservations } from './routes/reservations.routes.js';
import { routesAuth } from './routes/auth.routes.js';
import { routeIntrouvable, gererErreurs } from './middlewares/erreurs.js';
import { config } from './config/index.js';
import pkg from '../package.json' with { type: 'json' };
// Crée l'application SANS la démarrer : server.js l'écoute, les tests l'utilisent directement
export function creerApp() {
const app = express();
if (config.trustProxy) app.set('trust proxy', config.trustProxy);
app.use(helmet());
app.use(cors({ origin: config.corsOrigines }));
if (config.env === 'development') app.use(morgan('dev'));
if (config.env === 'production') app.use(morgan('combined'));
app.use(express.json({ limit: '10kb' }));
app.use(express.static('public'));
app.get('/api/sante', (req, res) => res.json({ statut: 'ok', version: pkg.version, uptime: Math.round(process.uptime()) }));
app.use('/api/auth', routesAuth);
app.use('/api/salles', routesSalles);
app.use('/api/reservations', routesReservations);
// la SPA utilise des adresses en #/… : la partie après # n'est jamais envoyée au serveur
app.use(routeIntrouvable);
app.use(gererErreurs);
return app;
}
📄 src/routes/reservations.routes.js
import { Router } from 'express';
import { body } from 'express-validator';
import * as ctrl from '../controllers/reservations.controller.js';
import { authentifier, autoriser } from '../middlewares/auth.js';
import { valider } from '../middlewares/valider.js';
export const routesReservations = Router();
routesReservations.use(authentifier);
routesReservations.post('/',
body('salle').notEmpty().withMessage('La salle est obligatoire'),
body('debut').isISO8601().withMessage('Début : date ISO 8601'),
body('fin').isISO8601().withMessage('Fin : date ISO 8601'),
body('objet').trim().isLength({ min: 3, max: 120 }).withMessage('Objet : 3 à 120 caractères'),
body('participants').optional().isInt({ min: 1 }).toInt(),
valider, ctrl.creer);
routesReservations.get('/miennes', ctrl.miennes);
routesReservations.get('/', autoriser('admin'), ctrl.toutes);
routesReservations.patch('/:id/annuler', ctrl.annuler);
📄 src/routes/salles.routes.js
import { Router } from 'express';
import { body } from 'express-validator';
import * as ctrl from '../controllers/salles.controller.js';
import { authentifier, autoriser } from '../middlewares/auth.js';
import { valider } from '../middlewares/valider.js';
const regles = [
body('nom').trim().notEmpty().withMessage('Le nom est obligatoire'),
body('capacite').isInt({ min: 1, max: 500 }).withMessage('Capacité : entier de 1 à 500'),
body('equipements').optional().isArray().withMessage('Équipements : tableau de textes'),
body('etage').optional().isInt({ min: -2, max: 20 }),
];
export const routesSalles = Router();
routesSalles.use(authentifier); // toutes les routes des salles exigent une connexion
routesSalles.get('/', ctrl.lister);
routesSalles.get('/:id', ctrl.trouver);
routesSalles.get('/:id/planning', ctrl.planning);
routesSalles.post('/', autoriser('admin'), regles, valider, ctrl.creer);
routesSalles.patch('/:id', autoriser('admin'), ctrl.modifier);
📄 src/routes/auth.routes.js
import { Router } from 'express';
import { body } from 'express-validator';
import rateLimit from 'express-rate-limit';
import * as ctrl from '../controllers/auth.controller.js';
import { valider } from '../middlewares/valider.js';
import { authentifier } from '../middlewares/auth.js';
const limiteConnexion = rateLimit({ windowMs: 15 * 60 * 1000, limit: 10, standardHeaders: 'draft-8', legacyHeaders: false,
message: { erreur: 'Trop de tentatives, réessayez dans 15 minutes' } });
export const routesAuth = Router();
routesAuth.post('/inscription',
body('nom').trim().isLength({ min: 2, max: 80 }).withMessage('Nom : 2 à 80 caractères'),
body('email').isEmail().withMessage('E-mail invalide'),
body('motDePasse').isStrongPassword({ minLength: 8, minSymbols: 0 }).withMessage('8 caractères minimum, avec majuscule, minuscule et chiffre'),
valider, ctrl.inscription);
routesAuth.post('/connexion', limiteConnexion, body('email').isEmail(), body('motDePasse').notEmpty(), valider, ctrl.connexion);
routesAuth.get('/moi', authentifier, ctrl.moi);
📄 src/controllers/reservations.controller.js
import * as service from '../services/reservations.service.js';
export const creer = async (req, res) => res.status(201).json(await service.creer(req.body, req.utilisateur));
export const miennes = async (req, res) => res.json(await service.mesReservations(req.utilisateur, { aVenir: req.query.aVenir === 'oui' }));
export const toutes = async (req, res) => res.json(await service.toutes(req.query));
export const annuler = async (req, res) => res.json(await service.annuler(req.params.id, req.utilisateur));
📄 src/controllers/salles.controller.js
import * as service from '../services/salles.service.js';
export const lister = async (req, res) =>
res.json(await service.lister({ ...req.query, toutes: req.utilisateur.role === 'admin' && req.query.toutes === 'oui' }));
export const trouver = async (req, res) => res.json(await service.trouver(req.params.id));
export const creer = async (req, res) => res.status(201).json(await service.creer(req.body));
export const modifier = async (req, res) => res.json(await service.modifier(req.params.id, req.body));
export const planning = async (req, res) => res.json(await service.planning(req.params.id, req.query.date, req.utilisateur));
📄 src/controllers/auth.controller.js
import * as service from '../services/auth.service.js';
export const inscription = async (req, res) => res.status(201).json(await service.inscrire(req.body));
export const connexion = async (req, res) => res.json(await service.connecter(req.body));
export const moi = async (req, res) => res.json(await service.moi(req.utilisateur.id));
📄 src/middlewares/auth.js
import { verifierJeton } from '../services/auth.service.js';
import { ErreurApi } from '../utils/erreur-api.js';
export function authentifier(req, res, next) {
const [type, jeton] = (req.headers.authorization ?? '').split(' ');
if (type !== 'Bearer' || !jeton) return next(new ErreurApi(401, 'Authentification requise'));
try {
const charge = verifierJeton(jeton);
req.utilisateur = { id: charge.sub, role: charge.role, nom: charge.nom };
next();
} catch {
next(new ErreurApi(401, 'Jeton invalide ou expiré'));
}
}
export const autoriser = (...roles) => (req, res, next) =>
roles.includes(req.utilisateur?.role) ? next() : next(new ErreurApi(403, 'Accès refusé'));
📄 src/middlewares/valider.js
import { validationResult } from 'express-validator';
import { ErreurApi } from '../utils/erreur-api.js';
// À placer après les règles express-validator d'une route
export function valider(req, res, next) {
const erreurs = validationResult(req);
if (!erreurs.isEmpty()) {
return next(new ErreurApi(400, 'Données invalides', erreurs.array().map((e) => ({ champ: e.path, message: e.msg }))));
}
next();
}
📄 src/middlewares/erreurs.js
import mongoose from 'mongoose';
import { ErreurApi } from '../utils/erreur-api.js';
export function routeIntrouvable(req, res, next) {
next(new ErreurApi(404, `Route introuvable : ${req.method} ${req.originalUrl}`));
}
// Middleware d'erreurs : 4 paramètres, déclaré en dernier
// eslint-disable-next-line no-unused-vars
export function gererErreurs(err, req, res, next) {
if (err instanceof mongoose.Error.ValidationError) {
const details = Object.values(err.errors).map((e) => ({ champ: e.path, message: e.message }));
return res.status(400).json({ erreur: 'Données invalides', details });
}
if (err.type === 'entity.parse.failed') return res.status(400).json({ erreur: 'JSON mal formé' });
if (err instanceof ErreurApi) {
return res.status(err.statut).json({ erreur: err.message, ...(err.details && { details: err.details }) });
}
console.error(err);
res.status(500).json({ erreur: 'Erreur interne du serveur' });
}
📄 src/utils/erreur-api.js
// Erreur « attendue » : un code HTTP et un message pour le client
export class ErreurApi extends Error {
constructor(statut, message, details) {
super(message);
this.statut = statut;
this.details = details;
}
}
server.js, temps réel et scripts
📄 src/server.js
import { createServer } from 'node:http';
import { creerApp } from './app.js';
import { config } from './config/index.js';
import { connecterBase, deconnecterBase } from './config/db.js';
import { brancherTempsReel } from './temps-reel.js';
await connecterBase(config.mongoUri);
const app = creerApp();
const serveur = createServer(app); // un serveur HTTP partagé par Express et Socket.IO
const io = brancherTempsReel(serveur);
serveur.listen(config.port, config.hote, () => {
console.log(`API démarrée sur http://${config.hote}:${config.port} (${config.env})`);
});
// Arrêt propre (Ctrl+C, PM2, Docker) : on ferme les connexions avant de quitter
for (const signal of ['SIGINT', 'SIGTERM']) {
process.on(signal, async () => {
console.log(`${signal} reçu : arrêt en cours…`);
io.close();
serveur.close(async () => {
await deconnecterBase();
process.exit(0);
});
});
}
📄 src/evenements.js
import { EventEmitter } from 'node:events';
// Bus d'événements de l'application : les services annoncent, d'autres parties écoutent (ex. Socket.IO)
export const bus = new EventEmitter();
📄 src/temps-reel.js
import { Server } from 'socket.io';
import { bus } from './evenements.js';
import { verifierJeton } from './services/auth.service.js';
import { config } from './config/index.js';
// Bonus : le planning affiché se met à jour quand quelqu'un réserve ou annule
export function brancherTempsReel(serveurHttp) {
const io = new Server(serveurHttp, { cors: { origin: config.corsOrigines } });
io.use((socket, next) => {
try {
socket.data.utilisateur = verifierJeton(socket.handshake.auth?.jeton ?? '');
next();
} catch {
next(new Error('Authentification requise'));
}
});
bus.on('reservation:modifiee', (donnees) => io.emit('planning:modifie', donnees));
return io;
}
📄 scripts/seed.js
// Données de démonstration (développement uniquement) : npm run seed
import bcrypt from 'bcrypt';
import { connecterBase, deconnecterBase } from '../src/config/db.js';
import { config } from '../src/config/index.js';
import { Salle } from '../src/models/salle.js';
import { Reservation } from '../src/models/reservation.js';
import { Utilisateur } from '../src/models/utilisateur.js';
import { journeeLocale, dateLocale } from '../src/utils/dates.js';
if (config.env === 'production') throw new Error('Le seed est interdit en production');
await connecterBase(config.mongoUri);
await Promise.all([Salle.deleteMany({}), Reservation.deleteMany({}), Utilisateur.deleteMany({})]);
const hash = (mdp) => bcrypt.hash(mdp, config.coutBcrypt);
const [admin, sami, lina] = await Utilisateur.create([
{ nom: 'Administration', email: 'admin@exemple.tn', role: 'admin', motDePasse: await hash('Admin2026!') },
{ nom: 'Sami Ben Ali', email: 'sami@exemple.tn', motDePasse: await hash('Sami2026!') },
{ nom: 'Lina Trabelsi', email: 'lina@exemple.tn', motDePasse: await hash('Lina2026!') },
]);
const salles = await Salle.create([
{ nom: 'Carthage', capacite: 30, etage: 0, equipements: ['vidéoprojecteur', 'tableau blanc', 'sonorisation'] },
{ nom: 'Dougga', capacite: 16, etage: 1, equipements: ['vidéoprojecteur', 'tableau blanc'] },
{ nom: 'Kerkouane', capacite: 8, etage: 1, equipements: ['écran tactile', 'visioconférence'] },
{ nom: 'Laboratoire Web', capacite: 20, etage: 2, equipements: ['20 postes', 'vidéoprojecteur'] },
{ nom: 'Utique', capacite: 12, etage: 2, equipements: ['tableau blanc'], active: false },
]);
// réservations sur les deux prochains jours ouvrés, à heures locales fixes
const demain = new Date(Date.now() + 24 * 3600 * 1000);
const j1 = journeeLocale(dateLocale(demain)).debut;
const h = (jour, heure) => new Date(jour.getTime() + heure * 3600 * 1000);
await Reservation.create([
{ salle: salles[0]._id, utilisateur: sami._id, debut: h(j1, 9), fin: h(j1, 11), objet: 'Cours Node.js — groupe DEV201', participants: 24 },
{ salle: salles[0]._id, utilisateur: lina._id, debut: h(j1, 14), fin: h(j1, 16), objet: 'Jury de soutenance', participants: 6 },
{ salle: salles[1]._id, utilisateur: lina._id, debut: h(j1, 10), fin: h(j1, 12), objet: 'Atelier Git et GitHub', participants: 12 },
{ salle: salles[2]._id, utilisateur: admin._id, debut: h(j1, 8.5), fin: h(j1, 9.5), objet: 'Réunion pédagogique', participants: 5 },
]);
console.log(`${await Utilisateur.countDocuments()} utilisateurs, ${await Salle.countDocuments()} salles, ${await Reservation.countDocuments()} réservations`);
await deconnecterBase();
📄 scripts/creer-admin.js
// Premier administrateur en production :
// ADMIN_NOM=... ADMIN_EMAIL=... ADMIN_MOT_DE_PASSE=... npm run admin:creer
import bcrypt from 'bcrypt';
import { connecterBase, deconnecterBase } from '../src/config/db.js';
import { config } from '../src/config/index.js';
import { Utilisateur } from '../src/models/utilisateur.js';
const email = process.env.ADMIN_EMAIL?.toLowerCase();
const motDePasse = process.env.ADMIN_MOT_DE_PASSE ?? '';
if (!email || motDePasse.length < 12) {
console.error('ADMIN_EMAIL et ADMIN_MOT_DE_PASSE (12 caractères minimum) sont obligatoires');
process.exit(1);
}
await connecterBase(config.mongoUri);
if (await Utilisateur.exists({ email })) {
console.log(`Le compte ${email} existe déjà : rien à faire`);
} else {
await Utilisateur.create({ nom: process.env.ADMIN_NOM ?? 'Administration', email, role: 'admin', motDePasse: await bcrypt.hash(motDePasse, 12) });
console.log(`Compte administrateur ${email} créé`);
}
await deconnecterBase();
Les tests
📄 test/aide.js
// Outils communs aux tests d'intégration (ce fichier n'est pas un test)
import mongoose from 'mongoose';
import bcrypt from 'bcrypt';
import request from 'supertest';
import { creerApp } from '../src/app.js';
import { Utilisateur } from '../src/models/utilisateur.js';
import { journeeLocale, dateLocale } from '../src/utils/dates.js';
export const app = creerApp();
// une base par fichier de test : node --test exécute les fichiers en parallèle
export async function ouvrirBase(nom) {
await mongoose.connect(`${process.env.MONGODB_URI}_${nom}`);
await mongoose.connection.dropDatabase();
}
export async function fermerBase() {
await mongoose.connection.dropDatabase();
await mongoose.disconnect();
}
// crée un compte et renvoie son jeton
export async function jetonPour(nom, role = 'utilisateur') {
const email = `${nom}@test.tn`;
await Utilisateur.create({ nom, email, role, motDePasse: await bcrypt.hash('MotDePasse1', 4) });
const res = await request(app).post('/api/auth/connexion').send({ email, motDePasse: 'MotDePasse1' });
return res.body.jeton;
}
// créneau en heure locale du centre, dans N jours : creneau(2, 9, 11) → après-demain de 9 h à 11 h
export function creneau(dansJours, heureDebut, heureFin) {
const jour = journeeLocale(dateLocale(new Date(Date.now() + dansJours * 86400000))).debut.getTime();
return { debut: new Date(jour + heureDebut * 3600000).toISOString(), fin: new Date(jour + heureFin * 3600000).toISOString() };
}
export const avec = (jeton) => ({ Authorization: `Bearer ${jeton}` });
📄 test/reservations.test.js
import { describe, it, before, after, beforeEach } from 'node:test';
import assert from 'node:assert/strict';
import request from 'supertest';
import { app, ouvrirBase, fermerBase, jetonPour, creneau, avec } from './aide.js';
import { Salle } from '../src/models/salle.js';
import { Reservation } from '../src/models/reservation.js';
describe('API /api/reservations', () => {
let sami, lina, admin, salle;
const reserver = (jeton, corps) => request(app).post('/api/reservations').set(avec(jeton)).send({ salle: salle.id, objet: 'Cours', ...corps });
before(async () => {
await ouvrirBase('reservations');
[sami, lina, admin] = await Promise.all([jetonPour('sami'), jetonPour('lina'), jetonPour('admin', 'admin')]);
});
after(fermerBase);
beforeEach(async () => {
await Promise.all([Salle.deleteMany({}), Reservation.deleteMany({})]);
salle = await Salle.create({ nom: 'Carthage', capacite: 20 });
});
describe('création', () => {
it('201 pour un créneau libre', async () => {
const res = await reserver(sami, creneau(1, 9, 11)).expect(201);
assert.equal(res.body.salle.nom, 'Carthage');
assert.equal(res.body.statut, 'confirmee');
});
it('409 si le créneau chevauche une réservation existante', async () => {
await reserver(sami, creneau(1, 9, 11)).expect(201);
const res = await reserver(lina, creneau(1, 10, 12)).expect(409);
assert.equal(res.body.erreur, 'Créneau déjà réservé');
assert.ok(res.body.details.conflit.debut);
});
it('accepte deux créneaux qui se touchent (fin = début)', async () => {
await reserver(sami, creneau(1, 9, 11)).expect(201);
await reserver(lina, creneau(1, 11, 12)).expect(201);
});
it('400 pour un créneau dans le passé', () => reserver(sami, creneau(-1, 9, 10)).expect(400));
for (const [cas, c, message] of [
['avant l\'ouverture', creneau(1, 7, 9), 'Le centre est ouvert de 8 h à 19 h'],
['après la fermeture', creneau(1, 18, 20), 'Le centre est ouvert de 8 h à 19 h'],
['plus de 4 heures', creneau(1, 8, 13), 'Durée maximale : 4 heures'],
['moins de 30 minutes', creneau(1, 9, 9.25), 'Durée minimale : 30 minutes'],
['fin avant le début', creneau(1, 11, 9), 'La fin doit être après le début'],
]) {
it(`400 : ${cas}`, async () => {
const res = await reserver(sami, c).expect(400);
assert.equal(res.body.erreur, message);
});
}
it('400 si les participants dépassent la capacité', () => reserver(sami, { ...creneau(1, 9, 10), participants: 21 }).expect(400));
it('409 pour une salle désactivée', async () => {
await Salle.updateOne({ _id: salle.id }, { active: false });
await reserver(sami, creneau(1, 9, 10)).expect(409);
});
it('409 au-delà de 5 réservations à venir', async () => {
for (let h = 8; h < 18; h += 2) await reserver(sami, creneau(2, h, h + 1)).expect(201);
const res = await reserver(sami, creneau(3, 9, 10)).expect(409);
assert.match(res.body.erreur, /5 réservations à venir/);
});
it('401 sans jeton', () => request(app).post('/api/reservations').send(creneau(1, 9, 10)).expect(401));
});
describe('annulation', () => {
it("l'auteur annule, et le créneau redevient libre", async () => {
const { body } = await reserver(sami, creneau(1, 9, 11));
const res = await request(app).patch(`/api/reservations/${body._id}/annuler`).set(avec(sami)).expect(200);
assert.equal(res.body.statut, 'annulee');
await reserver(lina, creneau(1, 9, 11)).expect(201);
});
it("404 pour la réservation d'un autre utilisateur", async () => {
const { body } = await reserver(sami, creneau(1, 9, 11));
await request(app).patch(`/api/reservations/${body._id}/annuler`).set(avec(lina)).expect(404);
});
it("l'administration peut annuler n'importe quelle réservation", async () => {
const { body } = await reserver(sami, creneau(1, 9, 11));
await request(app).patch(`/api/reservations/${body._id}/annuler`).set(avec(admin)).expect(200);
});
it('409 pour une réservation déjà annulée', async () => {
const { body } = await reserver(sami, creneau(1, 9, 11));
await request(app).patch(`/api/reservations/${body._id}/annuler`).set(avec(sami)).expect(200);
await request(app).patch(`/api/reservations/${body._id}/annuler`).set(avec(sami)).expect(409);
});
});
describe('consultation', () => {
it('GET /miennes ne renvoie que ses propres réservations', async () => {
await reserver(sami, creneau(1, 9, 10));
await reserver(lina, creneau(1, 10, 11));
const res = await request(app).get('/api/reservations/miennes').set(avec(sami)).expect(200);
assert.equal(res.body.length, 1);
});
it("GET / est réservé à l'administration", async () => {
await request(app).get('/api/reservations').set(avec(sami)).expect(403);
await request(app).get('/api/reservations').set(avec(admin)).expect(200);
});
});
});
test/salles.test.js, auth.test.js et dates.test.js
📄 test/salles.test.js
import { describe, it, before, after } from 'node:test';
import assert from 'node:assert/strict';
import request from 'supertest';
import { app, ouvrirBase, fermerBase, jetonPour, creneau, avec } from './aide.js';
import { Salle } from '../src/models/salle.js';
import { dateLocale } from '../src/utils/dates.js';
describe('API /api/salles', () => {
let sami, lina, admin, salle;
before(async () => {
await ouvrirBase('salles');
[sami, lina, admin] = await Promise.all([jetonPour('sami'), jetonPour('lina'), jetonPour('admin', 'admin')]);
salle = await Salle.create({ nom: 'Dougga', capacite: 16, equipements: ['vidéoprojecteur'] });
await Salle.create({ nom: 'Utique', capacite: 12, active: false });
});
after(fermerBase);
it('401 sans jeton', () => request(app).get('/api/salles').expect(401));
it('ne liste que les salles actives', async () => {
const res = await request(app).get('/api/salles').set(avec(sami)).expect(200);
assert.deepEqual(res.body.map((s) => s.nom), ['Dougga']);
});
it("l'administration voit aussi les salles désactivées", async () => {
const res = await request(app).get('/api/salles?toutes=oui').set(avec(admin)).expect(200);
assert.equal(res.body.length, 2);
});
it('création : 403 pour un utilisateur, 201 pour un administrateur, 409 pour un nom existant', async () => {
const nouvelle = { nom: 'Carthage', capacite: 30, equipements: ['tableau blanc'] };
await request(app).post('/api/salles').set(avec(sami)).send(nouvelle).expect(403);
await request(app).post('/api/salles').set(avec(admin)).send(nouvelle).expect(201);
await request(app).post('/api/salles').set(avec(admin)).send(nouvelle).expect(409);
});
it("le planning masque l'objet des réservations des autres", async () => {
const c = creneau(1, 9, 11);
await request(app).post('/api/reservations').set(avec(sami)).send({ salle: salle.id, objet: 'Entretien confidentiel', ...c }).expect(201);
const date = dateLocale(new Date(c.debut));
const vuParLina = await request(app).get(`/api/salles/${salle.id}/planning?date=${date}`).set(avec(lina)).expect(200);
assert.equal(vuParLina.body.creneaux[0].objet, 'Réservé');
const vuParSami = await request(app).get(`/api/salles/${salle.id}/planning?date=${date}`).set(avec(sami)).expect(200);
assert.equal(vuParSami.body.creneaux[0].objet, 'Entretien confidentiel');
assert.equal(vuParSami.body.creneaux[0].aMoi, true);
});
it('planning : 400 pour une date mal formée', () =>
request(app).get(`/api/salles/${salle.id}/planning?date=20-11-2026`).set(avec(sami)).expect(400));
});
📄 test/auth.test.js
import { describe, it, before, after } from 'node:test';
import assert from 'node:assert/strict';
import request from 'supertest';
import { app, ouvrirBase, fermerBase } from './aide.js';
describe('API /api/auth', () => {
before(() => ouvrirBase('auth'));
after(fermerBase);
const nadia = { nom: 'Nadia', email: 'nadia@exemple.tn', motDePasse: 'Nadia2026' };
it('inscription : 201, rôle utilisateur, pas de mot de passe renvoyé', async () => {
const res = await request(app).post('/api/auth/inscription').send({ ...nadia, role: 'admin' }).expect(201);
assert.equal(res.body.role, 'utilisateur'); // le rôle envoyé par le client est ignoré
assert.equal(res.body.motDePasse, undefined);
});
it('mot de passe trop faible : 400', () =>
request(app).post('/api/auth/inscription').send({ ...nadia, email: 'autre@exemple.tn', motDePasse: 'azerty' }).expect(400));
it('e-mail déjà utilisé : 409', () => request(app).post('/api/auth/inscription').send(nadia).expect(409));
it('connexion puis /moi', async () => {
const { body } = await request(app).post('/api/auth/connexion').send({ email: nadia.email, motDePasse: nadia.motDePasse }).expect(200);
const res = await request(app).get('/api/auth/moi').set('Authorization', `Bearer ${body.jeton}`).expect(200);
assert.equal(res.body.email, nadia.email);
});
it('mauvais mot de passe : 401', () =>
request(app).post('/api/auth/connexion').send({ email: nadia.email, motDePasse: 'Faux2026' }).expect(401));
});
📄 test/dates.test.js
import { describe, it } from 'node:test';
import assert from 'node:assert/strict';
import { journeeLocale, heureLocale, dateLocale } from '../src/utils/dates.js';
describe('dates dans le fuseau du centre (Africa/Tunis, UTC+1)', () => {
it('une journée locale commence à 23 h UTC la veille', () => {
const { debut, fin } = journeeLocale('2026-11-20');
assert.equal(debut.toISOString(), '2026-11-19T23:00:00.000Z');
assert.equal(fin.toISOString(), '2026-11-20T23:00:00.000Z');
});
it('refuse un format de date incorrect', () => {
for (const texte of ['20/11/2026', '2026-11', '', undefined]) assert.equal(journeeLocale(texte), null);
});
it("donne l'heure et la date locales d'un instant UTC", () => {
const instant = new Date('2026-11-20T23:30:00Z'); // 0 h 30 le 21 à Tunis
assert.equal(heureLocale(instant), 0.5);
assert.equal(dateLocale(instant), '2026-11-21');
});
});
Résultat réellement obtenu :
$ npm test
> reservation-salles@1.0.0 test
> node --env-file=.env.test --test "test/**/*.test.js"
▶ API /api/auth
✔ inscription : 201, rôle utilisateur, pas de mot de passe renvoyé (81.471361ms)
✔ mot de passe trop faible : 400 (9.156719ms)
✔ e-mail déjà utilisé : 409 (7.958212ms)
✔ connexion puis /moi (25.310955ms)
✔ mauvais mot de passe : 401 (7.876234ms)
✔ API /api/auth (210.408068ms)
▶ dates dans le fuseau du centre (Africa/Tunis, UTC+1)
✔ une journée locale commence à 23 h UTC la veille (120.300833ms)
✔ refuse un format de date incorrect (0.368708ms)
✔ donne l'heure et la date locales d'un instant UTC (0.716132ms)
✔ dates dans le fuseau du centre (Africa/Tunis, UTC+1) (127.114291ms)
▶ API /api/reservations
▶ création
✔ 201 pour un créneau libre (40.08592ms)
✔ 409 si le créneau chevauche une réservation existante (34.748239ms)
✔ accepte deux créneaux qui se touchent (fin = début) (27.658358ms)
✔ 400 pour un créneau dans le passé (9.716244ms)
✔ 400 : avant l'ouverture (7.946105ms)
✔ 400 : après la fermeture (7.200153ms)
✔ 400 : plus de 4 heures (6.046308ms)
✔ 400 : moins de 30 minutes (5.593104ms)
✔ 400 : fin avant le début (7.058822ms)
✔ 400 si les participants dépassent la capacité (10.248756ms)
✔ 409 pour une salle désactivée (10.565517ms)
✔ 409 au-delà de 5 réservations à venir (87.006767ms)
✔ 401 sans jeton (10.75173ms)
✔ création (267.029452ms)
▶ annulation
✔ l'auteur annule, et le créneau redevient libre (39.660724ms)
✔ 404 pour la réservation d'un autre utilisateur (21.22746ms)
✔ l'administration peut annuler n'importe quelle réservation (17.935575ms)
✔ 409 pour une réservation déjà annulée (21.795667ms)
✔ annulation (101.229198ms)
▶ consultation
✔ GET /miennes ne renvoie que ses propres réservations (30.635969ms)
✔ GET / est réservé à l'administration (9.233567ms)
✔ consultation (40.247991ms)
✔ API /api/reservations (592.768373ms)
▶ API /api/salles
✔ 401 sans jeton (13.522087ms)
✔ ne liste que les salles actives (10.499787ms)
✔ l'administration voit aussi les salles désactivées (5.332074ms)
✔ création : 403 pour un utilisateur, 201 pour un administrateur, 409 pour un nom existant (15.505113ms)
✔ le planning masque l'objet des réservations des autres (62.762528ms)
✔ planning : 400 pour une date mal formée (4.254317ms)
✔ API /api/salles (300.489962ms)
ℹ tests 33
ℹ pass 33
ℹ fail 0
ℹ duration_ms 2822.988998
📄 .github/workflows/tests.yml
name: Tests
on:
push:
branches: [main]
pull_request:
jobs:
tests:
runs-on: ubuntu-24.04
services:
mongodb:
image: mongo:8.0
ports:
- 27017:27017
steps:
- uses: actions/checkout@v7
- uses: actions/setup-node@v7
with:
node-version: 24
cache: npm
- run: npm ci
# .env.test est versionné : il ne contient que des valeurs de test
- run: npm test
Le client SPA
📄 public/js/api.js
// Toutes les requêtes vers l'API passent par ici : jeton, JSON et erreurs au même endroit
const CLE = 'jeton';
export const session = {
get jeton() { return localStorage.getItem(CLE); },
get utilisateur() { return JSON.parse(localStorage.getItem('utilisateur') ?? 'null'); },
ouvrir({ jeton, utilisateur }) {
localStorage.setItem(CLE, jeton);
localStorage.setItem('utilisateur', JSON.stringify(utilisateur));
},
fermer() {
localStorage.removeItem(CLE);
localStorage.removeItem('utilisateur');
},
};
export class ErreurApi extends Error {
constructor(statut, corps) {
super(corps?.erreur ?? `Erreur ${statut}`);
this.statut = statut;
this.details = corps?.details;
}
}
export async function api(chemin, { methode = 'GET', corps } = {}) {
const entetes = { Accept: 'application/json' };
if (corps) entetes['Content-Type'] = 'application/json';
if (session.jeton) entetes.Authorization = `Bearer ${session.jeton}`;
const reponse = await fetch(`/api${chemin}`, { method: methode, headers: entetes, body: corps && JSON.stringify(corps) });
const donnees = reponse.status === 204 ? null : await reponse.json().catch(() => null);
if (reponse.status === 401 && session.jeton) {
session.fermer(); // jeton expiré : retour à la connexion
location.hash = '#/connexion';
}
if (!reponse.ok) throw new ErreurApi(reponse.status, donnees);
return donnees;
}
📄 public/js/app.js
// Routeur de la SPA : la partie après # de l'adresse choisit la vue, sans recharger la page
import { session } from './api.js';
import { h } from './dom.js';
import { vueConnexion, vueInscription } from './vues/connexion.js';
import { vueSalles } from './vues/salles.js';
import { vuePlanning } from './vues/planning.js';
import { vueMesReservations } from './vues/reservations.js';
import { vueAdmin } from './vues/admin.js';
const ROUTES = [
{ motif: /^#\/connexion$/, vue: vueConnexion, publique: true },
{ motif: /^#\/inscription$/, vue: vueInscription, publique: true },
{ motif: /^#\/salles$/, vue: vueSalles },
{ motif: /^#\/salles\/([a-f\d]{24})$/, vue: vuePlanning },
{ motif: /^#\/mes-reservations$/, vue: vueMesReservations },
{ motif: /^#\/admin$/, vue: vueAdmin, role: 'admin' },
];
let nettoyer = null; // fonction fournie par la vue précédente (ex. fermer Socket.IO)
async function afficher() {
const [adresse, requete = ''] = (location.hash || '#/salles').split('?');
const route = ROUTES.find((r) => r.motif.test(adresse));
const u = session.utilisateur;
if (!route) return (location.hash = '#/salles');
if (!route.publique && !u) return (location.hash = '#/connexion'); // route protégée
if (route.role && u.role !== route.role) return (location.hash = '#/salles');
nettoyer?.();
nettoyer = null;
dessinerMenu(adresse);
const conteneur = document.getElementById('vue');
conteneur.replaceChildren(h('p', { class: 'muet' }, 'Chargement…'));
const params = adresse.match(route.motif).slice(1);
nettoyer = await route.vue(conteneur, ...params, new URLSearchParams(requete));
}
function dessinerMenu(adresse) {
const u = session.utilisateur;
const lien = (href, texte) => h('a', { href, class: adresse === href ? 'actif' : null }, texte);
const menu = u
? [lien('#/salles', 'Salles'), lien('#/mes-reservations', 'Mes réservations'), u.role === 'admin' && lien('#/admin', 'Administration'),
h('span', { class: 'muet', style: { color: '#c7d2fe' } }, u.nom),
h('button', { class: 'secondaire', onclick: () => { session.fermer(); location.hash = '#/connexion'; } }, 'Déconnexion')]
: [lien('#/connexion', 'Connexion'), lien('#/inscription', 'Inscription')];
document.getElementById('menu').replaceChildren(...menu.filter(Boolean));
}
window.addEventListener('hashchange', afficher);
afficher();
📄 public/js/vues/planning.js
import { api, session } from '../api.js';
import { h, notifier, heure, jour, aujourdhui, versIso } from '../dom.js';
const OUVERTURE = 8, FERMETURE = 19, HAUTEUR = 40; // 40 px par heure
const horaires = [];
for (let m = OUVERTURE * 60; m <= FERMETURE * 60; m += 30) horaires.push(`${String(Math.floor(m / 60)).padStart(2, '0')}:${String(m % 60).padStart(2, '0')}`);
export async function vuePlanning(conteneur, id, params) {
const date = params.get('date') ?? aujourdhui();
const zonePlanning = h('div');
const titre = h('h1');
async function charger() {
const p = await api(`/salles/${id}/planning?date=${date}`);
titre.textContent = `Salle ${p.salle.nom} — ${jour(`${date}T12:00:00+01:00`)}`;
const journee = h('div', { class: 'journee', style: { height: `${(FERMETURE - OUVERTURE) * HAUTEUR}px` } },
...p.creneaux.map((c) => {
const debut = (new Date(c.debut) - new Date(`${date}T0${OUVERTURE}:00:00+01:00`)) / 3600000;
const duree = (new Date(c.fin) - new Date(c.debut)) / 3600000;
return h('div', { class: c.aMoi ? 'creneau moi' : 'creneau', style: { top: `${debut * HAUTEUR}px`, height: `${duree * HAUTEUR - 2}px` } },
h('strong', {}, `${heure(c.debut)} – ${heure(c.fin)}`), ' ', c.objet);
}));
const heures = h('div', { class: 'heures' }, ...Array.from({ length: FERMETURE - OUVERTURE }, (_, i) => h('div', {}, `${OUVERTURE + i} h`)));
zonePlanning.replaceChildren(
h('p', { class: 'muet' }, `${p.salle.capacite} places · ${p.salle.equipements.join(', ') || 'sans équipement'}`),
h('div', { class: 'planning' }, heures, journee),
h('p', { class: 'muet' }, '🟩 vos réservations · 🟥 créneaux occupés'));
}
const erreur = h('div', { class: 'erreur', hidden: true });
const select = (nom, defaut) => h('select', { name: nom }, ...horaires.map((t) => h('option', { value: t, selected: t === defaut }, t)));
const form = h('form', {
onsubmit: async (e) => {
e.preventDefault();
erreur.hidden = true;
const d = Object.fromEntries(new FormData(form));
try {
await api('/reservations', { methode: 'POST', corps: {
salle: id, debut: versIso(date, d.debut), fin: versIso(date, d.fin), objet: d.objet, participants: Number(d.participants),
} });
notifier('Réservation confirmée');
form.reset();
await charger();
} catch (err) {
const conflit = err.details?.conflit;
erreur.replaceChildren(err.message + (conflit ? ` (occupé de ${heure(conflit.debut)} à ${heure(conflit.fin)})` : ''),
...(Array.isArray(err.details) ? err.details.map((x) => h('div', {}, `• ${x.message}`)) : []));
erreur.hidden = false;
}
},
},
h('div', { class: 'ligne' }, h('label', {}, 'Début', select('debut', '09:00')), h('label', {}, 'Fin', select('fin', '10:00'))),
h('label', {}, 'Objet', h('input', { name: 'objet', required: true, minlength: 3, maxlength: 120, placeholder: 'Ex. : cours, réunion, examen' })),
h('label', {}, 'Participants', h('input', { name: 'participants', type: 'number', min: 1, value: 1 })),
erreur, h('button', { type: 'submit' }, 'Réserver ce créneau'));
const choixDate = h('input', { type: 'date', value: date, min: aujourdhui(),
onchange: (e) => { location.hash = `#/salles/${id}?date=${e.target.value}`; } });
conteneur.replaceChildren(
h('p', {}, h('a', { href: '#/salles' }, '← Toutes les salles')), titre,
h('div', { class: 'deux-colonnes' },
h('section', { class: 'carte' }, h('label', {}, 'Jour', choixDate), zonePlanning),
h('section', { class: 'carte' }, h('h2', {}, 'Nouvelle réservation'), form)));
await charger();
// Bonus temps réel : si quelqu'un réserve ou annule dans cette salle ce jour-là, le planning se met à jour
const socket = window.io?.({ auth: { jeton: session.jeton } });
socket?.on('planning:modifie', (m) => { if (m.salle === id && m.date === date) charger(); });
return () => socket?.close(); // appelé par le routeur en quittant la vue
}
index.html, style.css, dom.js et les autres vues
📄 public/index.html
<!doctype html>
<html lang="fr">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>Réservation de salles</title>
<link rel="stylesheet" href="/css/style.css">
</head>
<body>
<header class="barre">
<a href="#/salles" class="logo">🏫 Réservation de salles</a>
<nav id="menu"></nav>
</header>
<main id="vue" aria-live="polite"></main>
<div id="notification" role="status"></div>
<script src="/socket.io/socket.io.js"></script>
<script type="module" src="/js/app.js"></script>
</body>
</html>
📄 public/css/style.css
* { box-sizing: border-box; }
body { margin: 0; font-family: system-ui, sans-serif; color: #1e293b; background: #f1f5f9; }
.barre { display: flex; justify-content: space-between; align-items: center; padding: 12px 24px; background: #1e3a8a; color: #fff; }
.barre a { color: #fff; text-decoration: none; }
.logo { font-weight: 700; font-size: 18px; }
#menu { display: flex; gap: 16px; align-items: center; font-size: 15px; }
#menu .actif { border-bottom: 2px solid #fbbf24; }
main { max-width: 1050px; margin: 24px auto; padding: 0 16px; }
h1 { font-size: 24px; margin: 0 0 16px; }
.carte { background: #fff; border-radius: 10px; padding: 18px; box-shadow: 0 1px 3px rgb(0 0 0 / .08); }
.grille { display: grid; grid-template-columns: repeat(auto-fill, minmax(230px, 1fr)); gap: 16px; }
.salle h2 { margin: 0 0 6px; font-size: 18px; }
.muet { color: #64748b; font-size: 14px; }
.etiquettes { display: flex; flex-wrap: wrap; gap: 6px; margin: 10px 0; }
.etiquette { background: #e0e7ff; color: #3730a3; border-radius: 999px; padding: 2px 10px; font-size: 12px; }
form { display: grid; gap: 12px; }
label { display: grid; gap: 4px; font-size: 14px; font-weight: 600; }
input, select { padding: 8px 10px; border: 1px solid #cbd5e1; border-radius: 6px; font: inherit; }
button, .bouton { background: #2563eb; color: #fff; border: 0; border-radius: 6px; padding: 9px 16px; font: inherit; cursor: pointer; text-decoration: none; display: inline-block; text-align: center; }
button.secondaire { background: #e2e8f0; color: #1e293b; }
button.danger { background: #dc2626; }
button:disabled { opacity: .5; cursor: default; }
.ligne { display: flex; gap: 12px; flex-wrap: wrap; align-items: end; }
.ligne > * { flex: 1; min-width: 140px; }
.erreur { background: #fee2e2; color: #991b1b; padding: 10px 12px; border-radius: 6px; font-size: 14px; }
.connexion { max-width: 420px; margin: 40px auto; }
.planning { display: grid; grid-template-columns: 60px 1fr; margin-top: 12px; }
.heures div { height: 40px; font-size: 12px; color: #64748b; transform: translateY(-7px); }
.journee { position: relative; border-left: 1px solid #cbd5e1; background: repeating-linear-gradient(#fff 0 39px, #e2e8f0 39px 40px); }
.creneau { position: absolute; left: 8px; right: 8px; border-radius: 6px; padding: 4px 8px; font-size: 13px; background: #fecaca; border-left: 4px solid #dc2626; overflow: hidden; }
.creneau.moi { background: #bbf7d0; border-left-color: #16a34a; }
.deux-colonnes { display: grid; grid-template-columns: 1.3fr 1fr; gap: 20px; align-items: start; }
table { width: 100%; border-collapse: collapse; font-size: 14px; }
th, td { text-align: left; padding: 8px; border-bottom: 1px solid #e2e8f0; }
.statut-annulee { color: #94a3b8; text-decoration: line-through; }
#notification { position: fixed; bottom: 20px; right: 20px; background: #1e293b; color: #fff; padding: 10px 16px; border-radius: 8px; opacity: 0; transition: opacity .3s; }
#notification.visible { opacity: 1; }
@media (max-width: 760px) { .deux-colonnes { grid-template-columns: 1fr; } }
📄 public/js/dom.js
// Petit utilitaire pour créer des éléments sans innerHTML (pas d'injection de HTML)
export function h(balise, attributs = {}, ...enfants) {
const el = document.createElement(balise);
for (const [cle, valeur] of Object.entries(attributs ?? {})) {
if (valeur === false || valeur == null) continue;
if (cle.startsWith('on')) el.addEventListener(cle.slice(2), valeur);
else if (cle === 'class') el.className = valeur;
else if (cle === 'style') Object.assign(el.style, valeur);
else el.setAttribute(cle, valeur === true ? '' : valeur);
}
el.append(...enfants.flat().filter((e) => e != null && e !== false));
return el;
}
export function notifier(texte) {
const n = document.getElementById('notification');
n.textContent = texte;
n.classList.add('visible');
setTimeout(() => n.classList.remove('visible'), 2500);
}
const FUSEAU = 'Africa/Tunis';
export const heure = (iso) => new Date(iso).toLocaleTimeString('fr-FR', { hour: '2-digit', minute: '2-digit', timeZone: FUSEAU });
export const jour = (iso) => new Date(iso).toLocaleDateString('fr-FR', { weekday: 'long', day: 'numeric', month: 'long', timeZone: FUSEAU });
export const aujourdhui = () => new Date().toLocaleDateString('sv-SE', { timeZone: FUSEAU }); // AAAA-MM-JJ
// « 2026-11-20 » + « 09:30 » (heure de Tunis, UTC+1 toute l'année) → ISO 8601
export const versIso = (date, hhmm) => new Date(`${date}T${hhmm}:00+01:00`).toISOString();
📄 public/js/vues/connexion.js
import { api, session } from '../api.js';
import { h, notifier } from '../dom.js';
function formulaire({ titre, champs, bouton, lien, envoyer }) {
const erreur = h('div', { class: 'erreur', hidden: true });
const form = h('form', {
onsubmit: async (e) => {
e.preventDefault();
erreur.hidden = true;
const valider = form.querySelector('button');
valider.disabled = true;
try {
await envoyer(Object.fromEntries(new FormData(form)));
} catch (err) {
erreur.replaceChildren(err.message, ...(err.details?.map?.((d) => h('div', {}, `• ${d.message}`)) ?? []));
erreur.hidden = false;
} finally {
valider.disabled = false;
}
},
}, ...champs.map(([nom, libelle, type, autocomplete]) => h('label', {}, libelle, h('input', { name: nom, type, required: true, autocomplete }))),
erreur, h('button', { type: 'submit' }, bouton));
return h('div', { class: 'carte connexion' }, h('h1', {}, titre), form, h('p', { class: 'muet' }, lien));
}
export function vueConnexion(conteneur) {
conteneur.replaceChildren(formulaire({
titre: 'Connexion',
champs: [['email', 'E-mail', 'email', 'username'], ['motDePasse', 'Mot de passe', 'password', 'current-password']],
bouton: 'Se connecter',
lien: h('span', {}, 'Pas encore de compte ? ', h('a', { href: '#/inscription' }, 'Créer un compte')),
envoyer: async (donnees) => {
session.ouvrir(await api('/auth/connexion', { methode: 'POST', corps: donnees }));
notifier(`Bienvenue ${session.utilisateur.nom}`);
location.hash = '#/salles';
},
}));
}
export function vueInscription(conteneur) {
conteneur.replaceChildren(formulaire({
titre: 'Créer un compte',
champs: [['nom', 'Nom complet', 'text', 'name'], ['email', 'E-mail', 'email', 'username'], ['motDePasse', 'Mot de passe (8 caractères, majuscule, minuscule, chiffre)', 'password', 'new-password']],
bouton: "S'inscrire",
lien: h('span', {}, 'Déjà inscrit ? ', h('a', { href: '#/connexion' }, 'Se connecter')),
envoyer: async (donnees) => {
await api('/auth/inscription', { methode: 'POST', corps: donnees });
session.ouvrir(await api('/auth/connexion', { methode: 'POST', corps: { email: donnees.email, motDePasse: donnees.motDePasse } }));
location.hash = '#/salles';
},
}));
}
📄 public/js/vues/salles.js
import { api } from '../api.js';
import { h } from '../dom.js';
export async function vueSalles(conteneur, params) {
const filtres = { capaciteMin: params.get('capaciteMin') ?? '', equipement: params.get('equipement') ?? '' };
const requete = new URLSearchParams(Object.entries(filtres).filter(([, v]) => v)).toString();
const salles = await api(`/salles${requete ? '?' + requete : ''}`);
const form = h('form', {
class: 'carte ligne',
onsubmit: (e) => {
e.preventDefault();
const q = new URLSearchParams([...new FormData(e.target)].filter(([, v]) => v)).toString();
location.hash = '#/salles' + (q ? '?' + q : '');
},
},
h('label', {}, 'Places minimum', h('input', { name: 'capaciteMin', type: 'number', min: 1, value: filtres.capaciteMin })),
h('label', {}, 'Équipement', h('select', { name: 'equipement' },
h('option', { value: '' }, 'Tous'),
...['vidéoprojecteur', 'tableau blanc', 'visioconférence', 'écran tactile'].map((e) => h('option', { value: e, selected: e === filtres.equipement }, e)))),
h('button', { type: 'submit' }, 'Filtrer'));
conteneur.replaceChildren(
h('h1', {}, 'Salles disponibles'), form, h('p', { class: 'muet' }, `${salles.length} salle(s)`),
h('div', { class: 'grille' }, ...salles.map((s) => h('article', { class: 'carte salle' },
h('h2', {}, s.nom),
h('div', { class: 'muet' }, `${s.capacite} places · ${s.etage === 0 ? 'rez-de-chaussée' : `étage ${s.etage}`}`),
h('div', { class: 'etiquettes' }, ...s.equipements.map((e) => h('span', { class: 'etiquette' }, e))),
h('a', { class: 'bouton', href: `#/salles/${s._id}` }, 'Planning et réservation')))),
);
}
📄 public/js/vues/reservations.js
import { api } from '../api.js';
import { h, notifier, heure, jour } from '../dom.js';
export async function vueMesReservations(conteneur) {
const liste = await api('/reservations/miennes');
const maintenant = new Date();
const lignes = liste.map((r) => {
const annulable = r.statut === 'confirmee' && new Date(r.debut) > maintenant;
return h('tr', { class: r.statut === 'annulee' ? 'statut-annulee' : null },
h('td', {}, jour(r.debut)), h('td', {}, `${heure(r.debut)} – ${heure(r.fin)}`),
h('td', {}, r.salle?.nom ?? '—'), h('td', {}, r.objet),
h('td', {}, r.statut === 'annulee' ? 'annulée' : new Date(r.fin) < maintenant ? 'passée' : 'confirmée'),
h('td', {}, annulable && h('button', { class: 'danger', onclick: async () => {
if (!confirm(`Annuler « ${r.objet} » ?`)) return;
await api(`/reservations/${r._id}/annuler`, { methode: 'PATCH' });
notifier('Réservation annulée');
vueMesReservations(conteneur);
} }, 'Annuler')));
});
conteneur.replaceChildren(h('h1', {}, 'Mes réservations'), h('div', { class: 'carte' },
liste.length === 0 ? h('p', {}, 'Aucune réservation pour le moment. ', h('a', { href: '#/salles' }, 'Réserver une salle'))
: h('table', {}, h('thead', {}, h('tr', {}, ...['Jour', 'Horaire', 'Salle', 'Objet', 'Statut', ''].map((t) => h('th', {}, t)))), h('tbody', {}, ...lignes))));
}
📄 public/js/vues/admin.js
import { api } from '../api.js';
import { h, notifier, heure, jour } from '../dom.js';
export async function vueAdmin(conteneur) {
const [salles, reservations] = await Promise.all([api('/salles?toutes=oui'), api(`/reservations?date=${new Date().toISOString()}`)]);
const erreur = h('div', { class: 'erreur', hidden: true });
const form = h('form', { class: 'ligne', onsubmit: async (e) => {
e.preventDefault();
const d = Object.fromEntries(new FormData(form));
try {
await api('/salles', { methode: 'POST', corps: { nom: d.nom, capacite: Number(d.capacite), etage: Number(d.etage),
equipements: d.equipements.split(',').map((x) => x.trim()).filter(Boolean) } });
notifier('Salle ajoutée');
vueAdmin(conteneur);
} catch (err) {
erreur.replaceChildren(err.message, ...(Array.isArray(err.details) ? err.details.map((x) => h('div', {}, `• ${x.message}`)) : []));
erreur.hidden = false;
}
} },
h('label', {}, 'Nom', h('input', { name: 'nom', required: true })),
h('label', {}, 'Places', h('input', { name: 'capacite', type: 'number', min: 1, required: true })),
h('label', {}, 'Étage', h('input', { name: 'etage', type: 'number', value: 0 })),
h('label', {}, 'Équipements (séparés par des virgules)', h('input', { name: 'equipements' })),
h('button', { type: 'submit' }, 'Ajouter'));
const basculer = (s) => async () => {
await api(`/salles/${s._id}`, { methode: 'PATCH', corps: { active: !s.active } });
notifier(s.active ? `${s.nom} désactivée` : `${s.nom} réactivée`);
vueAdmin(conteneur);
};
conteneur.replaceChildren(
h('h1', {}, 'Administration'),
h('section', { class: 'carte' }, h('h2', {}, 'Salles'),
h('table', {}, h('tbody', {}, ...salles.map((s) => h('tr', {},
h('td', {}, h('strong', {}, s.nom)), h('td', {}, `${s.capacite} places`), h('td', {}, s.equipements.join(', ')),
h('td', {}, s.active ? 'active' : 'désactivée'),
h('td', {}, h('button', { class: s.active ? 'secondaire' : '', onclick: basculer(s) }, s.active ? 'Désactiver' : 'Réactiver')))))),
h('h3', {}, 'Ajouter une salle'), form, erreur),
h('section', { class: 'carte', style: { marginTop: '20px' } }, h('h2', {}, `Réservations à venir (${reservations.length})`),
h('table', {}, h('thead', {}, h('tr', {}, ...['Jour', 'Horaire', 'Salle', 'Objet', 'Réservé par', 'Statut'].map((t) => h('th', {}, t)))),
h('tbody', {}, ...reservations.map((r) => h('tr', { class: r.statut === 'annulee' ? 'statut-annulee' : null },
h('td', {}, jour(r.debut)), h('td', {}, `${heure(r.debut)} – ${heure(r.fin)}`), h('td', {}, r.salle?.nom),
h('td', {}, r.objet), h('td', {}, r.utilisateur?.nom), h('td', {}, r.statut === 'annulee' ? 'annulée' : 'confirmée')))))));
}
La mise en production (option A)
📄 ecosystem.config.cjs
// PM2 : pm2 start ecosystem.config.cjs
module.exports = {
apps: [
{
name: 'reservation-salles',
cwd: __dirname,
script: 'src/server.js',
node_args: '--env-file-if-exists=.env', // .env du serveur, jamais versionné
instances: 1, // Socket.IO garde ses connexions en mémoire : une seule instance (voir 16.3)
exec_mode: 'fork',
max_memory_restart: '300M',
env: { NODE_ENV: 'production' },
time: true,
},
],
};
📄 deploiement/nginx-reservation-salles.conf
# /etc/nginx/sites-available/reservation-salles
upstream reservation_salles {
server 127.0.0.1:3000;
keepalive 16;
}
server {
listen 80;
server_name reservations.exemple.tn;
server_tokens off;
return 301 https://$host$request_uri;
}
server {
# nginx 1.24 (Ubuntu 24.04) ; nginx >= 1.25.1 : « listen 443 ssl; » + « http2 on; »
listen 443 ssl http2;
server_name reservations.exemple.tn;
ssl_certificate /etc/letsencrypt/live/reservations.exemple.tn/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/reservations.exemple.tn/privkey.pem;
server_tokens off;
client_max_body_size 1m;
access_log /var/log/nginx/reservation-salles.access.log;
error_log /var/log/nginx/reservation-salles.error.log;
# Socket.IO : la connexion HTTP doit pouvoir être « transformée » en WebSocket
location /socket.io/ {
proxy_pass http://reservation_salles;
proxy_http_version 1.1;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection "upgrade";
proxy_set_header Host $host;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
proxy_read_timeout 1h; # une connexion WebSocket peut rester ouverte longtemps
}
# tout le reste (API et client SPA de public/) : Express
location / {
proxy_pass http://reservation_salles;
proxy_http_version 1.1;
proxy_set_header Connection "";
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
}
}
📄 deploiement/deployer.sh
#!/bin/bash
# Mise à jour sur le serveur (utilisateur deploy) : bash deploiement/deployer.sh
set -euo pipefail
cd /var/www/reservation-salles
git pull --ff-only
npm ci --omit=dev --no-audit --no-fund # du JavaScript : rien à compiler
pm2 reload ecosystem.config.cjs --update-env
pm2 save
sleep 2
curl -fsS http://127.0.0.1:3000/api/sante && echo
Fichier .env du serveur (secret masqué) :
NODE_ENV=production
PORT=3000
HOTE=127.0.0.1
# MongoDB Atlas : mongodb+srv://reservations:MOT_DE_PASSE@cluster0.xxxxx.mongodb.net/reservations
MONGODB_URI=mongodb://127.0.0.1:27017/reservations_prod
JWT_SECRET=••••••••
JWT_DUREE=2h
CORS_ORIGINES=
FUSEAU=Africa/Tunis
TRUST_PROXY=loopback
Déploiement réellement effectué :
deploy@vps:/var/www/reservation-salles$ git clone https://github.com/VOTRE_COMPTE/reservation-salles.git .
Cloning into '.'...
done.
deploy@vps:/var/www/reservation-salles$ chmod 600 .env && ls -l .env
-rw------- 1 deploy deploy 343 Nov 16 06:14 .env
deploy@vps:/var/www/reservation-salles$ npm ci --omit=dev
added 133 packages, and audited 134 packages in 5s
36 packages are looking for funding
run `npm fund` for details
found 0 vulnerabilities
deploy@vps:/var/www/reservation-salles$ ADMIN_NOM='Direction des études' ADMIN_EMAIL=direction@exemple.tn ADMIN_MOT_DE_PASSE='Direction-2026-Prod' npm run admin:creer
> reservation-salles@1.0.0 admin:creer
> node --env-file-if-exists=.env scripts/creer-admin.js
MongoDB connecté : 127.0.0.1/reservations_prod
Compte administrateur direction@exemple.tn créé
deploy@vps:/var/www/reservation-salles$ pm2 start ecosystem.config.cjs
[PM2][WARN] Applications reservation-salles not running, starting...
[PM2] App [reservation-salles] launched (1 instances)
┌────┬───────────────────────┬─────────────┬─────────┬─────────┬──────────┬────────┬──────┬───────────┬──────────┬──────────┬──────────┬──────────┐
│ id │ name │ namespace │ version │ mode │ pid │ uptime │ ↺ │ status │ cpu │ mem │ user │ watching │
├────┼───────────────────────┼─────────────┼─────────┼─────────┼──────────┼────────┼──────┼───────────┼──────────┼──────────┼──────────┼──────────┤
│ 0 │ reservation-salles │ default │ 1.0.0 │ fork │ 1375 │ 0s │ 0 │ online │ 0% │ 29.4mb │ deploy │ disabled │
└────┴───────────────────────┴─────────────┴─────────┴─────────┴──────────┴────────┴──────┴───────────┴──────────┴──────────┴──────────┴──────────┘
deploy@vps:/var/www/reservation-salles$ pm2 ls && pm2 save
┌────┬───────────────────────┬─────────────┬─────────┬─────────┬──────────┬────────┬──────┬───────────┬──────────┬──────────┬──────────┬──────────┐
│ id │ name │ namespace │ version │ mode │ pid │ uptime │ ↺ │ status │ cpu │ mem │ user │ watching │
├────┼───────────────────────┼─────────────┼─────────┼─────────┼──────────┼────────┼──────┼───────────┼──────────┼──────────┼──────────┼──────────┤
│ 0 │ reservation-salles │ default │ 1.0.0 │ fork │ 1375 │ 4s │ 0 │ online │ 0% │ 107.4mb │ deploy │ disabled │
└────┴───────────────────────┴─────────────┴─────────┴─────────┴──────────┴────────┴──────┴───────────┴──────────┴──────────┴──────────┴──────────┘
[PM2] Saving current process list...
[PM2] Successfully saved in /home/deploy/.pm2/dump.pm2
root@vps:~# cp /var/www/reservation-salles/deploiement/nginx-reservation-salles.conf /etc/nginx/sites-available/reservation-salles
root@vps:~# ln -s /etc/nginx/sites-available/reservation-salles /etc/nginx/sites-enabled/
root@vps:~# nginx -t && nginx -s reload
nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful
root@vps:~# curl -sI http://reservations.exemple.tn/ | grep -iE "^HTTP|^location"
HTTP/1.1 301 Moved Permanently
Location: https://reservations.exemple.tn/
root@vps:~# curl -s https://reservations.exemple.tn/ | grep -o "<title>.*</title>"
<title>Réservation de salles</title>
root@vps:~# curl -s https://reservations.exemple.tn/api/sante
{"statut":"ok","version":"1.0.0","uptime":6}
root@vps:~# curl -s https://reservations.exemple.tn/api/salles
{"erreur":"Authentification requise"}
root@vps:~# curl -s -m 3 http://192.0.2.2:3000/api/sante || echo "refusé (code $?)"
refusé (code 7)
HTTP redirige vers HTTPS, le client SPA et l'API répondent par nginx, l'API exige un jeton, et le port 3000 est fermé depuis l'extérieur (code 7 de curl). Le journal de nginx confirme la connexion WebSocket du planning (statut 101). L'administratrice a ensuite ajouté les salles depuis l'écran d'administration :

L'application en production sur https://reservations.exemple.tn (capture réelle dans Chrome).
📄 README.md
# Réservation de salles — projet de synthèse Node.js
Application SPA Full Stack JS : API REST Express 5 + MongoDB (Mongoose) + JWT, client JavaScript sans framework,
planning mis à jour en temps réel (Socket.IO), tests avec node:test et Supertest.
## Démarrer en local
```bash
npm install
cp .env.example .env # compléter JWT_SECRET (et MONGODB_URI pour Atlas)
npm run seed # 3 comptes, 5 salles, 4 réservations
npm run dev # http://localhost:3000
```
Comptes de démonstration : admin@exemple.tn / Admin2026!, sami@exemple.tn / Sami2026!, lina@exemple.tn / Lina2026!
## Règles de gestion
- Centre ouvert de 8 h à 19 h (fuseau Africa/Tunis) ; réservation de 30 minutes à 4 heures, dans le futur.
- Pas de chevauchement sur une même salle ; participants ≤ capacité ; salle désactivée non réservable.
- 5 réservations à venir au maximum par utilisateur ; annulation par l'auteur ou l'administration, avant le début.
## Tests
```bash
npm test
npm run test:couverture
```
## API
| Méthode | Route | Accès |
|---|---|---|
| POST | /api/auth/inscription, /api/auth/connexion | public |
| GET | /api/auth/moi | connecté |
| GET | /api/salles, /api/salles/:id, /api/salles/:id/planning?date=AAAA-MM-JJ | connecté |
| POST, PATCH | /api/salles, /api/salles/:id | admin |
| POST | /api/reservations | connecté |
| GET | /api/reservations/miennes | connecté |
| PATCH | /api/reservations/:id/annuler | auteur ou admin |
| GET | /api/reservations | admin |
## Déploiement
PM2 (`ecosystem.config.cjs`), nginx (`deploiement/nginx-reservation-salles.conf`), mise à jour (`deploiement/deployer.sh`).
Cet article vous a-t-il aidé ?
Merci pour votre avis sur cet article 🙏
Merci, votre message nous a bien été transmis 🙏
Cette leçon vous a été utile ? Partagez-la !