TP TypeScript : gestion des inscriptions d’un centre de formation

mkdir gestion-formaplus
cd gestion-formaplus
npm init -y
npm install -D typescript
npx tsc -v
code .

// Partie 01 – Types de base et inférence
const centre: string = 'FormaPlus';
const anneeOuverture: number = 2010;
let ouvert: boolean = true;
let effectif = 120; // type déduit : number

const modules: string[] = ['HTML', 'CSS', 'TypeScript'];
const notes: Array<number> = [12, 15.5, 9];
const coordonnees: [string, number] = ['Tunis', 1002]; // tuple

let identifiant: string | number = 'STG-001'; // union
identifiant = 42;

type Niveau = 'Débutant' | 'Intermédiaire' | 'Avancé'; // types littéraux
const niveau: Niveau = 'Intermédiaire';

let donneeInconnue: unknown = JSON.parse('{"nom":"Amira"}');
if (typeof donneeInconnue === 'object' && donneeInconnue !== null && 'nom' in donneeInconnue) {
  console.log('Nom reçu :', (donneeInconnue as { nom: string }).nom);
}

console.log(`${centre} (ouvert en ${anneeOuverture}) : ${effectif} stagiaires, ouvert = ${ouvert}`);
console.log(`Modules : ${modules.join(', ')} – moyenne des notes : ${(notes.reduce((s, n) => s + n, 0) / notes.length).toFixed(2)}`);
console.log(`Ville : ${coordonnees[0]}, code postal : ${coordonnees[1]}`);
console.log(`Identifiant : ${identifiant} (${typeof identifiant}) – niveau : ${niveau}`);
ouvert = false;
effectif += 5;

export type Mention = 'Très bien' | 'Bien' | 'Assez bien' | 'Passable' | 'Ajourné';

export function formaterMontant(montant: number, devise: string = 'DT'): string {
  return `${montant.toFixed(3)} ${devise}`;
}

export function calculerMoyenne(notes: readonly number[]): number {
  if (notes.length === 0) return 0;
  return notes.reduce((somme, note) => somme + note, 0) / notes.length;
}

// À vous : formaterDate, mention, formaterIdentifiant, initiales

// Partie 02 – Fonctions typées
import { calculerMoyenne, formaterDate, formaterIdentifiant, formaterMontant, initiales, mention } from '../utils/format.js';

const notesAmira = [14, 16, 17];
const moyenne = calculerMoyenne(notesAmira);
console.log(`Moyenne : ${moyenne.toFixed(2)} – mention : ${mention(moyenne)}`);
console.log(`Moyenne sans note : ${calculerMoyenne([])} – mention : ${mention(0)}`);
console.log(`Frais : ${formaterMontant(1200)} – ${formaterMontant(350, '€')}`);
console.log(`Date de rentrée : ${formaterDate(new Date(2026, 8, 15))}`);
console.log(`Identifiants : ${formaterIdentifiant(7)} – ${formaterIdentifiant('stg-042')}`);
console.log(`Initiales : ${initiales('Amira', 'Ben Ali')} – ${initiales('Sami')}`);

type Operation = (a: number, b: number) => number;
const operations: Record<string, Operation> = {
  addition: (a, b) => a + b,
  moyenne: (a, b) => (a + b) / 2,
};
console.log(`Opérations : ${operations['addition'](12, 15)} et ${operations['moyenne'](12, 15)}`);

export interface Identifiable {
  readonly id: number;
}

export interface Personne extends Identifiable {
  nom: string;
  prenom: string;
  email: string;
  telephone?: string;
}

export interface Stagiaire extends Personne {
  groupe: string;
  notes: number[];
  dateInscription: Date;
}

export interface Formateur extends Personne {
  specialites: string[];
  tarifHoraire: number;
}

export type Resultat<T> =
  | { succes: true; valeur: T }
  | { succes: false; erreur: string };

import type { Formateur, Stagiaire } from '../models/personne.js';
import type { Formation } from '../models/formation.js';

export const formateurs: Formateur[] = [
  { id: 1, nom: 'Gharbi', prenom: 'Ali', email: 'ali.gharbi@formaplus.tn', specialites: ['Angular', 'TypeScript'], tarifHoraire: 45 },
  { id: 2, nom: 'Mansour', prenom: 'Leila', email: 'leila.mansour@formaplus.tn', specialites: ['Réseaux', 'Linux'], tarifHoraire: 40 },
];

