Documentation de Développement QuizMaker

Table of Contents

1. Introduction

1.1. Objectif du document

Ce document présente l’architecture et la conception détaillée du système QuizMaker, une plateforme de gestion d’épreuves et de questionnaires en ligne. Il s’adresse aux développeurs, architectes et mainteneurs du système.

1.2. Portée du système

QuizMaker permet aux enseignants de créer des épreuves basées sur des questionnaires prédéfinis, aux étudiants de participer à ces épreuves, et automatise le processus de correction et de publication des notes.

1.3. Public cible

  • Équipe de développement

  • Architectes logiciels

  • Responsables techniques

  • Équipe de maintenance

1.4. Références

  • Langage de modélisation : UML 2.5

  • Format de documentation : Asciidoc

  • Exigence : NF-Req-3

2. Architecture Générale

2.1. Vue d’ensemble

Le système QuizMaker est construit sur une architecture multi-couches comprenant :

  • Couche Présentation : Interfaces web pour enseignants et étudiants

  • Couche Métier : Logique applicative et services

  • Couche Accès aux Données : Gestion de la persistance

  • Couche Infrastructure : Services transversaux (cache, sessions, logs)

2.2. Principes architecturaux

  • Séparation des responsabilités (Separation of Concerns)

  • Architecture en couches

  • Services asynchrones pour les traitements longs

  • Mise en cache pour l’optimisation des performances

  • API REST pour la communication client-serveur

3. Modélisation Fonctionnelle

3.1. Diagramme de cas d’utilisation

Le diagramme suivant présente les interactions principales entre les acteurs (Enseignant, Étudiant, Système de notification) et le système QuizMaker.

cas-utilisation

3.1.1. Acteurs principaux

Enseignant

  • Crée et configure des épreuves

  • Lance la correction des épreuves

  • Publie les notes aux étudiants

  • Consulte les statistiques

Étudiant

  • Participe aux épreuves disponibles

  • Répond aux questions dans le temps imparti

  • Consulte ses notes publiées

Système de notification

  • Envoie des notifications automatiques lors de la publication des notes

3.1.2. Cas d’utilisation détaillés

UC1 : Créer une épreuve

  • Acteur principal : Enseignant

  • Préconditions : L’enseignant est authentifié

  • Description : L’enseignant crée une nouvelle épreuve en sélectionnant un questionnaire existant et en définissant les paramètres temporels

  • Inclusions : UC2 (Sélectionner un questionnaire), UC3 (Définir date et durée), UC11 (Se connecter au système)

UC4 : Participer à une épreuve

  • Acteur principal : Étudiant

  • Préconditions : L’étudiant est authentifié, l’épreuve est active

  • Description : L’étudiant accède à une épreuve, répond aux questions et soumet sa copie

  • Inclusions : UC5 (Répondre aux questions), UC6 (Soumettre la copie), UC11 (Se connecter au système)

UC7 : Corriger l’épreuve

  • Acteur principal : Enseignant

  • Préconditions : L’épreuve est terminée, toutes les copies sont soumises

  • Description : Lance le processus de correction automatique

  • Inclusions : UC8 (Calculer les notes)

UC9 : Publier les notes

  • Acteur principal : Enseignant

  • Préconditions : La correction est terminée

  • Description : Rend les notes visibles aux étudiants

  • Extensions : Notification du système de notification

3.2. Diagramme de séquence

Le diagramme de séquence suivant illustre les quatre phases principales du processus complet d’une épreuve.

sequence-detaille

3.2.1. Phase 1 : Création de l’épreuve

L’enseignant se connecte au système, sélectionne un questionnaire dans la banque existante, définit les paramètres temporels (date et durée) et valide la création de l’épreuve. Le système enregistre l’épreuve avec l’état "PLANIFIEE".

