TP 2 : Structurer l'API de gestion de formation en modules

import { Injectable } from '@nestjs/common';

@Injectable()
export class JournalService {
  private compteur = 0;

  ecrire(contexte: string, message: string): void {
    this.compteur++;
    const heure = new Date().toLocaleTimeString('fr-FR');
    console.log(`[${heure}] [${contexte}] ${message}`);
  }

  get nombreMessages(): number {
    return this.compteur;
  }
}

import { Injectable, NestMiddleware } from '@nestjs/common';
import { NextFunction, Request, Response } from 'express';
import { JournalService } from './journal.service';

@Injectable()
export class JournalMiddleware implements NestMiddleware {
  constructor(private readonly journal: JournalService) {}

  use(req: Request, res: Response, next: NextFunction) {
    const debut = Date.now();
    res.on('finish', () => {
      this.journal.ecrire('HTTP', `${req.method} ${req.originalUrl} → ${res.statusCode} (${Date.now() - debut} ms)`);
    });
    next();
  }
}

import { Module } from '@nestjs/common';
import { JournalService } from './journal.service';

@Module({
  providers: [JournalService],
  exports: [JournalService],
})
export class CommonModule {}

export interface ParametresOptions {
  etablissement: string;
  anneeScolaire: string;
  version: string;
}

export const PARAMETRES_OPTIONS = 'PARAMETRES_OPTIONS';

import { Inject, Injectable } from '@nestjs/common';
import { PARAMETRES_OPTIONS, ParametresOptions } from './parametres.constants';

@Injectable()
export class ParametresService {
  constructor(@Inject(PARAMETRES_OPTIONS) private readonly options: ParametresOptions) {}

  get etablissement(): string {
    return this.options.etablissement;
  }

  infos() {
    return { application: 'api-formation', ...this.options };
  }
}

import { DynamicModule, Global, Module } from '@nestjs/common';
import { PARAMETRES_OPTIONS, ParametresOptions } from './parametres.constants';
import { ParametresService } from './parametres.service';

@Global()
@Module({})
export class ParametresModule {
  static forRoot(options: ParametresOptions): DynamicModule {
    return {
      module: ParametresModule,
      providers: [{ provide: PARAMETRES_OPTIONS, useValue: options }, ParametresService],
      exports: [ParametresService],
    };
  }
}

import { Injectable, NotFoundException, OnModuleInit } from '@nestjs/common';
import { JournalService } from '../common/journal.service';

export interface Formation {
  id: number;
  intitule: string;
  heures: number;
}

@Injectable()
export class FormationsService implements OnModuleInit {
  private formations: Formation[] = [];

  constructor(private readonly journal: JournalService) {}

  onModuleInit() {
    this.formations = [
      { id: 1, intitule: 'Développement digital', heures: 1200 },
      { id: 2, intitule: 'Infrastructure digitale', heures: 1100 },
    ];
    this.journal.ecrire('Formations', `${this.formations.length} formations chargées`);
  }

  findAll(): Formation[] {
    return this.formations;
  }

  findOne(id: number): Formation {
    const f = this.formations.find((x) => x.id === id);
    if (!f) throw new NotFoundException(`Formation ${id} introuvable`);
    return f;
  }
}

import { Controller, Get, Param } from '@nestjs/common';
import { FormationsService } from './formations.service';

@Controller('formations')
export class FormationsController {
  constructor(private readonly formationsService: FormationsService) {}

  @Get()
  findAll() {
    return this.formationsService.findAll();
  }

  @Get(':id')
  findOne(@Param('id') id: string) {
    return this.formationsService.findOne(Number(id));
  }
}

import { Module } from '@nestjs/common';
import { CommonModule } from '../common/common.module';
import { FormationsController } from './formations.controller';
import { FormationsService } from './formations.service';

@Module({
  imports: [CommonModule],
  controllers: [FormationsController],
  providers: [FormationsService],
  exports: [FormationsService],
})
export class FormationsModule {}

import { Injectable, NotFoundException } from '@nestjs/common';
import { FormationsService } from '../formations/formations.service';

export interface Groupe {
  code: string;
  formationId: number;
  capacite: number;
}

@Injectable()
export class GroupesService {
  private groupes: Groupe[] = [
    { code: 'DEV101', formationId: 1, capacite: 24 },
    { code: 'DEV102', formationId: 1, capacite: 20 },
    { code: 'INF101', formationId: 2, capacite: 18 },
  ];

  constructor(private readonly formationsService: FormationsService) {}

  private detailler(g: Groupe) {
    const { intitule } = this.formationsService.findOne(g.formationId);
    return { ...g, formation: intitule };
  }

  findAll() {
    return this.groupes.map((g) => this.detailler(g));
  }

  findOne(code: string) {
    const g = this.groupes.find((x) => x.code === code.toUpperCase());
    if (!g) throw new NotFoundException(`Groupe ${code} introuvable`);
    return this.detailler(g);
  }
}