export const formations: Formation[] = [
  { id: 1, titre: 'Développement Angular', niveau: 'Intermédiaire', dureeHeures: 120, prixHT: 1200, formateurId: 1 },
  { id: 2, titre: 'TypeScript pour débutants', niveau: 'Débutant', dureeHeures: 40, prixHT: 450, formateurId: 1 },
  { id: 3, titre: 'Administration Linux', niveau: 'Avancé', dureeHeures: 80, prixHT: 900, formateurId: 2 },
];

export const stagiaires: Stagiaire[] = [
  { id: 1, nom: 'Ben Ali', prenom: 'Amira', email: 'amira@exemple.tn', groupe: 'DEV1', notes: [14, 16, 17], dateInscription: new Date(2026, 8, 15) },
  // À vous : les stagiaires 2 à 5 (tableau ci-dessous)
];

// Partie 03 – Modèles de données
import { formateurs, formations, stagiaires } from '../data/donnees.js';
import type { Personne } from '../models/personne.js';
import { calculerMoyenne, formaterMontant, mention } from '../utils/format.js';

const contact = (p: Personne): string => `${p.prenom} ${p.nom.toUpperCase()} <${p.email}>${p.telephone ? ' – ' + p.telephone : ''}`;

console.log('--- Formateurs ---');
formateurs.forEach((f) => console.log(`${contact(f)} – ${f.specialites.join(', ')}`));

console.log('--- Formations ---');
for (const f of formations) {
  const formateur = formateurs.find((x) => x.id === f.formateurId);
  console.log(`${f.titre} (${f.niveau}, ${f.dureeHeures} h) – ${formaterMontant(f.prixHT)} HT – ${formateur?.prenom ?? '?'}`);
}

console.log('--- Stagiaires ---');
for (const s of stagiaires) {
  const moy = calculerMoyenne(s.notes);
  const resultat = s.notes.length ? `${moy.toFixed(2)} (${mention(moy)})` : 'aucune note';
  console.log(`${contact(s)} – ${s.groupe} – ${resultat}`);
}

import type { Formation } from '../models/formation.js';
import type { Resultat } from '../models/inscription.js';
import { formaterDate } from '../utils/format.js';

export class Session {
  private static compteur = 0;
  readonly id: number;
  private inscrits: number[] = [];

  constructor(
    public readonly formation: Formation,
    public readonly debut: Date,
    private capacite: number,
  ) {
    Session.compteur++;
    this.id = Session.compteur;
  }

  static get nombre(): number {
    return Session.compteur;
  }

  get placesRestantes(): number {
    return this.capacite - this.inscrits.length;
  }

  // À vous : estComplete, libelle, inscrire(), annuler()
}

// Partie 04 – Classes
import { Session } from '../classes/session.js';
import { formations } from '../data/donnees.js';

const angular = new Session(formations[0], new Date(2026, 10, 2), 2);
const linux = new Session(formations[2], new Date(2026, 10, 9), 10);

console.log(`Session ${angular.id} : ${angular.libelle} (${angular.placesRestantes} places)`);
console.log(`Session ${linux.id} : ${linux.libelle} (${linux.placesRestantes} places)`);

for (const id of [1, 2, 1, 3]) {
  const r = angular.inscrire(id);
  if (r.succes) {
    console.log(`Stagiaire ${id} inscrit – reste ${r.valeur} place(s)`);
  } else {
    console.log(`Stagiaire ${id} refusé : ${r.erreur}`);
  }
}
console.log(`Annulation du stagiaire 2 : ${angular.annuler(2)} – places : ${angular.placesRestantes}`);
console.log(`Nombre de sessions créées : ${Session.nombre}`);

import { formaterMontant } from '../utils/format.js';

export interface Exportable {
  exporterCsv(): string;
}

export abstract class Paiement implements Exportable {
  static readonly TVA = 0.19;

  constructor(protected readonly montantHT: number) {}

  abstract get libelle(): string;
  abstract frais(): number;

  get montantTTC(): number {
    return this.montantHT * (1 + Paiement.TVA);
  }

  total(): number {
    return this.montantTTC + this.frais();
  }

  recu(): string {
    return `${this.libelle.padEnd(22)} TTC ${formaterMontant(this.montantTTC)} + frais ${formaterMontant(this.frais())} = ${formaterMontant(this.total())}`;
  }

  exporterCsv(): string {
    return [this.libelle, this.montantHT, this.total().toFixed(3)].join(';');
  }
}

export class PaiementEspeces extends Paiement {
  get libelle(): string {
    return 'Espèces';
  }
  frais(): number {
    return 0;
  }
}

// À vous : PaiementCarte et PaiementFacilite