Interactions principales :

  1. Authentification de l’enseignant

  2. Initialisation d’une nouvelle épreuve

  3. Récupération du questionnaire depuis la base de données

  4. Configuration des paramètres (date, durée)

  5. Sauvegarde de l’épreuve

3.2.2. Phase 2 : Participation des étudiants

Les étudiants se connectent, consultent les épreuves disponibles et démarrent leur participation. Le système initialise une copie pour chaque étudiant et enregistre leurs réponses au fur et à mesure. La soumission peut être volontaire ou automatique en cas de dépassement du temps.

Interactions principales :

  1. Authentification de l’étudiant

  2. Récupération des épreuves actives

  3. Initialisation d’une copie d’étudiant

  4. Affichage séquentiel des questions

  5. Enregistrement des réponses en temps réel

  6. Soumission de la copie (manuelle ou automatique)

3.2.3. Phase 3 : Correction et publication

L’enseignant lance le processus de correction automatique. Le système compare les réponses des étudiants avec les réponses correctes, calcule les notes, génère les statistiques et marque les copies comme corrigées. L’enseignant analyse les résultats et publie les notes.

Interactions principales :

  1. Ouverture de l’épreuve par l’enseignant

  2. Lancement de la correction automatique

  3. Récupération des réponses pour chaque copie

  4. Comparaison avec les réponses correctes

  5. Calcul et enregistrement des notes

  6. Génération des statistiques

  7. Publication des notes

3.2.4. Phase 4 : Consultation par les étudiants

Les étudiants se connectent pour consulter leurs notes publiées et le détail de leur copie corrigée.

Interactions principales :

  1. Authentification de l’étudiant

  2. Récupération des notes publiées

  3. Affichage des résultats

  4. Consultation du détail de la copie

3.3. Diagramme d’activité

Le diagramme d’activité suivant détaille le flux de travail complet du système, depuis la création d’une épreuve jusqu’à la consultation des notes par les étudiants.

activite

3.3.1. Flux enseignant - Création

  1. Connexion au système

  2. Création d’une nouvelle épreuve

  3. Sélection d’un questionnaire depuis la banque

  4. Définition de la date de réalisation

  5. Définition de la durée

  6. Validation et enregistrement (État : PLANIFIEE)

  7. Déconnexion

3.3.2. Flux étudiant - Participation

  1. Connexion au système

  2. Consultation des épreuves disponibles

  3. Démarrage de l’épreuve (initialisation copie, État : EN_COURS)

  4. Affichage de la première question

  5. Boucle de traitement des questions :

    • Lecture de la question

    • Sélection d’un ou plusieurs choix

    • Enregistrement de la réponse

    • Navigation vers la question suivante ou révision

  6. Soumission (volontaire ou automatique si durée écoulée)

  7. État copie : SOUMISE

  8. Réception de la confirmation

  9. Déconnexion

3.3.3. Flux système - Correction automatique

  1. Attente que toutes les copies soient soumises (État épreuve : TERMINEE)

  2. Enseignant lance la correction

  3. Pour chaque copie :

    • Récupération des réponses de l’étudiant

    • Pour chaque réponse :

      • Récupération de la réponse correcte

      • Comparaison

      • Attribution des points si correct

    • Calcul de la note totale

    • Enregistrement de la note (État copie : CORRIGEE)

  4. Calcul des statistiques globales (moyenne, écart-type, distribution)

  5. État épreuve : CORRIGEE

3.3.4. Flux enseignant - Publication

  1. Analyse des résultats et statistiques

  2. Ajustement manuel des notes si nécessaire (optionnel)

  3. Publication des notes (État épreuve : PUBLIEE)

  4. Déconnexion

3.3.5. Flux étudiant - Consultation

  1. Connexion au système

  2. Consultation des notes

  3. Consultation du détail de la copie corrigée

  4. Contact de l’enseignant si insatisfait (optionnel)

  5. Déconnexion

4. Modélisation Structurelle

4.1. Diagramme de classes