import { Controller, Get, Param } from '@nestjs/common';
import { GroupesService } from './groupes.service';

@Controller('groupes')
export class GroupesController {
  constructor(private readonly groupesService: GroupesService) {}

  @Get()
  findAll() {
    return this.groupesService.findAll();
  }

  @Get(':code')
  findOne(@Param('code') code: string) {
    return this.groupesService.findOne(code);
  }
}

import { Module } from '@nestjs/common';
import { FormationsModule } from '../formations/formations.module';
import { GroupesController } from './groupes.controller';
import { GroupesService } from './groupes.service';

@Module({
  imports: [FormationsModule],
  controllers: [GroupesController],
  providers: [GroupesService],
  exports: [GroupesService],
})
export class GroupesModule {}

import { Injectable, NotFoundException } from '@nestjs/common';
import { GroupesService } from '../groupes/groupes.service';

export interface Stagiaire {
  id: number;
  nom: string;
  prenom: string;
  groupe: string;
}

@Injectable()
export class StagiairesService {
  private stagiaires: Stagiaire[] = [
    { id: 1, nom: 'Ben Ali', prenom: 'Sami', groupe: 'DEV101' },
    { id: 2, nom: 'Trabelsi', prenom: 'Ines', groupe: 'DEV101' },
    { id: 3, nom: 'Gharbi', prenom: 'Yassine', groupe: 'INF101' },
  ];

  constructor(private readonly groupesService: GroupesService) {}

  findAll(groupe?: string): Stagiaire[] {
    return groupe ? this.stagiaires.filter((s) => s.groupe === groupe.toUpperCase()) : this.stagiaires;
  }

  findOne(id: number) {
    const s = this.stagiaires.find((x) => x.id === id);
    if (!s) throw new NotFoundException(`Stagiaire ${id} introuvable`);
    return { ...s, groupe: this.groupesService.findOne(s.groupe) };
  }
}

import { Controller, Get, Param, Query } from '@nestjs/common';
import { StagiairesService } from './stagiaires.service';

@Controller('stagiaires')
export class StagiairesController {
  constructor(private readonly stagiairesService: StagiairesService) {}

  @Get()
  findAll(@Query('groupe') groupe?: string) {
    return this.stagiairesService.findAll(groupe);
  }

  @Get(':id')
  findOne(@Param('id') id: string) {
    return this.stagiairesService.findOne(Number(id));
  }
}

import { Module } from '@nestjs/common';
import { GroupesModule } from '../groupes/groupes.module';
import { StagiairesController } from './stagiaires.controller';
import { StagiairesService } from './stagiaires.service';

@Module({
  imports: [GroupesModule],
  controllers: [StagiairesController],
  providers: [StagiairesService],
})
export class StagiairesModule {}

import { Controller, Get } from '@nestjs/common';
import { JournalService } from './common/journal.service';
import { ParametresService } from './parametres/parametres.service';

@Controller()
export class AppController {
  constructor(
    private readonly parametres: ParametresService,
    private readonly journal: JournalService,
  ) {}

  @Get()
  accueil(): string {
    return `Bienvenue sur l'API de ${this.parametres.etablissement}`;
  }

  @Get('infos')
  infos() {
    return { ...this.parametres.infos(), messagesJournal: this.journal.nombreMessages };
  }
}

import { MiddlewareConsumer, Module, NestModule, OnApplicationShutdown } from '@nestjs/common';
import { AppController } from './app.controller';
import { CommonModule } from './common/common.module';
import { JournalMiddleware } from './common/journal.middleware';
import { JournalService } from './common/journal.service';
import { FormationsModule } from './formations/formations.module';
import { GroupesModule } from './groupes/groupes.module';
import { ParametresModule } from './parametres/parametres.module';
import { StagiairesModule } from './stagiaires/stagiaires.module';

@Module({
  imports: [
    ParametresModule.forRoot({
      etablissement: 'Institut de formation de Tunis',
      anneeScolaire: '2026-2027',
      version: '0.2.0',
    }),
    CommonModule,
    FormationsModule,
    GroupesModule,
    StagiairesModule,
  ],
  controllers: [AppController],
})
export class AppModule implements NestModule, OnApplicationShutdown {
  constructor(private readonly journal: JournalService) {}

  configure(consumer: MiddlewareConsumer) {
    consumer.apply(JournalMiddleware).forRoutes('*');
  }

  onApplicationShutdown(signal?: string) {
    this.journal.ecrire('App', `API arrêtée (${signal ?? 'arrêt manuel'})`);
  }
}

import { Logger } from '@nestjs/common';
import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  app.setGlobalPrefix('api');
  app.enableCors({ origin: ['http://localhost:4200'] });
  app.enableShutdownHooks();

  const port = process.env.PORT ?? 3000;
  await app.listen(port);
  Logger.log(`API api-formation démarrée sur http://localhost:${port}/api`, 'Bootstrap');
}
bootstrap();