// Partie 05 – Héritage, classes abstraites et interfaces
import { type Exportable, Paiement, PaiementCarte, PaiementEspeces, PaiementFacilite } from '../classes/paiement.js';

const paiements: Paiement[] = [new PaiementEspeces(1200), new PaiementCarte(1200), new PaiementFacilite(1200, 3)];
paiements.forEach((p) => console.log(p.recu()));

const aExporter: Exportable[] = paiements;
console.log('libelle;montantHT;total');
aExporter.forEach((e) => console.log(e.exporterCsv()));

import type { Identifiable } from '../models/personne.js';

export class Depot<T extends Identifiable> {
  private elements: T[] = [];

  constructor(elementsInitiaux: T[] = []) {
    this.elements = [...elementsInitiaux];
  }

  get taille(): number {
    return this.elements.length;
  }

  tous(): readonly T[] {
    return this.elements;
  }

  trouver(id: number): T | undefined {
    return this.elements.find((e) => e.id === id);
  }

  ajouter(donnees: Omit<T, 'id'>): T {
    const id = Math.max(0, ...this.elements.map((e) => e.id)) + 1;
    const element = { ...donnees, id } as T;
    this.elements.push(element);
    return element;
  }

  // À vous : filtrer(), modifier(), supprimer()
}

// Partie 06 – Génériques et types utilitaires
import { Depot } from '../classes/depot.js';
import { formations, stagiaires } from '../data/donnees.js';
import type { Formation } from '../models/formation.js';
import type { Stagiaire } from '../models/personne.js';

const depotStagiaires = new Depot<Stagiaire>(stagiaires);
const depotFormations = new Depot<Formation>(formations);

const nouveau = depotStagiaires.ajouter({
  nom: 'Khelifi', prenom: 'Ines', email: 'ines@exemple.tn', groupe: 'DEV2', notes: [], dateInscription: new Date(2026, 9, 20),
});
console.log(`Ajout : ${nouveau.prenom} avec l'id ${nouveau.id} – total : ${depotStagiaires.taille}`);

const modifie = depotStagiaires.modifier(2, { groupe: 'DEV2', telephone: '+216 21 111 111' });
console.log(`Modification : ${modifie?.prenom} est maintenant en ${modifie?.groupe}`);
console.log(`Modification d'un id inconnu : ${depotStagiaires.modifier(99, { groupe: 'X' }) ?? 'introuvable'}`);

const dev2 = depotStagiaires.filtrer((s) => s.groupe === 'DEV2').map((s) => s.prenom);
console.log(`Groupe DEV2 : ${dev2.join(', ')}`);
console.log(`Suppression de l'id 5 : ${depotStagiaires.supprimer(5)} – puis encore : ${depotStagiaires.supprimer(5)}`);

const debutant = depotFormations.filtrer((f) => f.niveau === 'Débutant')[0];
console.log(`Formation débutant : ${debutant?.titre}`);
console.log(`Stagiaires : ${depotStagiaires.tous().map((s) => s.id).join(', ')}`);

export interface Notificateur {
  readonly canal: string;
  envoyer(destinataire: string, message: string): void;
}

export class NotificateurConsole implements Notificateur {
  readonly canal = 'console';
  envoyer(destinataire: string, message: string): void {
    console.log(`  ✉ [${this.canal}] à ${destinataire} : ${message}`);
  }
}

export class NotificateurJournal implements Notificateur {
  readonly canal = 'journal';
  private messages: string[] = [];

  envoyer(destinataire: string, message: string): void {
    this.messages.push(`${destinataire} – ${message}`);
  }

  get historique(): readonly string[] {
    return this.messages;
  }
}

import { Depot } from '../classes/depot.js';
import { type Paiement, PaiementCarte, PaiementEspeces, PaiementFacilite } from '../classes/paiement.js';
import { Session } from '../classes/session.js';
import type { Inscription, ModePaiement, Resultat } from '../models/inscription.js';
import type { Stagiaire } from '../models/personne.js';
import { formaterMontant } from '../utils/format.js';
import type { Notificateur } from './notificateur.js';

export class InscriptionService {
  private readonly inscriptions = new Depot<Inscription>();

  constructor(
    private readonly stagiaires: Depot<Stagiaire>,
    private readonly sessions: Session[],
    private readonly notificateur: Notificateur,
  ) {}