Le diagramme de classes suivant présente le modèle objet complet du système QuizMaker avec tous les concepts du domaine, leurs attributs, méthodes et relations.

classes

4.1.1. Package : Gestion des acteurs

Classe abstraite Utilisateur

Classe de base pour tous les acteurs du système.

  • Attributs :

    • nom: String - Nom complet de l’utilisateur

    • login: String - Identifiant de connexion unique

    • motDePasse: String - Mot de passe crypté

  • Méthodes :

    • seConnecter(): boolean - Établit une session utilisateur

    • seDeconnecter(): void - Ferme la session en cours

    • authentifier(): boolean - Vérifie les credentials

Classe Enseignant (hérite de Utilisateur)

Représente un enseignant du système avec des privilèges de création et de gestion.

  • Attributs :

    • matières: List<String> - Liste des matières enseignées

  • Méthodes :

    • créerEpreuve(): Epreuve - Crée une nouvelle épreuve

    • sélectionnerQuestionnaire(): Questionnaire - Sélectionne un questionnaire depuis la banque

    • corrigerEpreuve(e: Epreuve): void - Lance la correction d’une épreuve

    • publierNotes(e: Epreuve): void - Publie les notes aux étudiants

    • analyserRésultats(e: Epreuve): Statistiques - Génère les statistiques d’une épreuve

Classe Etudiant (hérite de Utilisateur)

Représente un étudiant participant aux épreuves.

  • Attributs :

    • code: String - Code étudiant unique

    • niveau: String - Niveau d’études (L1, L2, M1, etc.)

  • Méthodes :

    • participerEpreuve(e: Epreuve): Copie - Démarre une épreuve et initialise une copie

    • répondreQuestion(q: Question, c: Choix): void - Enregistre une réponse

    • soumettreCopieFinie(): void - Soumet volontairement la copie

    • consulterNote(): Note - Consulte sa note publiée

4.1.2. Package : Gestion des questionnaires

Classe Banque

Conteneur pour la gestion centralisée des questions.

  • Attributs :

    • id: int - Identifiant unique

    • nom: String - Nom de la banque de questions

  • Méthodes :

    • ajouterQuestion(q: Question): void - Ajoute une question à la banque

    • rechercherQuestion(critères): List<Question> - Recherche des questions selon des critères

Classe Questionnaire

Ensemble structuré de questions constituant la base d’une épreuve.

  • Attributs :

    • id: int - Identifiant unique

    • titre: String - Titre du questionnaire

    • dateCreation: Date - Date de création

  • Méthodes :

    • ajouterQuestion(q: Question): void - Ajoute une question au questionnaire

    • supprimerQuestion(q: Question): void - Retire une question

    • obtenirQuestions(): List<Question> - Retourne la liste des questions

    • validerCompletude(): boolean - Vérifie que le questionnaire est complet

Classe Question

Élément de base d’un questionnaire avec ses choix de réponses.

  • Attributs :

    • etiquette: String - Identifiant court de la question

    • intitule: String - Texte complet de la question

    • typeScoring: String - Type de notation (binaire, partiel, etc.)

  • Méthodes :

    • ajouterChoix(c: Choix): void - Ajoute un choix de réponse

    • obtenirChoixCorrects(): List<Choix> - Retourne les réponses correctes

    • valider(): boolean - Vérifie la validité de la question

  • Contrainte : Une question possède au moins une réponse correcte

Classe Choix

Option de réponse pour une question.

  • Attributs :

    • texte: String - Texte du choix

    • estCorrect: boolean - Indique si le choix est correct

  • Méthodes :

    • marquerCommeCorrect(): void - Marque le choix comme réponse correcte

    • marquerCommeIncorrect(): void - Marque le choix comme incorrect

4.1.3. Package : Gestion des épreuves

Classe Epreuve

Instance d’un questionnaire définie dans le temps.

  • Attributs :

    • id: int - Identifiant unique

    • dateRealisation: DateTime - Date et heure de début

    • duree: int - Durée en minutes

    • etat: EtatEpreuve - État actuel de l’épreuve

  • Méthodes :

    • planifier(date: DateTime, duree: int): void - Planifie l’épreuve

    • démarrer(): void - Active l’épreuve

    • terminer(): void - Clôture l’épreuve

    • estActive(): boolean - Vérifie si l’épreuve est en cours

    • ajouterQuestionnaire(q: Questionnaire): void - Associe un questionnaire

Énumération EtatEpreuve

États possibles d’une épreuve :

  • PLANIFIEE - Épreuve créée mais non démarrée

  • EN_COURS - Épreuve accessible aux étudiants

  • TERMINEE - Tous les étudiants ont soumis ou temps écoulé

  • CORRIGEE - Correction effectuée

  • PUBLIEE - Notes publiées et visibles

Classe Copie

Ensemble des réponses d’un étudiant pour une épreuve.

  • Attributs :

    • id: int - Identifiant unique

    • dateDebut: DateTime - Horodatage du début

    • dateFin: DateTime - Horodatage de la soumission

    • etatCopie: EtatCopie - État actuel de la copie

    • note: float - Note attribuée (0-20)

  • Méthodes :

    • initialiser(): void - Initialise une nouvelle copie

    • soumettreFinTemps(): void - Soumission automatique (temps écoulé)

    • soumettreVolontaire(): void - Soumission manuelle par l’étudiant

    • estTerminee(): boolean - Vérifie si la copie est soumise

    • calculerNote(): float - Calcule la note finale

  • Invariant : Les choix des réponses doivent correspondre aux choix des questions du questionnaire

Énumération EtatCopie

États possibles d’une copie :

  • EN_COURS - L’étudiant répond aux questions

  • SOUMISE - Copie remise, en attente de correction

  • CORRIGEE - Note calculée et attribuée

Classe Reponse

Réponse d’un étudiant à une question.

  • Attributs :

    • texte: String - Texte de la réponse (si applicable)

    • dateReponse: DateTime - Horodatage de la réponse

  • Méthodes :

    • enregistrer(): void - Sauvegarde la réponse

    • estCorrecte(): boolean - Vérifie la correction de la réponse

4.1.4. Package : Gestion de la correction

Classe MoteurCorrection

Service de correction automatique des copies.

  • Méthodes publiques :

    • corrigerCopie(c: Copie): float - Corrige une copie et retourne la note

    • corrigerEpreuve(e: Epreuve): void - Corrige toutes les copies d’une épreuve

  • Méthodes privées :

    • comparerReponses(r: Reponse, rc: List<Choix>): boolean - Compare réponse étudiant vs correcte

    • calculerScore(copie: Copie): float - Calcule le score total

  • Note : Calcul automatique basé sur la comparaison entre les réponses de l’étudiant et les réponses correctes

Classe Statistiques

Métriques calculées sur les résultats d’une épreuve.

  • Attributs :

    • moyenne: float - Moyenne arithmétique des notes

    • ecartType: float - Écart-type de la distribution

    • minimum: float - Note minimale

    • maximum: float - Note maximale

    • distribution: Map<String, int> - Répartition des notes par tranche

  • Méthodes :

    • calculer(notes: List<float>): void - Calcule toutes les statistiques

    • genererRapport(): String - Génère un rapport textuel

Classe Note

Note attribuée à un étudiant pour une épreuve.

  • Attributs :

    • valeur: float - Valeur numérique (0-20)

    • datePublication: DateTime - Date de publication

    • estPubliee: boolean - Indicateur de visibilité

  • Méthodes :

    • publier(): void - Rend la note visible à l’étudiant

    • masquer(): void - Masque la note

4.1.5. Relations principales

Héritage

  • Enseignant et Etudiant héritent de Utilisateur (spécialisation)