  inscrire(stagiaireId: number, sessionId: number): Resultat<Inscription> {
    const stagiaire = this.stagiaires.trouver(stagiaireId);
    const session = this.sessions.find((s) => s.id === sessionId);
    if (!stagiaire) return { succes: false, erreur: `stagiaire ${stagiaireId} introuvable` };
    if (!session) return { succes: false, erreur: `session ${sessionId} introuvable` };

    const place = session.inscrire(stagiaireId);
    if (!place.succes) return { succes: false, erreur: place.erreur };

    const inscription = this.inscriptions.ajouter({ stagiaireId, sessionId, statut: 'en attente' });
    this.notificateur.envoyer(stagiaire.email, `inscription en attente pour « ${session.libelle} »`);
    return { succes: true, valeur: inscription };
  }

  // À vous : payer(), creerPaiement() (privée) et parStatut()
}

import { Depot } from './classes/depot.js';
import { Session } from './classes/session.js';
import { formateurs, formations, stagiaires } from './data/donnees.js';
import type { Stagiaire } from './models/personne.js';
import { InscriptionService } from './services/inscription.service.js';
import { NotificateurConsole } from './services/notificateur.js';
import { calculerMoyenne, formaterMontant, mention } from './utils/format.js';

console.log('=== FormaPlus – gestion des inscriptions ===');

const depotStagiaires = new Depot<Stagiaire>(stagiaires);
const sessions = [
  new Session(formations[0], new Date(2026, 10, 2), 2),
  new Session(formations[1], new Date(2026, 10, 4), 12),
  new Session(formations[2], new Date(2026, 10, 9), 10),
];
const inscriptions = new InscriptionService(depotStagiaires, sessions, new NotificateurConsole());

console.log('\n--- Inscriptions ---');
const demandes: [number, number][] = [[1, 1], [2, 1], [3, 1], [4, 3], [9, 2]];
for (const [stagiaireId, sessionId] of demandes) {
  const r = inscriptions.inscrire(stagiaireId, sessionId);
  console.log(r.succes ? `  ✔ inscription n° ${r.valeur.id} créée` : `  ✘ refus : ${r.erreur}`);
}

console.log('\n--- Paiements ---');
const reglements: [number, 'especes' | 'carte' | 'facilite'][] = [[1, 'carte'], [3, 'facilite'], [1, 'especes']];
for (const [id, mode] of reglements) {
  const r = inscriptions.payer(id, mode);
  console.log(r.succes ? `  ✔ ${r.valeur.recu()}` : `  ✘ refus : ${r.erreur}`);
}

export function journaliser<This, Args extends unknown[], Retour>(
  methode: (this: This, ...args: Args) => Retour,
  contexte: ClassMethodDecoratorContext<This, (this: This, ...args: Args) => Retour>,
) {
  const nom = String(contexte.name);
  return function (this: This, ...args: Args): Retour {
    console.log(`  ▶ ${nom}(${args.map((a) => JSON.stringify(a)).join(', ')})`);
    const resultat = methode.call(this, ...args);
    return resultat;
  };
}

export function service(nom: string) {
  return function <T extends abstract new (...args: any[]) => unknown>(classe: T, contexte: ClassDecoratorContext<T>): T {
    console.log(`[décorateur] service « ${nom} » enregistré (classe ${String(contexte.name)})`);
    return classe;
  };
}

// À vous : mesurer

// Partie 08 – Décorateurs
import { journaliser, mesurer, service } from '../decorateurs/journal.js';

@service('calculs')
class Calculatrice {
  @journaliser
  @mesurer
  moyenne(...notes: number[]): number {
    return notes.reduce((s, n) => s + n, 0) / notes.length;
  }
}

const calc = new Calculatrice();
console.log(`Résultat : ${calc.moyenne(14, 16, 17).toFixed(2)}`);

console.log('\n--- Tableau de bord ---');
for (const s of sessions) {
  const formateur = formateurs.find((f) => f.id === s.formation.formateurId);
  console.log(`${s.libelle.padEnd(45)} ${String(s.placesRestantes).padStart(2)} place(s) – ${formateur?.prenom} ${formateur?.nom}`);
}
console.log('Inscriptions par statut :', inscriptions.parStatut());

const classement = depotStagiaires
  .filtrer((s) => s.notes.length > 0)
  .map((s) => ({ nom: `${s.prenom} ${s.nom}`, moyenne: calculerMoyenne(s.notes) }))
  .toSorted((a, b) => b.moyenne - a.moyenne);
console.log('Classement :');
classement.forEach((c, i) => console.log(`  ${i + 1}. ${c.nom.padEnd(16)} ${c.moyenne.toFixed(2)} (${mention(c.moyenne)})`));

const chiffreAffaires = formations.reduce((t, f) => t + f.prixHT, 0);
console.log(`Catalogue : ${formations.length} formations, ${formaterMontant(chiffreAffaires)} HT au total`);