Composition (diamant noir plein)

  • Banque compose Question (1 → 0..*)

  • Question compose Choix (1 → 2..*)

  • Epreuve compose Copie (1 → 0..*)

  • Copie compose Reponse (1 → 0..*)

Agrégation (diamant blanc)

  • Questionnaire agrège Question (1 → 1..*)

  • Epreuve agrège Questionnaire (1 → 1..*)

  • Copie agrège Questionnaire (1 → 1) - référence

Associations simples

  • Enseignant crée Epreuve (1 → 0..*)

  • Enseignant élabore Questionnaire (1 → 0..*)

  • Enseignant crée Question (1 → 0..*)

  • Etudiant produit Copie (1 → 0..*)

  • Etudiant consulte Note (1 → 0..*)

  • Reponse sélectionne Choix (0..* ↔ 1..*)

  • Copie obtient Note (1 → 0..1)

Dépendances

  • MoteurCorrection corrige Copie (dépendance)

  • MoteurCorrection génère Statistiques (dépendance)

4.1.6. Multiplicités clés

  • Un Questionnaire contient au minimum 1 question (1..*)

  • Une Question possède au minimum 2 choix (2..*)

  • Une Epreuve peut avoir 0 ou plusieurs copies selon la participation

  • Une Copie a 0 ou 1 note (avant/après correction)

4.2. Diagramme d’états - Cycle de vie d’une copie

Le diagramme d’états suivant modélise les différents états par lesquels passe une copie d’étudiant durant son cycle de vie.

etats-copie

4.2.1. États de la copie

Non Initialisée

  • État initial avant qu’un étudiant ne démarre l’épreuve

  • Aucune copie créée pour cet étudiant

En Cours

  • L’étudiant répond activement aux questions

  • Actions d’entrée : démarrerChronomètre()

  • Actions pendant : enregistrerRéponses()

  • Actions de sortie : arrêterChronomètre()

  • Transitions internes :

    • répondreQuestion() : enregistrement d’une réponse

    • naviguerEntreQuestions() : déplacement dans le questionnaire

    • modifierRéponse() : modification d’une réponse existante

Soumise

  • Copie remise en attente de correction

  • Actions d’entrée : horodaterSoumission()

  • Transition automatique possible si :

    • Durée maximale atteinte

    • Déconnexion intempestive de l’étudiant

Correction en cours (état composite)

  • Sous-état : Analyse des réponses

    • Comparaison avec les réponses correctes

  • Sous-état : Calcul de la note

    • Calcul du score final

    • Génération des statistiques

Corrigée

  • Note attribuée et correction disponible

  • Actions d’entrée :

    • calculerNote()

    • horodaterCorrection()

  • Note consultable uniquement après publication par l’enseignant

4.2.2. Transitions principales

  • NonInitialisée → EnCours : démarrerEpreuve() [étudiant authentifié]

  • EnCours → Soumise : soumettreVolontaire() [étudiant termine] OU soumettreAutomatique() [durée écoulée]

  • Soumise → Correction : lancerCorrection()

  • Correction → Corrigée : [correction terminée]

  • Corrigée → [fin] : archiverCopie() [après consultation]

4.2.3. Contraintes

  • Les choix sélectionnés doivent appartenir aux questions du questionnaire associé

  • La transition vers "Soumise" est irréversible

  • La note devient consultable uniquement après publication par l’enseignant

4.3. Diagramme de composants

Le diagramme de composants illustre l’architecture logicielle en couches du système QuizMaker.

composants

4.3.1. Couche Présentation

Interface Web Enseignant

  • Création et gestion des épreuves

  • Consultation des statistiques

  • Publication des notes

Interface Web Étudiant

  • Participation aux épreuves

  • Consultation des notes

Gestionnaire d’Authentification

  • Validation des identifiants

  • Gestion des sessions utilisateurs

  • Contrôle d’accès

4.3.2. Couche Métier

Contrôleurs

  • Contrôleur Epreuves : Orchestration du cycle de vie des épreuves

  • Contrôleur Questionnaires : Gestion des questionnaires

  • Contrôleur Utilisateurs : Gestion des utilisateurs et authentification

Services

  • Service Correction : Service asynchrone pour la correction automatique des copies

  • Service Notification : Envoi de notifications aux utilisateurs

  • Service Statistiques : Calcul et génération des statistiques

Moteur de Calcul

  • Moteur Calcul Notes : Algorithme de calcul des notes

    • Score par question

    • Pondération

    • Note finale sur 20

4.3.3. Couche Accès aux Données

Data Access Objects (DAO)

  • DAO Epreuves : CRUD épreuves

  • DAO Questionnaires : CRUD questionnaires

  • DAO Utilisateurs : CRUD utilisateurs

  • DAO Copies : CRUD copies et notes

4.3.4. Couche Persistance

Base de Données QuizMaker

Tables principales :

  • Utilisateurs : Enseignants et étudiants

  • Questionnaires : Banque de questionnaires

  • Questions : Questions des questionnaires

  • Choix : Choix possibles pour chaque question

  • Epreuves : Épreuves planifiées et réalisées

  • Copies : Copies des étudiants

  • Réponses : Réponses des étudiants

  • Notes : Notes attribuées

4.3.5. Composants Transversaux

Système de Gestion de Session

  • Gestion du cycle de vie des sessions utilisateurs

  • Lié au gestionnaire d’authentification

Gestionnaire de Cache

  • Cache des questionnaires fréquemment utilisés

  • Cache des requêtes vers les DAO

  • Optimisation des performances

  • TTL (Time To Live) configurable

Logger

  • Traçabilité des actions sur les épreuves

  • Traçabilité des corrections

  • Logs d’audit

4.3.6. API REST

Interface exposée pour la communication avec la couche présentation :

  • Endpoints pour les épreuves

  • Endpoints pour les questionnaires

  • Endpoints pour les utilisateurs

5. Architecture de Déploiement

5.1. Diagramme de déploiement

Le diagramme suivant présente l’infrastructure technique du système QuizMaker et la répartition des composants sur les différents nœuds matériels.

deploiement

5.1.1. Postes Clients

Poste Enseignant

  • Navigateur Web moderne (Chrome, Firefox, Edge, Safari)

  • Interface HTML responsive

  • Connexion HTTPS sécurisée

Poste Étudiant

  • Navigateur Web moderne

  • Interface HTML responsive

  • Connexion HTTPS sécurisée

5.1.2. Infrastructure Serveur

Serveur Web (Apache/Nginx)

  • Port : 443 (HTTPS)

  • Responsabilités :

    • Hébergement de l’interface utilisateur

    • Gestion SSL/TLS pour la sécurisation des communications

    • Compression des ressources (gzip)

    • Équilibrage de charge (Load Balancer)

  • Composants :

    • Serveur HTTP

    • Load Balancer

    • Pages statiques

    • Assets (CSS, JavaScript, images)

Serveur d’Application (Tomcat/Spring Boot)

  • Port : 8080 (HTTP interne)

  • Responsabilités :

    • Logique métier du système

    • Authentification JWT

    • Validation des données

    • Gestion des sessions utilisateurs

  • Composants :

    • API REST

    • Contrôleurs Métier

    • Services

    • Gestionnaire de Sessions

Serveur de Correction (Worker Service)

  • Responsabilités :

    • Traitement asynchrone des corrections

    • Correction automatique des copies

    • Calcul des notes

    • Génération des statistiques

  • Composants :

    • Moteur de Correction

    • Service de Calcul

    • File d’attente (Message Queue)

Serveur de Base de Données (PostgreSQL/MySQL)

  • Port : 5432 (PostgreSQL) ou 3306 (MySQL)

  • Responsabilités :

    • Stockage persistant de toutes les données

    • Transactions ACID

    • Sauvegardes régulières (backup)

    • Réplication possible pour haute disponibilité

  • Composant :

    • Système de Gestion de Base de Données (SGBD)

    • QuizMaker DB (tables métier)

Serveur de Cache (Redis)

  • Port : 6379 (TCP)

  • Responsabilités :

    • Cache des sessions utilisateurs

    • Cache des questionnaires fréquemment consultés

    • Cache des résultats temporaires

    • Amélioration significative des performances

  • Configuration :

    • TTL (Time To Live) configurable par type de donnée

    • Stratégie d’éviction LRU (Least Recently Used)

Serveur de Notification

  • Responsabilités :

    • Envoi de notifications aux utilisateurs

    • Support multi-canal

  • Composants :

    • Service Email (SMTP)

    • Service SMS (API tierce)

    • Service Push (notifications web/mobile)

5.1.3. Protocoles de Communication

  • Client ↔ Serveur Web : HTTPS (Port 443)

  • Serveur Web ↔ Serveur d’Application : HTTP/REST (Port 8080)

  • Serveur d’Application ↔ Base de Données : JDBC (Port 5432)

  • Serveur d’Application ↔ Cache : TCP/Redis Protocol (Port 6379)

  • Serveur d’Application ↔ Serveur de Correction : Message Queue (asynchrone)

  • Serveur de Correction ↔ Base de Données : JDBC (Port 5432)

  • Serveur d’Application → Serveur de Notification : SMTP/API

5.1.4. Réseau

Internet (Cloud)

  • Point d’entrée public pour les utilisateurs

  • Routage vers le serveur web via HTTPS

  • Isolation du réseau interne

6. Flux de Données et Algorithmes

6.1. Algorithme de correction automatique

L’algorithme de correction automatique compare les réponses des étudiants avec les réponses correctes du questionnaire.

Pseudo-code :

POUR chaque copie NON corrigée FAIRE
    score_total = 0

    POUR chaque question du questionnaire FAIRE
        réponse_étudiant = récupérer_réponse(copie, question)
        réponse_correcte = récupérer_réponse_correcte(question)
        points_question = question.points

        SI réponse_étudiant == réponse_correcte ALORS
            score_total = score_total + points_question
        FIN SI
    FIN POUR

    note_finale = (score_total / score_maximum) * 20
    enregistrer_note(copie, note_finale)
    marquer_copie_comme(CORRIGEE)
FIN POUR

calculer_statistiques_globales()

Complexité : O(n × m) où n = nombre de copies, m = nombre de questions

6.2. Algorithme de calcul des statistiques

notes[] = récupérer_toutes_les_notes(épreuve)
n = taille(notes)

// Moyenne
somme = 0
POUR chaque note DANS notes FAIRE
    somme = somme + note
FIN POUR
moyenne = somme / n

// Écart-type
somme_carrés_écarts = 0
POUR chaque note DANS notes FAIRE
    écart = note - moyenne
    somme_carrés_écarts = somme_carrés_écarts + (écart * écart)
FIN POUR
variance = somme_carrés_écarts / n
écart_type = racine_carrée(variance)

// Distribution (tranches de notes)
distribution = initialiser_tableau(0..20)
POUR chaque note DANS notes FAIRE
    tranche = arrondir_inf(note)
    distribution[tranche] = distribution[tranche] + 1
FIN POUR

RETOURNER {moyenne, écart_type, distribution}

7. Considérations Techniques

7.1. Sécurité

Authentification

  • Utilisation de JWT (JSON Web Tokens) pour l’authentification

  • Stockage sécurisé des mots de passe (bcrypt, Argon2)

  • Session timeout configurable

Autorisation

  • Contrôle d’accès basé sur les rôles (RBAC)

  • Enseignants : création/correction/publication

  • Étudiants : participation/consultation limitée

Communication

  • HTTPS obligatoire pour toutes les communications externes

  • Certificats SSL/TLS valides

  • Protection contre les attaques XSS, CSRF, injection SQL

7.2. Performance

Optimisations

  • Cache Redis pour les données fréquemment consultées

  • Pagination des résultats

  • Lazy loading des questions

  • Compression gzip des ressources

Scalabilité

  • Architecture stateless au niveau applicatif

  • Load balancing horizontal

  • Séparation du serveur de correction pour parallélisation

  • File d’attente pour les traitements asynchrones

7.3. Disponibilité

  • Réplication de la base de données (master-slave)

  • Sauvegardes automatiques quotidiennes

  • Plan de reprise après sinistre (DRP)

  • Monitoring et alertes

7.4. Maintenance

Logs

  • Logging centralisé de toutes les opérations critiques

  • Rotation des logs

  • Niveaux : DEBUG, INFO, WARN, ERROR

Monitoring

  • Surveillance des performances serveur

  • Métriques applicatives (temps de réponse, taux d’erreur)

  • Alertes automatiques en cas d’anomalie

8. Glossaire

Terme Définition

Épreuve

Instance d’un questionnaire définie dans le temps, avec une date de début et une durée

Questionnaire

Ensemble de questions constituant la base d’une épreuve

Copie

Ensemble des réponses d’un étudiant pour une épreuve donnée

DAO

Data Access Object - Pattern de conception pour l’accès aux données

JWT

JSON Web Token - Standard d’authentification par jeton

CRUD

Create, Read, Update, Delete - Opérations de base sur les données

TTL

Time To Live - Durée de vie d’une donnée en cache

RBAC

Role-Based Access Control - Contrôle d’accès basé sur les rôles

ACID

Atomicité, Cohérence, Isolation, Durabilité - Propriétés des transactions

9. Annexes

9.1. Conventions de nommage

Classes

  • PascalCase : GestionnaireEpreuve, ServiceCorrection

Méthodes

  • camelCase : créerEpreuve(), calculerNote()

Variables

  • camelCase : idEpreuve, noteFinale

Constantes

  • UPPER_SNAKE_CASE : ETAT_EN_COURS, DUREE_MAX

Tables de base de données

  • PascalCase au singulier : Utilisateur, Epreuve, Copie

9.2. États des entités

États d’une épreuve :

  • PLANIFIEE : Créée mais pas encore démarrée

  • EN_COURS : Accessible aux étudiants

  • TERMINEE : Tous les étudiants ont soumis

  • CORRIGEE : Correction effectuée

  • PUBLIEE : Notes visibles par les étudiants

États d’une copie :

  • NON_INITIALISEE : Pas encore démarrée

  • EN_COURS : Étudiant en train de répondre

  • SOUMISE : Copie remise

  • CORRIGEE : Note calculée

9.3. Technologies recommandées

Frontend

  • HTML5, CSS3, JavaScript (ES6+)

  • Framework : React.js ou Vue.js

  • UI Library : Bootstrap ou Material-UI

Backend

  • Langage : Java 11+ ou Python 3.9+

  • Framework : Spring Boot ou Django

  • API : REST avec JSON

Base de données

  • SGBD relationnel : PostgreSQL 13+ ou MySQL 8+

  • ORM : Hibernate (Java) ou SQLAlchemy (Python)

Cache

  • Redis 6+

Serveur Web

  • Nginx ou Apache HTTP Server

Conteneurisation

  • Docker

  • Orchestration : Kubernetes (optionnel pour haute disponibilité)

10. Contact et Support

Pour toute question concernant cette fonctionnalité :

Auteur : Cheikh Tidiane DIOP
Institution : Université de Nantes - Master Informatique

Document construit conformément à l’exigence NF-Req-3

Format : Asciidoc

Version : 1.0

Date : 2026-02-16