Rapport du Projet de Fin d'Année

School
Management
Conception et développement d'une
système de gestion scolaire

Encadré par : Mr El Jonhy Younes

Rédigé par : Aymane AIT OMAR, Mohamed El Boutahri et

Ahmed El Mehdi El Ouariti

Année scolaire: 2025/2026

 REMERCIEMENTS
La finalisation de "School Management : Gestion scolaire", fruit d'une intense
collaboration, n'aurait pu aboutir sans le soutien de précieux acteurs.

Nous exprimons notre profonde gratitude envers Monsieur El jonhy Younes, notre
encadrante, dont la guidance experte et la disponibilité ont structuré notre travail.

En tant que binôme, Aymane Ait Omar, Ahmed El Mehdi El Ouariti et Mohamed El
Boutahri, nous soulignons notre synergie et notre engagement mutuel, piliers de cette
réalisation.

Enfin, notre gratitude s'adresse à l'EMSI pour le cadre académique stimulant et les ressources
mises à disposition.

Que tous ceux ayant contribué à " School Management " trouvent ici l'expression de notre
profonde et sincère reconnaissance.
 Table des matières

Table des matières

INTRODUCTIONGÉNÉRALE .................................................................................... 1
CHAPITRE1:.................................................................................................... 3
1.1 Introduction à l’école : .................................................................................................................. 4
CHAPITRE2:.................................................................................................... 7
2.1 Introduction : .............................................................................................................................. 8
2.2 Problématique :........................................................................................................................... 8
2.3 Etat de l’art :...................................................................................................................................... 8
2.4 Motivation du projet : ........................................................................................................................... 9
2.5 Objectifs et engagements du projet :......................................................................................................... 9
2.6 Solution proposée : ........................................................................................................................... 10
2.7 Analyse de l’existant :......................................................................................................................... 11
2.9Conclusion :...................................................................................................................................... 12
Chapitre3: ....................................................................................... 13
3.6 Conclusion :............................................................................................................................. 25
CHAPITRE4:................................................................................................... 26
4.1 Introduction : ............................................................................................................................ 27
4.2 Technologies et environnement de développement : ...................................................................... 27
4.3 Architecture logicielle du système : ............................................................................................. 30
4.4 Étapes de Réalisation du Projet : .................................................................................................. 31
4.5 Exemple d'Exécution de Processus dans l'Application deGestion budgétaire: ................................. 31
Présentation des Captures d'Écran............................................................................................................ 33
CHAPITRE5:................................................................................................... 39
5.1 Introduction : ................................................................................ 40
5.2 Analyse critique et comparatif : ............................................................ 40
5.3 Tableau de test : ............................................................................ 41
5.4 Conclusion du chapitre : .................................................................... 43
Conclusion etPerspectives ....................................................................... 44
Bibliographie ..................................................................................... 46
 RÉSUMÉ

Le projet « School Management » a pour objectif de concevoir et de développer une application

web innovante dédiée à l'optimisation et à la modernisation du pilotage des établissements
éducatifs. Face aux difficultés croissantes rencontrées par le personnel pédagogique, les parents
et les élèves pour interagir de manière fluide et centraliser les données académiques au quotidien,
ce qui mène souvent à un manque de visibilité et à des processus administratifs lourds, cette
initiative propose un système de gestion intégré et simplifié.
L'objectif principal est d'offrir aux utilisateurs un contrôle total et transparent sur le suivi éducatif
à travers la saisie intuitive des notes et des présences par les enseignants, le calcul automatisé des
moyennes en temps réel, et la visualisation claire de l'emploi du temps ou de la progression
pédagogique via des tableaux de bord ergonomiques. Une innovation majeure de la plateforme
réside dans la séparation stricte de ses fonctionnalités selon quatre profils d'acteurs clés
(Administration, Enseignants, Élèves, Parents) conditionnés par un espace d'authentification
unique et sécurisé.
Développée avec le Framework Django et une base de données MySQL, l'application garantit
une architecture robuste et sécurisée, tout en offrant une interface utilisateur responsive. Ce
rapport explore les phases d'analyse UML — notamment à travers les diagrammes de cas
d'utilisation, de classes et de séquence —, la modélisation des données (s'appuyant sur une classe
de base abstraite Utilisateur), ainsi que les étapes de réalisation technique, en démontrant
comment le numérique peut favoriser une gouvernance scolaire plus accessible, fiable et
efficace.
 ABSTRACT
The "School Management" project aims to design and develop an innovative web application
dedicated to optimizing and modernizing educational institution management. Addressing the
common challenges faced by pedagogical staff, parents, and students in fluidly interacting and
centralizing academic data daily, which often lead to a lack of visibility and heavy administrative
burdens this initiative proposes a simplified and integrated management system.

The primary objective is to empower users with full and transparent control over educational
tracking through intuitive grade and attendance logging by teachers, real-time automated average
calculation, and clear visualization of schedules or pedagogical progress via ergonomic
dashboards. A major innovation of the platform lies in the strict separation of its functionalities
according to four key actor profiles (Administration, Teachers, Students, Parents) conditioned by
a unique and secure authentication space.

Developed with the Django framework and a MySQL database, the application ensures robust
and secure architecture while offering a responsive user interface. This report details the UML
analysis phases notably through use case, class, and sequence diagrams, data modeling (relying
on a "User" abstract base class), and technical implementation steps, demonstrating how digital
tools can effectively promote accessible and reliable school governance.
 Liste de figures :

Figure 1 : Un des sites de l’EMSI ............................................................................................... 11

Figure 2 : Historique de l’EMSI ................................................................................................... 13
Figure 3 : Diagramme de cas d’utilisation.................................................................................... 31
Figure 4 : Diagramme de Sequence .............................................................................................. 35
Figure 5 : Diagramme de classe .................................................................................................... 37
Figure 6 : Les Pages d'Admin ....................................................................................................... 52
Figure 7 : Les Pages de Teacher ................................................................................................... 54
Figure 8 : Les Pages de Student .................................................................................................... 54
Figure 9 : Les Pages de Parent ...................................................................................................... 55
 Liste des tableaux

Tableau 1 : Besoins fonctionnels

Tableau 2 : Besoins non fonctionnels
Tableau 3 : Tableau des Technologies
Tableau 4 : Principaux cas d'utilisation
Tableau 5 : Outils et technologies
Tableau 6: Comparaison entre la solution actuelle et les méthodes classiques
Tableau 7: Tableau de test
INTRODUCTION GÉNÉRALE
L'École Marocaine des Sciences de l'Ingénieur (EMSI), reconnue pour sa
formation d'excellence et son engagement envers l'innovation technologique,
constitue le cadre académique de ce Projet de Fin d'Année (PFA). Ce travail
s'inscrit dans une problématique organisationnelle et pédagogique de plus en
plus prégnante au Maroc : la modernisation de la gouvernance scolaire et la
centralisation rigoureuse des flux d'informations académiques,particulièrement
au sein des établissements éducatifs.

Dans un contexte éducatif marqué par l'évolution constante des exigences

administratives et la nécessité d'une communication fluide entre les différents
acteurs, la maîtrise des données scolaires est devenue un enjeu majeur. De
nombreux établissements marocains font face à des difficultés pour suivre en
temps réel les performances des élèves, les absences ou les plannings, ce qui
mène souvent à un manque de visibilité pour les parents et à des processus
administratifs lourds. Le manque d'outils numériques intuitifs, sécurisés et
centralisés souligne l'urgence de proposer des solutions facilitant une prise de
décision administrative éclairée et un suivi rigoureux de la scolarité.
Face à ce défi, et considérant le potentiel des avancées technologiques dans le
domaine du développement web et de la modélisation logicielle, notre projet «
School Management» ambitionne de proposer une solution innovante.
L'objectif principal est de concevoir et de développer une application web
optimisée, capable de simplifier le suivi pédagogique et administratif tout en
renforçant la connectivité au sein de la communauté scolaire.

Pour atteindre cet objectif, notre plateforme intègre notamment un espace

d'authentification unique et sécurisé qui segmente ses fonctionnalités selon
quatre profils d'acteurs clés : l'administration pour le pilotage global, les
enseignants pour la saisie intuitive des notes et le suivi des présences, ainsi que
les élèves et les parents pour la consultation transparente des résultats, des
absences et des emplois du temps. Développée avec le framework Django et
une base de données MySQL, l'application s'appuie sur une conception UML
rigoureuse pour offrir une gestion plus sereine, fiable et efficace de
l'établissement.

Ce rapport, qui détaille la démarche suivie, l'analyse UML, les choix

techniques et les résultats obtenus, est structuré en cinq chapitres :

1
 Chapitre 1 : Présentation de l’école et du contexte
Ce chapitre présente l'EMSI, cadre académique de ce travail, et expose les enjeux liés à la
modernisation de la gouvernance scolaire et à la centralisation des flux d'informations
académiques. Il définit la problématique de gestion et de communication rencontrée par les
établissements éducatifs ainsi que les objectifs globaux de l'application de gestion scolaire.

Chapitre 2 : Présentation du projet et cahier des charges

Ce chapitre est consacré à la présentation détaillée du projet. Il expose le périmètre de la
solution, les besoins spécifiques des différentes parties prenantes de la communauté
éducative ainsi que le cahier des charges fonctionnel et technique de l'application,
incluant la séparation stricte des fonctionnalités selon les quatre profils d'acteurs clés
(Administration, Enseignants, Élèves, Parents).

Chapitre 3 : Analyse et conception

Ce chapitre détaille l'analyse des besoins à travers la modélisation UML, en
s'appuyant notamment sur le diagramme de cas d'utilisation, le diagramme de classes
structuré autour de l'entité abstraite Utilisateur, et les diagrammes de séquence. Il
justifie également les choix de conception logicielle et présente l'architecture
relationnelle de la base de données MySQL destinée à stocker les notes, les présences
et les cours.

Chapitre 4 : Réalisation et développement

Ce chapitre décrit la mise en œuvre technique du projet. Il présente l'environnement

de développement, les outils et frameworks utilisés (Django, Python,
HTML/CSS/JavaScript, Bootstrap) , la structure modulaire de l'application (modules
accounts, courses, dashboard, reports) , ainsi que les captures d'écran des interfaces
finales du système.

Chapitre 5 : Résultats, tests et validation

Ce dernier chapitre est dédié à la phase de validation. Il présente les tests de flux
effectués pour garantir le bon fonctionnement du système (validation des connexions
et contrôle des saisies de données par le backend), les résultats obtenus par rapport
aux objectifs de pilotage initiaux, ainsi que les perspectives d'évolution pour le projet
scolaire.
2
 CHAPITRE 1 :
Présentation de l’école et du contexte

3
1.1 Introduction à l’école :

Présentation de l'École et de son Environnement :

Figure 1 : Un des sites de l’EMSI

L'EMSI (École Marocaine des Sciences de l'Ingénieur) se distingue comme l'une des
institutions privées pionnières et de référence dans l'enseignement supérieur d'ingénierie au
Maroc. Fondée sur une vision d'excellence et d'innovation, l'école s'efforce d'offrir un
environnement d'apprentissage stimulant et complet, propice au développement académique et
personnel de ses étudiants. Ses campus modernes, stratégiquement implantés dans les grandes
villes dynamiques du Maroc telles que Casablanca, Rabat, Marrakech et Tanger, sont dotés
d'infrastructures de pointe : laboratoires spécialisés, salles informatiques équipées,
bibliothèques fournies et espaces de vie étudiante. Cet écosystème favorise non seulement
l'acquisition de compétences techniques de haut niveau, mais aussi l'épanouissement des

étudiants dans un cadre qui reflète le dynamisme du monde professionnel et encourage

l'interaction et la collaboration.

Historique de l'EMSI :
4
Fondée en 1986, l’École Marocaine des Sciences de l’Ingénieur (EMSI) s’est imposée comme
l’un des établissements privés d’enseignement supérieur les plus reconnus au Maroc dans le
domaine de l’ingénierie. Depuis sa création, l’EMSI a pour mission de former des ingénieurs
compétents, innovants et adaptés aux besoins du marché national et international. L’école a su
évoluer au fil des années en diversifiant ses filières, en renforçant ses partenariats avec le
monde industriel et en s’investissant activement dans la recherche appliquée et l’innovation
technologique.

FIGURE 2 : HISTORIǪUE DE L’EMSI

Depuis sa fondation en 1986, l'EMSI a tracé un chemin riche et distinctif en tant que précurseur
de l'enseignement supérieur privé en ingénierie au Maroc. Son historique est jalonné d'une
5
croissance constante et d'une capacité remarquable à s'adapter aux évolutions rapides des
technologies et aux exigences du marché de l'emploi. Cette longévité témoigne de sa vision
avant-gardiste et de son engagement à former des générations d'ingénieurs qui ont contribué et
continuent de contribuer au développement économique et technologique du pays. L'école a su
évoluer avec son temps, élargissant ses domaines d'expertise et affinant sa pédagogie pour
rester à la pointe de l'innovation.

Missions et Secteurs d'Activité de l'EMSI :

La mission principale de l'EMSI est de former des ingénieurs hautement qualifiés, polyvalents
et dotés d'une forte capacité d'adaptation aux défis du monde moderne. L'école s'attache à
développer chez ses étudiants non seulement des compétences techniques pointues, mais aussi
des aptitudes managériales, entrepreneuriales et humaines essentielles à leur réussite
professionnelle et personnelle. Pour ce faire, l'EMSI propose des formations accréditées dans
des secteurs d'activité clés et en constante évolution, tels que le génie informatique (avec des
spécialisations en génie logiciel, systèmes d'information, réseaux et cybersécurité), le génie
industriel (logistique, management de la production, qualité), le génie civil (structures,
infrastructures, gestion de projets), le génie électrique et les énergies renouvelables
(automatisme, électronique de puissance, énergies nouvelles), ainsi que le génie des systèmes
embarqués & mobile et le Big Data & Cloud Computing. L'objectif est de préparer des lauréats
capables d'intégrer rapidement le monde professionnel et d'être des acteurs innovants et
influents.

6
 CHAPITRE 2 :
Présentation du projet

7
2.1 Introduction :
La gestion rigoureuse et centralisée des flux d'informations académiques représente un enjeu majeur pour
les établissements éducatifs, en particulier pour le personnel pédagogique, les parents et les élèves. Entre
le suivi quotidien des présences, la maîtrise de la saisie des notes et la planification transparente des
emplois du temps, de nombreuses difficultés peuvent compliquer le maintien d'une communication fluide
et d'un pilotage administratif sain.

Ce projet propose une solution numérique sous la forme d'une plateforme web intuitive, conçue pour
simplifier la gouvernance scolaire. En intégrant des fonctionnalités telles que la gestion automatisée des
classes et des matières, la visualisation claire de la progression pédagogique via des tableaux de bord
ergonomiques et l'accès sécurisé segmenté selon quatre profils d'acteurs clés, cette plateforme vise à
améliorer l'efficacité des services administratifs et à renforcer la connectivité de la communauté scolaire.

Ce document présente les fondements du projet, ses objectifs ainsi que les choix technologiques,
notamment le framework Django et la base de données MySQL, adoptés pour sa réalisation.

2.2 Problématique :
Les établissements éducatifs, et plus particulièrement la communauté scolaire, font face à la nécessité
d'un suivi rigoureux de leurs flux d'informations académiques pour garantir leur stabilité pédagogique.
Cela implique une surveillance constante des absences quotidiennes, une planification des emplois du
temps et une analyse précise de la répartition des notes.
Cependant, l'absence d'un outil centralisé et intuitif mène souvent à une gestion approximative, à l'oubli
de certaines données et, à terme, à des difficultés de communication imprévues. Les méthodes
traditionnelles (papier ou fichiers Excel complexes) s'avèrent souvent décourageantes et manquent
d'interactivité pour offrir un véritable accompagnement aux utilisateurs.
Ainsi, comment concevoir une application web permettant une gestion scolaire intégrée et automatisée ,
tout en offrant des espaces sécurisés et dédiés à chaque profil d'acteur (Administration, Enseignants,
Élèves, Parents) pour optimiser le pilotage de l'établissement?

2.3 Etat de l’art :

L'évolution des technologies pousse les établissements scolaires à adopter des systèmes d'information de
gestion (SIGS). L'étude quantitative de K. Demir (2006) démontre que, malgré le manque
d'infrastructures techniques adéquates en école primaire, ces outils s'avèrent indispensables à
l'administration et au pilotage de ces structures. Pour matérialiser ces besoins, la conception UML d'un
SIGS s'articule autour d'une interface web connectée à un backend et à une base de données centrale.
L'accès à l'application requiert une authentification sécurisée par identifiant et mot de passe, ouvrant
ensuite la voie à quatre espaces fonctionnels bien distincts.
Le profil de l'administration possède les privilèges les plus étendus pour générer des rapports et
administrer les utilisateurs, les classes ou les matières. Les enseignants se chargent de la gestion
pédagogique en assurant le suivi des absences et la saisie des notes, opération automatiquement
contrôlée et validée par le backend avant son enregistrement. De manière plus transparente, les
élèves consultent directement leurs notes, leurs absences et leur emploi du temps. Enfin, l'espace
parent offre un suivi de scolarité à distance en interrogeant la base de données pour afficher un
rapport visuel de la progression de l'enfant. Toute cette architecture logicielle s'appuie sur un
modèle de données robuste où une classe abstraite Utilisateur sert de base aux profils, complétée
8
par les entités interconnectées Élève, Cours, Note, Présence et Inscriptio, comme mentionné dans
l'article(Demir, 2006).

Ce document présente un système intégré de gestion scolaire conçu pour dynamiser les interactions
éducatives en connectant directement les élèves et les enseignants. L'objectif premier est de proposer une
plateforme web intuitive qui facilite le partage et la récupération de ressources académiques au format
PDF, tout en prenant en charge le multilinguisme dès son lancement avec l'anglais et l'arabe. Pour
accompagner au mieux les nouveaux utilisateurs, le système intègre des vidéos d'introduction
pédagogiques ainsi qu'un module de suivi des présences dédié à la sécurité des élèves. Parmi ses
fonctionnalités clés, la plateforme propose la gestion des profils et des inscriptions, un espace
d'authentification et de connexion sécurisé, un tableau de bord ergonomique, des outils de messagerie
directe et un calendrier de planification. Elle offre également un système structuré de téléversement,
d'organisation et de recherche de fichiers PDF, complété par des notifications en temps réel et des
mesures strictes pour garantir la sécurité et la confidentialité des données. Sur le plan technique, la
solution s'appuie sur une interface moderne développée en HTML5, CSS3, JavaScript et Tailwind, un
backend propulsé par [Link], une base de données MongoDB, une authentification par jetons JWT, ainsi
qu'un stockage cloud centralisé, comme mentionné dans l'article(Salama & Aly, 2024)

L'évolution des exigences administratives pousse les institutions scolaires à concevoir de nouveaux
systèmes de gestion électronique pour moderniser leur gouvernance. Cette étude examine le
fonctionnement d'un système d'information de gestion scolaire (SIGS) et analyse l'opinion des
enseignants d'un établissement face à son utilisation. Menée en République du Kosovo auprès de 25
enseignants de l'école primaire et secondaire inférieure « Heronjtë e Lumës » (municipalité de Prizren), la
recherche adopte une méthode mixte combinant des données quantitatives et qualitatives recueillies par
questionnaire. Les conclusions révèlent que les participants ont une perception très positive de cet outil de
gestion électronique, qui a pleinement répondu à leurs attentes professionnelles. Les résultats soulignent
que l'ensemble du personnel pédagogique et de l'établissement a bénéficié de cette transition numérique,
et les enseignants recommandent fermement la pérennisation et la poursuite de ce système à l'avenir,
comme mentionné dans l'article(Orhani et al., 2023).

2.4 Motivation du projet :

Gérer les flux d'informations académiques au quotidien s'apparente souvent à un véritable défi.
Entre les évaluations à planifier à date fixe, le suivi des absences imprévues et la nécessité de
maintenir une progression pédagogique stable, de nombreuses parties prenantes, notamment les
enseignants, parents et élèves, se sentent rapidement dépassées.
Il est facile de perdre le fil des performances scolaires ou de sous-estimer de petits retards
répétés, sans se rendre compte des risques de déséquilibre dans l'apprentissage ou le pilotage de
l'établissement que cela peut engendrer à long terme.
Dans ce contexte, une solution numérique simple, intuitive et parfaitement intégrée à leur routine
quotidienne pourrait les aider à mieux maîtriser le suivi éducatif, à anticiper les complications
administratives et à retrouver une véritable sérénité organisationnelle.

2.5 Objectifs et engagements du projet :

L’objectif principal de ce projet est de développer une plateforme numérique interactive et
performante, dédiée à l’optimisation de la gestion et du suivi académique au sein des

9
établissements. Cette solution vise à offrir un accompagnement personnalisé, à renforcer la
transparence éducative pour les utilisateurs et à simplifier le suivi de la scolarité au quotidien.
Plus concrètement, elle permettra de :

• Centraliser le suivi des flux académiques : saisie intuitive et organisée de l'ensemble

des notes, des présences et des cours dispensés.
• Automatiser les calculs pédagogiques : évaluation en temps réel des moyennes des
élèves et calcul automatique de la progression des classes.
• Visualiser les performances scolaires : génération de tableaux de bord dynamiques
pour identifier les résultats par matière, l'historique des absences et les tendances
trimestrielles.
• Exploiter la segmentation des profils : intégration d'un espace sécurisé propre à chaque
acteur (Administration, Enseignants, Élèves, Parents) capable de fournir un accès ciblé
basé sur des droits métier précis.
• Faciliter la prise de décision administrative : accès rapide à un historique clair et à des
indicateurs clés pour aider l'administration à générer automatiquement des rapports
d'activité.
• Garantir une accessibilité multi-support : offrir une interface responsive permettant un
suivi rigoureux de la scolarité aussi bien sur ordinateur que sur smartphone.
2.6 Solution proposée :
Nous proposons une application web dotée des fonctionnalités suivantes :
Suivi des flux académiques :
• Enregistrement intuitif et catégorisé des notes, des présences et des cours dispensés.
• Calcul automatisé et en temps réel des moyennes globales et de la progression pédagogique
disponible.
Journal de bord éducatif :
• Historique détaillé des évaluations et des absences quotidiennes des élèves.
• Génération de rapports automatiques pour identifier les baisses de résultats ou les anomalies
d'assiduité.
Visualisation et tableaux de bord :
• Interface graphique dynamique pour analyser la répartition des performances par matière.
• Suivi visuel de l'évolution des résultats trimestre par trimestre pour limiter les décrochages
scolaires.
Espaces dédiés par profil :
• Intégration d'espaces fonctionnels basés sur des droits métier pour répondre aux besoins de
chaque acteur (Administration, Enseignants).
• Fourniture d'accès personnalisés pour les élèves et les parents afin de consulter l'emploi du
temps ou la progression de l'enfant.
Analyse et validation :
• Algorithmes permettant au backend de valider strictement la concordance entre l'élève et la
matière lors de la saisie.
• Requêtes automatisées pour une meilleure extraction des données de scolarité stockées en
base.
Sécurisation et accès aux données :
• Authentification unique et sécurisée pour protéger l'accès aux données scolaires
personnelles.
10
 • Stockage structuré et rapide des informations de l'établissement via une base de données
MySQL.

2.7 Analyse de l’existant :

Au Maroc, la gestion des flux d'informations académiques constitue un défi croissant pour
une large partie de la communauté éducative, particulièrement pour le personnel
pédagogique, les parents et les élèves. Avec l'évolution des exigences administratives et
l'augmentation des effectifs, la maîtrise du suivi scolaire est devenue une nécessité pour
garantir une stabilité pédagogique. Bien que des méthodes traditionnelles et certaines
solutions génériques existent, plusieurs obstacles freinent une gouvernance scolaire efficace
au niveau local :
Complexité des outils actuels : Les solutions existantes (tableurs Excel complexes ou
registres papier limités) sont souvent perçues comme fastidieuses, ce qui décourage les
utilisateurs d'enregistrer leurs données de manière régulière.
Absence de suivi structuré et centralisé : La majorité des établissements ne disposent pas
d'une vue d'ensemble claire sur la répartition des notes et des présences, entraînant une
difficulté à identifier les décrochages scolaires.
Manque d'accompagnement et de communication : Les outils classiques se contentent de
stocker des chiffres sans offrir d'analyse critique ou d'espaces sécurisés dédiés pour aider les
parents à suivre la progression de leur enfant.
Faible adoption des solutions automatisées : Malgré la digitalisation croissante des services
au Maroc, l'utilisation d'outils numériques intelligents pour la gestion des établissements reste
limitée par manque d'applications intuitives et adaptées aux besoins spécifiques des quatre
profils d'acteurs.
Face à ces constats, il est crucial de développer une solution numérique qui non seulement
automatise le suivi des flux académiques quotidiens, mais qui propose également des
tableaux de bord interactifs et une validation stricte des données au niveau du backend pour
conseiller les utilisateurs et améliorer le pilotage de l'établissement.

Phases du projet et technologies utilisées

Le projet se déroule en plusieurs phases clés, chacune avec des objectifs spécifiques :
• Analyse des besoins et rédaction du cahier des charges : Cette phase initiale a permis de
définir les attentes des utilisateurs (administration, enseignants, élèves et parents) en matière de
suivi académique. Elle a abouti à l'identification des fonctionnalités prioritaires :
11
 l'authentification sécurisée par profil et la gestion des notes et des absences.
• Conception et modélisation : Il s'agit de structurer l'architecture logicielle et de modéliser la
base de données. À l'aide de l'UML (diagrammes de cas d’utilisation, de classes et de
séquence), nous avons défini comment l'entité abstraite Utilisateur interagit avec les classes
Cours et Notes, tout en choisissant MySQL pour sa légèreté et sa fiabilité.
• Développement du Backend (Logique métier et architecture) : Cette étape constitue le
cœur du projet. Nous avons utilisé le framework Python Django pour gérer les différents
modules, notamment l'authentification des profils (accounts), la gestion des cursus (courses),
ainsi que le calcul automatisé des moyennes générales et le traitement de la logique métier.
• Développement du Frontend (Interface utilisateur) : L'objectif est de proposer une interface
intuitive et responsive. HTML5 structure les tableaux de bord spécifiques à chaque rôle, CSS3
assure une présentation visuelle claire des plannings et des résultats scolaires, et JavaScript
permet une interactivité dynamique pour la navigation fluide entre les modules.
• Intégration et communication : Cette phase assure la liaison fluide entre les modèles Django
et l'interface utilisateur, permettant de transformer les données académiques brutes stockées en
visualisations compréhensibles et en tableaux de bord (dashboard) interactifs pour l'utilisateur
final.
• Tests fonctionnels et validation : Des tests rigoureux ont été menés pour vérifier la précision
du calcul des moyennes, la sécurité des accès conditionnés par profil, la validité des flux de
données du backend et la robustesse de la génération des rapports d'activité (reports).
• Finalisation et documentation : Cette dernière phase comprend la rédaction du rapport
technique du PFA et de la documentation utilisateur, expliquant comment optimiser le pilotage
de l'établissement éducatif grâce aux outils mis en place.
2.9 Conclusion :
L’optimisation de la gestion administrative et le développement d’une gouvernance éducative
centralisée constituent des enjeux majeurs pour les établissements, le personnel pédagogique, les
parents et les élèves. Grâce à une solution numérique innovante, structurée autour du framework
Django et d'une base de données MySQL, ce projet ambitionne de simplifier le suivi des flux
académiques quotidiens.

L’intégration d’espaces sécurisés dédiés par profil d'acteur et la centralisation des notes, des
absences et des cours permettent une gestion plus proactive et éclairée, aidant les utilisateurs à
éviter le manque de visibilité et à maximiser l'efficacité pédagogique. En offrant une
visualisation claire de la progression des élèves et des rapports d'activité automatisés, cette
plateforme contribue à renforcer l'autonomie organisationnelle et à promouvoir une
communication fluide au sein d'une interface sécurisée et conviviale.

12
 Chapitre 3 :
Analyse et conception

13
3.1 Introduction :
L'analyse et la conception sont des étapes clés dans le développement d'un système
d'information. Ce chapitre vise à détailler l'analyse des besoins, l'identification des quatre profils
d'acteurs, ainsi que la modélisation du système à travers des diagrammes formels.
Nous utiliserons principalement le langage UML pour la conception des cas d'utilisation, du
diagramme de classes structurant l'entité abstraite Utilisateur et des interactions dynamiques via
les diagrammes de séquence.

3.2 Analyse et Spécification du Projet

3.2.1 Identification des besoins fonctionnels et non fonctionnels :
[Link] Exigences fonctionnelles

• Authentification : connexion et déconnexion sécurisées avec gestion des sessions selon

quatre profils d'utilisateurs (Django Auth).

• Saisie des données : formulaire pour ajouter et valider les notes ou les absences des élèves
(note, coefficient, matière, date, statut d'absence).

• Tableau de bord : affichage des moyennes générales, du total des cours dispensés, du taux de
présence et des statistiques clés de l'établissement.

• Historique et suivi : liste filtrable et triable de toutes les notes attribuées, des absences
enregistrées et des plannings par classe.

• Alertes : avertissement visuel sur l'interface en cas de baisse de résultats ou de dépassement

du seuil d'absences autorisé pour un élève.

• Graphiques : courbe d'évolution des notes trimestrielles et camembert de répartition des taux
de présence ([Link] ou équivalent).

• Gestion des modules : espaces de travail intégrés pour les modules spécifiques (accounts
pour les profils, courses pour le suivi des programmes).

• Paramétrage : définition et configuration des classes, des coefficients par matière et des
droits d'accès pour chaque acteur de l'école.

Tableau 1 : Besoins fonctionnels

ID Besoins fonctionnels

Authentification : inscription, connexion, déconnexion avec gestion des sessions et des

F1
rôles (admin, enseignant, élève, parent) via Django Auth.

14
 ID Besoins fonctionnels

Gestion des utilisateurs : création, modification et suppression des comptes par

F2 l'administrateur avec formulaires de saisie des informations (nom, prénom, rôle,
identifiant).

Gestion des classes / groupes : création et administration des classes (1AC, 2AC, 3AC, TC,
F3
1BAC, 2BAC) avec affectation des élèves et des enseignants.

Gestion des cours (matières) : définition des cours par classe (code, intitulé, crédits,
F4
enseignant responsable, groupe) et consultation par rôle.

Saisie des notes : formulaire enseignant pour enregistrer les notes des élèves (valeur 0–20,
F5
type : examen / quiz / devoir / projet, commentaire).

Gestion des absences : marquage de la présence par cours et par date avec statuts (présent,
F6
absent, en retard) et notes associées, en mode individuel ou groupé.

Tableau de bord : vues personnalisées selon le rôle — statistiques enseignant (élèves,

F7
cours, notes du mois), vue élève (moyenne, assiduité, prochain cours).

Emploi du temps : affichage hebdomadaire des créneaux par classe avec mise en évidence
F8
du jour courant.

Suivi parentale : consultation par le parent des notes et présences de ses enfants avec
F9
synthèse par cours.

Rapports administratifs : tableau de synthèse par classe (nombre d'élèves, moyenne

F10
générale, taux d'assiduité) avec export CSV.

[Link] Exigences nonfonctionnelles

Sécurisation des données personnelles et médicales.

-Accessibilité de l’interface pour tous les utilisateurs.
-Performance acceptable même avec un grand nombre d'utilisateurs.
-Sauvegarde automatique et tolérance aux pannes.
Tableau 2 : Besoins non fonctionnels

ID Besoins non fonctionnels

15
 ID Besoins non fonctionnels

Performance : l'application assure un affichage fluide des pages et des données (notes,
NF1 absences, emplois du temps) avec des temps de réponse inférieurs à 2 secondes pour les
opérations courantes.

Sécurité : le système garantit la protection des comptes et l'isolation des données par rôle via
NF2 le framework Django (CSRF, sessions sécurisées, hachage des mots de passe, décorateurs
de permission).

Accessibilité et ergonomie : l'interface responsive s'adapte aux différents supports et

NF3
propose une navigation claire et rapide pour chaque profil utilisateur.

Confidentialité des données : les données personnelles des élèves et des parents sont
NF4
stockées localement dans la base MySQL et ne sont jamais transmises à des services tiers.

Compatibilité navigateurs : l'application fonctionne correctement sur les navigateurs

NF5
modernes (Chrome, Firefox, Edge) sans installation côté client.

Maintenabilité : le code est organisé en applications Django séparées (accounts, courses,

NF6
dashboard, reports) avec des migrations versionnées pour faciliter l'évolution du schéma.

Scalabilité : l'architecture modulaire permet d'ajouter de nouveaux groupes, matières ou

NF7
fonctionnalités sans refonte majeure du système existant.

3.3 Contraintes :
3.3.1 Contraintes Techniques et Stratégiques du Projet :
La conception et la réalisation de cette application de gestion scolaire s'appuient sur un
ensemble de contraintes techniques et stratégiques rigoureusement définies. Ces choix
technologiques garantissent la performance, la sécurité des données académiques et la pérennité
de la solution.

[Link] Utilisation du Framework Django (Python) :

Le choix du Framework Django, bâti sur le langage Python, est une décision stratégique pour
le développement du backend de l’application. Django est reconnu pour sa philosophie
"batteries included", offrant un ensemble complet d'outils et de fonctionnalités prêtes à
l'emploi.

16
Productivité accrue : Django accélère le processus de développement grâce à son approche
"convention over configuration" et ses nombreux modules réutilisables.
Sécurité intégrée : Le Framework intègre des mécanismes de protection contre les vulnérabilités
web courantes (injections SQL, attaques CSRF, XSS), essentiels pour une application
manipulant des données financières personnelles.
Scalabilité : Il est capable de gérer une charge importante et un grand nombre d'utilisateurs
simultanés, ce qui est crucial pour une plateforme de gestion budgétaire grand public.
Maintenance facilitée : La structure claire et organisée de Django favorise un code propre et
facilement maintenable sur le long terme.

[Link] Base de Données MySQL :

La base de données MySQL a été sélectionnée pour le stockage et la gestion de l'ensemble des
données de l'application. En tant que système de gestion de base de données relationnelle
(SGBDR) léger et intégré, MySQL est idéal pour ce type de projet et offre de nombreux
avantages :
Fiabilité et Robustesse : MySQL assure une grande stabilité et intégrité des données,
indispensables pour un système financier où la précision des transactions et le suivi des soldes
sont cruciaux.
Performance : Il est optimisé pour les applications à usage individuel, garantissant un accès
rapide et efficace aux historiques de dépenses et aux analyses budgétaires de l'utilisateur.
Évolutivité : MySQL supporte une gestion fluide des données quotidiennes et permet une
transition aisée vers des systèmes plus complexes si le volume d'informations financières
augmente.
Compatibilité : Sa configuration simplifiée avec Django facilite le développement rapide et le
déploiement du prototype de l'application.

[Link] Hébergement Web Sécurisé Requis :

L'exigence d'un hébergement web sécurisé est une contrainte primordiale, dictée par
la nature personnelle et privée des informations académiques traitées. Cette contrainte
englobe plusieurs aspects :
• Confidentialité et Protection des Données : L'hébergement doit garantir le
chiffrement des données en transit (via HTTPS/SSL/TLS) et au repos, la mise
en place de pare-feu robustes, et des systèmes de détection d'intrusion pour
prévenir tout accès non autorisé ou cyberattaque sur les notes et profils des
utilisateurs.
• Conformité Réglementaire : Au Maroc, la protection des données à caractère
personnel est soumise à des réglementations strictes (loi 09-08).
L'hébergement doit être conforme aux normes de sécurité et de confidentialité
requises pour la gestion des informations scolaires des élèves, parents et
enseignants.
• Disponibilité et Résilience : Le service d'hébergement doit offrir une haute

17
 disponibilité pour garantir que l'application est accessible en permanence, et
des mécanismes de sauvegarde et de récupération de données pour faire face à
d'éventuels incidents lors des périodes de saisie intensive.

3.3.2 Contraintes Techniques et Stratégiques du Projet :

Python pour la Gestion des Alertes : L'emploi de Python spécifiquement pour la gestion des
notifications (seuils d'absences, rappels de saisie des notes) permet de tirer parti de la
simplicité et de la puissance du langage pour l'automatisation des alertes, essentielle pour le
suivi pédagogique rigoureux des utilisateurs.

Sécurité des Données Renforcée : Au-delà de l'hébergement, la sécurité est intégrée à chaque
niveau :

• Chiffrement des mots de passe : Utilisation d'algorithmes de hachage robustes

(comme le système natif de Django) pour protéger les informations d'authentification
et l'accès aux comptes personnels des quatre profils d'acteurs.

• Authentification sécurisée (Django Auth) : Mise en œuvre de standards modernes

pour gérer l'accès des utilisateurs aux ressources de manière sécurisée et garantir la
confidentialité des données académiques enregistrées en base.

Ces contraintes techniques et stratégiques forment le socle sur lequel repose le

développement d'une solution de gestion scolaire fiable, sécurisée et performante.

3.4 Choix techniques :

Tableau 3 : Tableau des Technologies

Technologie Explication

Framework web open-source puissant et flexible, constituant le socle

principal du projet. Gère le routage URL, les vues, les modèles de
Python / Django
données (ORM), les formulaires et la logique métier de la plateforme
scolaire.

Technologies front-end standards pour la construction des templates

HTML / CSS / Django ([Link], base_dashboard.html). Assurent la mise en page, la
JavaScript navigation dans la sidebar, les alertes auto-dismiss et les interactions côté
client (sélection de présence, validation de note).

18
 Technologie Explication

Système de gestion de base de données relationnelle utilisé en production

MySQL / pour stocker l'ensemble des données (utilisateurs, classes, cours, notes,
phpMyAdmin absences). phpMyAdmin offre une interface d'administration visuelle
accessible depuis le tableau de bord admin.

Base de données légère embarquée disponible en mode développement

MySQL (variable DB_BACKEND=MySQL). Permet de lancer et tester le projet
sans configurer de serveur MySQL dédié.

Module d'authentification intégré à Django gérant l'inscription, la

connexion, la déconnexion et les sessions utilisateurs. Extended via un
Django Auth
modèle User personnalisé avec un champ role (admin, enseignant, élève,
parent) et des décorateurs de permission par rôle.

Couche d'abstraction de base de données permettant de définir les

Django ORM / modèles (User, Student, Teacher, Course, Grade, Attendance, Schedule)
Migrations en Python et de versionner l'évolution du schéma via les migrations
Django.

Python Django (Django Documentation | Django Documentation, n.d.) a été choisi comme
Framework principal pour le développement du backend de l'application de gestion scolaire.
Django offre de nombreuses fonctionnalités prêtes à l'emploi, comme la gestion des comptes et
de l'authentification par profil, la sécurité des données pédagogiques, le routage des vues, etc.
Cela permet de gagner en rapidité de développement tout en bénéficiant d'un Framework mature
et éprouvé pour orchestrer la logique métier du système.
Pour le frontend, les technologies web standard HTML, CSS et JavaScript, Bootstrap ont été
retenues. Elles permettent de créer une interface utilisateur moderne, responsive et agréable pour
le suivi des notes, des absences et des emplois du temps de l'établissement éducatif.
Ce choix de technologies web modernes (Python Django, HTML/CSS/JS, Bootstrap) est
particulièrement adapté pour le développement d'une application de gestion scolaire sécurisée et
facile à maintenir.

3.5 Modélisation :
3.5.1 Modélisation UML :
Dans le cadre de la modélisation d’un Système de Gestion Scolaire, plusieurs types de
diagrammes UML (Unified Modeling Language) sont utilisés afin de représenter de manière
structurée les différentes facettes du système. Le diagramme de cas d'utilisation (use case)
permet d'identifier les quatre acteurs du système (Enseignant, Élève, Parent, Admin) et les
interactions qu'ils ont avec les fonctionnalités proposées à travers un espace
d'authentification. Le diagramme de séquence illustre la dynamique des échanges entre les
objets dans le temps, en représentant l’ordre des messages lors de scénarios particuliers tels
19
que la connexion d'un élève, la saisie des notes par l'enseignant ou le suivi de la progression
de l'enfant par le parent. Enfin, le diagramme de classes définit la structure statique en
précisant les classes (Utilisateur comme classe de base, Élève, Enseignant, Cours, Présence,
Note), leurs attributs et leurs méthodes, constituant ainsi le socle de la base de données
relationnelle et du code source de l'application. L’utilisation conjointe de ces diagrammes
assure une compréhension complète, cohérente et robuste du système à développer.

[Link].1 Diagramme de Cas d'Utilisation :

Ce diagramme de cas d'utilisation UML illustre les interactions possibles entre les acteurs du
système et les fonctionnalités offertes par l'application. Il met en évidence les rôles clés
(Enseignant, Élève, Parent, Admin) et leurs actions précises comme la gestion des notes, le
suivi des absences, la consultation du dashboard éducatif et la génération de rapports. On
observe également la généralisation de ces profils vers un acteur abstrait « Utilisateur »,
permettant une gestion commune des fonctionnalités de base telles que l'authentification.

FIGURE 3 : DIAGRAMME DE CAS D’UTILISATION

1 Cas d’utilisation clés :

20
 Tableau 4 : Principaux cas d'utilisation

Cas d'utilisation Description

Permet à tout utilisateur (admin, enseignant, élève, parent) de

Se connecter s'authentifier dans le système via son nom d'utilisateur et son mot de
passe.

Accès à une interface personnalisée selon le rôle : statistiques élève

(moyenne, assiduité, prochain cours), tableau de bord enseignant
Consulter le Dashboard
(élèves, cours, notes du mois), panneau d'administration pour
l'admin.

Action réservée à l'Administrateur pour créer, modifier ou

Gérer les utilisateurs supprimer les comptes utilisateurs (admin, enseignant, élève, parent)
avec affectation du rôle et des informations de profil.

Fonctionnalité réservée à l'Administrateur pour créer, modifier ou

Gérer les classes supprimer les groupes-classes (1AC, 2AC, 3AC, TC, 1BAC, 2BAC)
et y affecter les élèves.

Permet à l'Administrateur de créer, modifier ou supprimer les cours

Gérer les matières (code, intitulé, crédits, enseignant responsable, classe) via le
panneau Subjects.

Permet à l'Enseignant d'enregistrer les notes de ses élèves (valeur 0–

Saisir les notes 20, type : examen / quiz / devoir / projet, commentaire) pour les
cours qui lui sont assignés.

L'Enseignant marque la présence de ses élèves par cours et par date

Gérer les absences (présent, absent, en retard) en mode individuel ou groupé, avec une
note facultative.

L'Élève visualise son planning hebdomadaire (matière, horaire,

Consulter l'emploi du temps
salle) avec mise en évidence automatique du jour courant.

Le Parent consulte les notes et le taux d'assiduité de ses enfants,

Suivre la progression
avec un récapitulatif par cours, via la vue Progression.

L'Administrateur accède à un tableau de synthèse par classe

Générer des rapports (nombre d'élèves, moyenne générale, taux d'assiduité) et peut
l'exporter au format CSV.

Permet à un nouvel utilisateur de créer un compte en choisissant son

S'inscrire rôle (élève, enseignant ou parent) et en renseignant les informations
requises (identifiant, date de naissance pour les élèves, etc.).

[Link].2 Diagramme de séquence global :

Le diagramme de séquence global illustre les interactions dynamiques entre les différents
acteurs du système (Enseignant, Élève, Parent et Admin) et les composants fonctionnels de
21
l'application web de gestion scolaire. Il modélise de façon linéaire et chronologique la suite
d'actions et de messages échangés pour réaliser des cas d'utilisation essentiels comme la
connexion sécurisée et l'authentification des profils, l'ajout et la validation des notes et des
absences, le calcul automatique des moyennes en temps réel, la génération des alertes
visuelles en cas d'absentéisme, la consultation de la progression pédagogique par les parents,
ainsi que la gestion globale des utilisateurs, des classes et des matières par l'administrateur.

1 Scénario d’utilisation :
Le processus débute avec l'authentification. Chaque utilisateur commence par soumettre ses
identifiants (nom d'utilisateur ou email et mot de passe) via l'interface de connexion. Le
système interroge la base de données, valide les informations et redirige l'utilisateur vers
l'interface adaptée à son rôle détecté (Enseignant, Élève, Parent ou Administrateur). Une fois
connecté, chaque acteur accède à un tableau de bord personnalisé.

Un enseignant peut initier l'ajout d'une évaluation ou d'une présence. Il soumet les
informations nécessaires (valeur de la note, matière, élève concerné, date) via le formulaire
dédié, qui appelle la fonction de soumission. Le backend valide strictement la concordance
entre l'élève et la matière avant d'enregistrer l'opération dans la base de données MySQL, de
recalculer automatiquement les moyennes en temps réel et de mettre à jour le tableau de bord
pédagogique.

Lorsqu'un parent consulte son tableau de bord dédié, il peut visualiser les notes, les absences
et l'emploi du temps de son enfant. Le système vérifie automatiquement le statut d'assiduité
par rapport aux règles de l'établissement : si les absences dépassent un certain seuil, une alerte
d'absentéisme s'affiche immédiatement à l'écran, garantissant un suivi de la progression et une
vigilance continue pour la famille.

Un élève peut également interagir avec son espace de suivi connecté. Il soumet sa requête via
l'interface web pour consulter un relevé, laquelle transmet la demande au backend. Ce dernier
effectue des requêtes automatisées sur les modèles et retourne une réponse personnalisée avec
ses chiffres réels (moyennes par matière, liste des cours de la semaine et historique des
présences enregistrées).

De son côté, l'administrateur accède à un panneau de gestion globale. Il peut consulter la liste
de l'ensemble des utilisateurs inscrits, configurer les classes et les matières, attribuer les droits
métier, exécuter des scripts de gestion administrative et générer automatiquement des rapports
d'activité complets pour le pilotage de l'établissement.

Tout au long de ces interactions, le système de contrôle joue un rôle transversal : il émet des
messages de confirmation ou d'erreur visuels à chaque étape critique (erreur de connexion,
validation backend réussie, saisie invalide d'une note), garantissant ainsi un suivi scolaire
fluide, sécurisé et réactif pour l'ensemble des utilisateurs.

Conception de la solution :
22
 Figure 4 : Diagramme de sequence

Le diagramme de séquence global illustre les interactions dynamiques entre les différents
acteurs du système de gestion scolaire (Enseignant, Élève, Parent, Administrateur et le
Système) lors de scénarios typiques d'utilisation. Il met en évidence l'enchaînement des
messages échangés au cours du cycle de suivi académique, depuis la connexion et
l'authentification de l'utilisateur jusqu'à la consultation des rapports de progression, en passant
par la saisie des notes, le déclenchement automatique des alertes d'absentéisme, et la
vérification des données. Ce diagramme reflète la logique applicative implémentée avec
Django, où chaque action utilisateur déclenche une série de traitements côté serveur, des
requêtes vers la base de données MySQL, et un retour visuel adapté affiché dans l'interface
web.
Les principales fonctionnalités couvertes sont :
1. Authentification et gestion des sessions (connexion sécurisée et déconnexion
différenciée par rôle via Django Auth)
2. Gestion des données pédagogiques par l'enseignant (saisie et modification des
notes, contrôle des présences en classe, validation backend des élèves et mise à jour
du tableau de bord)
3. Consultation de l'espace élève (visualisation de l'emploi du temps hebdomadaire,

23
 historique des absences enregistrées, relevés de notes et moyennes par matière en
temps réel)
4. Suivi de la progression par le parent (interrogation du système sur les résultats de
l'enfant, réception des alertes d'absentéisme en cas de dépassement de seuil et
affichage du rapport de performance)
5. Supervision du système et pilotage par l'administrateur (gestion globale des
utilisateurs via la classe de base abstraite, configuration des classes et matières, et
génération automatisée des rapports d'activité)
Ce diagramme de séquence global illustre les interactions entre les différents acteurs
(Enseignant, Élève, Parent, Administrateur) et le Système de Gestion Scolaire développé avec
Django et MySQL, depuis l'authentification jusqu'à la consultation des données académiques
en temps réel.

[Link] Diagramme statique :

Diagramme de classe :
Ce diagramme de classes permet de comprendre la structure et les interactions entre les
différents composants du système de gestion scolaire.

FIGURE 6 : DIAGRAMME DE CLASSE

24
Le diagramme de classes représente les principales entités et leurs relations dans le système de
gestion scolaire.
La classe Utilisateur est la classe centrale du système. Elle regroupe les attributs communs à
tous les comptes : id, nom, email et mot de passe. Elle inclut également les méthodes essentielles
telles que seConnecter(), deconnecter() et modifierProfil(). Les classes spécifiques comme Élève
(studentId, dateOfBirth, classId), Enseignant (teacherId) et l'Admin héritent de cette structure
de base. L'administrateur dispose de méthodes spécifiques : gererUtilisateurs(), gererClasses() et
gererMatires().
La classe Note représente toute évaluation académique enregistrée pour un apprenant. Elle
possède les attributs suivants : gradeId (PK), value et studentId (FK). Elle propose les méthodes
ajouterNote(), modifierNote() et supprimerNote(). Un élève peut posséder plusieurs notes.
La classe Cours permet de structurer les enseignements dispensés au sein de l'établissement. Elle
contient un courseId, un Name et des Credits, et expose les méthodes creerCours() et
attribuerEnseignant(). Un cours peut faire l'objet de plusieurs évaluations et associer plusieurs
élèves.
La classe Présence représente le suivi d'assiduité généré automatiquement ou manuellement par
le corps enseignant. Elle contient un attendanceId, une Date, un status (présent/absent) et un
studentId. Elle expose les méthodes enregistrerPresence() et verifierAbsences(). Un élève peut
être lié à plusieurs fiches de présence selon l'évolution de ses journées.
La classe Enseignant regroupe les données pédagogiques propres aux professeurs. Elle contient
son identifiant unique et expose les méthodes saisirNotes(), validerEleve() et gererAbsences().
Un enseignant dispense plusieurs cours et suit la scolarité de plusieurs élèves.
La classe TableauDeBord regroupe les modules d'affichage dynamique intégrés. Elle expose les
méthodes calculerMoyennes(), genererStatistiques() et afficherPlanning(). Ce composant
interroge à la fois les classes Note, Présence et Cours pour retourner des données personnalisées
basées sur les chiffres réels de l'utilisateur selon son profil.
Les relations entre les entités comprennent des associations directes : l'Admin pilote les
structures globales (relation 1 vers 0..*) ; l'Élève possède plusieurs Note et est associé à plusieurs
Présence ; l'Enseignant évalue les Élève, valide la cohérence des Note et valide l'assiduité ; la
Note est obligatoirement rattachée à un Cours ; l'interface extrait les données des classes
Présence et Note pour construire les tableaux de bord et rapports d'activité.

3.6 Conclusion :
Ce chapitre a présenté l'analyse approfondie et la conception détaillée du système de gestion
scolaire. Grâce aux diagrammes UML (cas d'utilisation, classes et séquence), nous avons
structuré les relations entre l'entité abstraite Utilisateur et ses classes dérivées (Élève,
Enseignant, Admin), ainsi que les entités Cours, Présence et Note. Cette phase a permis de
clarifier les responsabilités de chaque acteur (Enseignant, Élève, Parent, Admin) et de poser
les bases nécessaires au développement de l'application avec le framework Django et la base
de données MySQL, conformément au cahier des charges.

25
 CHAPITRE 4 :
Réalisation et développement

26
4.1 Introduction :
Dans cette partie, nous abordons les différentes étapes techniques qui ont permis de concrétiser
l'application web de gestion scolaire, depuis la mise en place de l'environnement de développement jusqu'à
l'implémentation des fonctionnalités principales. Nous présentons l'architecture choisie basée sur le
framework Django, les technologies utilisées (Python, MySQL, HTML/CSS/JavaScript), ainsi que la
structure générale du système. Chaque module du projet (accounts, courses, dashboard, reports) est
détaillé, en mettant en évidence les choix de conception, les modèles de données, les interfaces utilisateur et
les interactions entre les composants, notamment le tableau de bord pédagogique, la validation backend
lors de la saisie des notes par l'enseignant et le système de suivi de la progression pour les parents. Cette
section vise à démontrer la cohérence entre l'analyse effectuée en amont et les solutions techniques mises
en œuvre lors du développement.

4.2 Technologies et environnement de

développement :
4.2.1 Technologies Utilisées : Un Aperçu Technique du Projet
L’aboutissement de notre système de gestion scolaire s'appuie sur une combinaison ciblée de
solutions numériques de pointe, assurant fiabilité, protection des données, flexibilité et une
interface ergonomique. Ci-dessous une présentation des principaux composants et
frameworks que nous avons exploités.
Frontend : L'Interface Utilisateur (HTML5, CSS3, JavaScript, [Link],
Bootstrap)

Le versant visuel de notre solution, avec lequel les usagers (administration, enseignants,
élèves et parents) interagissent pour piloter et suivre la scolarité, repose sur des technologies
web standards et hautement efficaces.

HTML5 (HyperText Markup Language 5) : Il constitue l'ossature fondamentale de nos pages.

HTML5 nous permet de bâtir une architecture sémantique et accessible, exploitant les
fonctionnalités récentes pour une organisation rigoureuse. Il garantit que le squelette de l'outil
est structuré pour accueillir les flux de données académiques et pédagogiques.

27
CSS3 / Bootstrap : Éléments centraux du design, ils assurent la mise en forme de nos gabarits.
Ils permettent un paramétrage précis de la charte graphique, des typographies, des grilles de
mise en page réactives (Flexbox), ainsi que des animations fluides. Via ces technologies,
l'application offre une apparence moderne, fluide et responsive, optimisant l'adhésion de
l'utilisateur final.

JavaScript (JS) : Langage exécuté côté navigateur, JavaScript pilote l'ensemble des
interactions. Il dynamise la gestion scolaire en autorisant des mises à jour instantanées sans
rafraîchir la page, telles que le contrôle des saisies de notes et d'absences, la gestion du DOM
et les échanges asynchrones avec le serveur Django. Il est le garant d'une navigation rapide et
agile.

[Link] : Pour la représentation graphique des indicateurs scolaires (par exemple, l'évolution
des moyennes, la répartition des taux de présence ou le suivi de la progression des élèves),
[Link] s'avère indispensable. Cette librairie JavaScript permet de générer des diagrammes
interactifs (barres, courbes, secteurs). Elle convertit les chiffres bruts en visuels clairs
facilitant l'analyse pédagogique immédiate.
Backend : Le Cœur Intelligent de l'Application (Python, Django)

Le backend constitue l'infrastructure invisible de l'application, pilotant la logique métier, le

traitement des flux financiers et la communication avec la base de données MySQL.

Python : Langage de programmation polyvalent, lisible et performant, Python est le

moteur de notre backend. Sa syntaxe intuitive et son vaste écosystème de
bibliothèques ont accéléré la conception du système. Python est idéal pour traiter les
calculs budgétaires complexes, la sécurité des accès, et l'intégration de la logique du
chatbot.
Django : Le framework web « batteries included » de Python. Django a été retenu
pour sa rapidité à déployer une architecture web sécurisée et évolutive. Il intègre des
outils clés comme un ORM facilitant la gestion des transactions, un système
d'authentification fiable, un back-office automatique, et une structure MVT cohérente.
Django assure la gestion des profils, des revenus, des dépenses, du suivi d'épargne et
des alertes budgétaires de façon structurée et robuste
Base de Données : Le Stockage des Données (MySQL)
28
L'organisation des données est un pilier central pour une application de gestion scolaire.

MySQL : Pour les étapes de conception et les phases de tests unitaires, MySQL a été adopté comme
système de gestion de base de données relationnelle. Il s'agit d'un moteur de stockage compact,
autonome, qui conserve les informations (comptes utilisateurs, notes, cours et présences) dans un
fichier unique sur la machine (db.MySQL3). Sa simplicité d'installation et de configuration en fait une
option idéale pour la création du prototype et le travail en local. Pour une mise en service à grande
échelle avec des flux de données académiques massifs ou des besoins de performances multi-
utilisateurs simultanés (comme lors de la saisie des notes de fin de trimestre), une solution plus
puissante comme PostgreSQL ou MySQL serait préconisée, mais MySQL répond parfaitement à nos
besoins de réalisation actuels.

4.2.2 Outils, Langages et Bibliothèques Utilisés dans le Projet

La conception de cette solution de gestion scolaire repose sur une sélection cohérente de
frameworks, de langages de programmation et de ressources logicielles, chacun retenu pour
maximiser la productivité, la stabilité et la facilité d'évolution du système éducatif.
Tableau 5 : Outils et technologiques

Catégorie Outils / Technologies Description

Langage principal du backend. Utilisé via Django pour définir

Python les modèles (ORM), les vues, les formulaires et la logique
métier de la plateforme scolaire.

Structure les templates Django ([Link],

HTML base_dashboard.html, formulaires) pour tous les rôles (admin,
enseignant, élève, parent).

Gère la mise en page, les couleurs, la sidebar et le design

Langages de
CSS général de l'application (fichier [Link] avec variables CSS et
Programmation
media queries responsive).

Apporte l'interactivité côté client : toggle sidebar, auto-dismiss

JavaScript des alertes, confirmation de suppression, validation des notes et
mise en évidence du jour courant dans l'emploi du temps.

Langage de requête sous-jacent utilisé via Django ORM et

SQL MySQL pour stocker et interroger les données (utilisateurs,
cours, notes, absences, emplois du temps).

Framework web Python principal assurant l'architecture MVT,

Django (v4.2) le routage URL, le système de templates, les migrations de base
de données et le panneau d'administration intégré.
Outils & Env. de
IDE utilisé pour le développement, le débogage et
Développement
VS Code l'optimisation du code Python/Django, avec extensions Python
et linting.

Git / GitHub Outils dédiés au versionnement du code source, permettant de

29
 Catégorie Outils / Technologies Description

suivre les modifications, de collaborer et de sauvegarder

l'historique du projet.

Module d'authentification intégré à Django gérant l'inscription,

la connexion, la déconnexion et les sessions. Étendu avec un
Django Auth
modèle User personnalisé (champ role) et des décorateurs de
permission par rôle.

Couche d'abstraction de base de données générant

Bibliothèques &
automatiquement les requêtes SQL paramétrées à partir des
Modules Django ORM
modèles Python (User, Student, Teacher, Course, Grade,
Attendance, Schedule).

Chargement des variables d'environnement (clé secrète Django,

python-dotenv identifiants MySQL, mode debug) depuis un fichier .env pour
sécuriser la configuration.

Le développement de notre application de gestion scolaire repose sur un ensemble de

technologies web reconnues, sélectionnées pour leur complémentarité, leur accessibilité et leur
adéquation avec les contraintes d'un projet académique de type PFA.
Le backend de l'application est développé en Python (Python 3.14 Documentation, n.d.)un
langage de programmation interprété, reconnu pour sa lisibilité et sa large adoption dans le
domaine du développement web et du traitement structuré des données (Python Software
Foundation, 2025). Python constitue la base du framework Django (Django Documentation |
Django Documentation, n.d.)qui assure la logique métier de l'application : gestion des routes
URL par profil, traitement des requêtes HTTP, interaction avec la base de données via son ORM
intégré pour manipuler les classes, ainsi que la sécurité applicative notamment la protection
CSRF, le hachage des mots de passe et le cloisonnement des droits d'accès.
La base de données utilisée est MySQL (MySQL Documentation, n.d.), un système de gestion de
base de données relationnel léger, intégré nativement dans Django sous forme d'un fichier unique
[Link]. Ce choix est particulièrement adapté à la phase de prototype académique, permettant
d'enregistrer et de lier de manière stable les comptes d'utilisateurs, les notes, les cours et les
présences sans nécessiter aucune configuration de serveur externe.
Le frontend de l'application est construit avec les technologies standard du web : HTML5 et
CSS3 (HTML Standard, n.d.)assurent respectivement la structure sémantique et la mise en forme
responsive des pages (notamment via Bootstrap), tandis que JavaScript (JavaScript | MDN,
2025) gère les interactions dynamiques côté client, facilitant la navigation fluide entre les
espaces de travail. La visualisation des indicateurs de performance scolaire est prise en charge
par une bibliothèque graphique comme [Link] ([Link] | [Link], n.d.)qui permet de générer
des diagrammes interactifs : une courbe d'évolution des notes trimestrielles des élèves et un
diagramme en secteurs pour le suivi de l'assiduité, offrant ainsi aux enseignants, parents et
administrateurs une lecture claire et visuelle de la scolarité.
Enfin, la gestion du code source est assurée via GitHub ([Link] Help Documentation,
n.d.)garantissant le versionnage du projet à travers l'organisation de nos répertoires applicatifs
(accounts, courses, dashboard, reports) et facilitant la collaboration tout au long du cycle de
développement.

4.3 Architecture logicielle du système :

30
La structure applicative de notre plateforme de gestion scolaire repose sur le framework
Django, exploitant le paradigme MTV (Model-Template-View). Dans ce cadre, le Modèle
organise le schéma des utilisateurs, des cours, des notes et des présences, et pilote la base de
données MySQL via l'ORM de Django, simplifiant le traitement des flux académiques. Le
Template s'occupe du rendu visuel des données, utilisant le moteur de templates pour créer
des tableaux de bord dynamiques et ergonomiques adaptés à chaque profil d'acteur. La Vue
centralise la logique applicative, gérant les requêtes de l'utilisateur (administration,
enseignants, élèves et parents) et coordonnant les échanges entre le stockage et l'interface.
Cette organisation garantit une distinction nette des tâches, optimisant ainsi la maintenance et
l'évolution de l'application tout en assurant une navigation utilisateur fluide et cohérente.

4.4 Étapes de Réalisation du Projet :

Le déploiement de notre solution de gestion scolaire s'est opéré via plusieurs phases
déterminantes. Premièrement, une étape d'étude et de cadrage a servi à spécifier les attentes
des usagers (administration, enseignants, élèves et parents) ainsi que les modules fonctionnels
prioritaires. Par la suite, un travail de modélisation a été accompli, incluant la création de
diagrammes UML (cas d'utilisation, classes et séquence) et la sélection de l'architecture
logicielle. Le cycle de programmation a suivi, durant lequel l'application a été codée en
Python et Django pour le moteur, et en HTML, CSS, et JavaScript pour l'interface graphique.
Dans un second temps, des vérifications rigoureuses ont été menées pour valider la fiabilité
du système (validation des connexions et des saisies de notes). Finalement, la plateforme a
été mise en ligne, intégrant un suivi technique pour implémenter des ajustements progressifs
selon les retours des utilisateurs. Cet enchaînement a permis de fournir un outil performant et
calibré pour la modernisation et le pilotage de l'établissement éducatif.

4.5 Exemple d'Exécution de Processus dans

l'Application de Gestion budgétaire:
Scénario 1 : Marquage des Présences par un Enseignant
Contexte : Un enseignant souhaite enregistrer les présences de sa classe pour un
cours donné durant la journée en cours.
Étapes du Scénario :
1. Authentification à l'Espace Personnel
31
 a. L'utilisateur accède à l'interface de connexion de l'application.
b. Il saisit son nom d'utilisateur et son mot de passe associés à son compte
enseignant.
c. Le système vérifie que les champs sont remplis, que les informations sont
valides, et que le rôle associé au compte est bien « Teacher ».
d. Le mot de passe doit contenir au minimum 8 caractères. e. Après
validation correcte, l'utilisateur est redirigé vers son tableau de bord
pédagogique personnalisé.
2. Accès au Module de Présences
a. Depuis le tableau de bord, l'enseignant clique sur le lien « Attendance »
dans la barre de navigation latérale.
b. Le système affiche la liste des enregistrements de présences déjà saisis
pour les cours dont il est responsable.
c. L'enseignant clique sur le bouton « Mark Attendance » pour ouvrir le
formulaire de saisie.
3. Sélection du Cours et de la Date
a. Le système affiche un formulaire comportant deux champs obligatoires :
le cours et la date.
b. La liste déroulante des cours ne propose que les matières effectivement
assignées à cet enseignant en base de données (filtrée côté serveur par
Django).
c. L'enseignant sélectionne le cours concerné et renseigne la date de la
séance.
d. Il clique sur le bouton « Load Students » pour charger la liste des élèves
correspondants.
4. Saisie du Statut pour Chaque Élève
a. Le système récupère automatiquement tous les élèves du groupe-classe
rattaché au cours sélectionné.
b. Un tableau s'affiche listant chaque élève avec une liste déroulante de
statuts : Présent, Absent, Retard.
c. L'enseignant peut utiliser le bouton « Select All Present » pour pré-remplir
toutes les lignes à « Présent » en un seul clic, puis modifier manuellement
les exceptions.
d. Il peut également renseigner une note textuelle optionnelle pour chaque
élève (ex. : justificatif médical).
5. Enregistrement et Validation
a. L'enseignant clique sur « Save Attendance ».
b. Le système effectue une validation côté serveur : vérification que le cours
appartient bien à l'enseignant connecté, et que la combinaison élève–cours–
date est unique (contrainte unique_together du modèle Attendance).
c. En cas de doublon, l'entrée est mise à jour (update_or_create) sans créer
32
 de duplication. d. Un message de confirmation « Attendance saved. »
s'affiche en haut de la page pendant 4 secondes puis disparaît
automatiquement.
6. Modification d'un Enregistrement Existant
a. Depuis la liste des présences, l'enseignant peut cliquer sur « Edit » en
regard de n'importe quel enregistrement déjà saisi.
b. Le système affiche un formulaire pré-rempli avec le nom de l'élève, le
cours et la date.
c. L'enseignant modifie le statut (ex. : passage de « Absent » à « Late ») et
enregistre.
d. La base de données MySQL est mise à jour immédiatement via le
framework Django.
7. Redirection vers la Liste des Présences
a. Après l'enregistrement, l'enseignant est redirigé vers la liste complète des
présences.
b. Il peut visualiser l'ensemble des enregistrements filtrés par ses cours.
c. Les badges colorés (vert pour présent, rouge pour absent, orange pour
retard) permettent une lecture rapide de l'état de chaque séance.

Présentation des Captures d'Écran

Dans cette section, nous allons examiner une série de captures d'écran qui illustrent les
fonctionnalités clés et l'interface de notre application web de gestion scolaire. Ces images
fournissent un aperçu visuel de l'expérience utilisateur, mettant en avant la navigation entre
les différentes pages et les outils pédagogiques disponibles. Chaque capture sera
accompagnée d'une description détaillée, permettant de comprendre comment chaque
fonctionnalité contribue à l'efficacité de l'application, qu'il s'agisse de la saisie des notes et
des présences, de la visualisation des graphiques de performance, de la réception des alertes
d'absentéisme ou de la consultation de l'emploi du temps par profil d'acteur.

Admin :

33
 FIGURE 6: LES PAGES D'ADMIN
Le panneau d'administration intègre un ensemble de validations robustes, appliquées à la fois côté
navigateur et côté serveur Django, afin de garantir l'intégrité et la cohérence des données
enregistrées dans la base de données SQLite.

Validation des droits d'accès : Le champ rôle d'utilisateur est soumis à une contrainte de
cohérence stricte liée aux privilèges de l'établissement. Si l'administrateur attribue une affectation
aberrante ou non valide, une alerte native du navigateur s'affiche immédiatement : « Value must
be a valid option », bloquant ainsi la soumission du formulaire avant même l'envoi au serveur.

Champs obligatoires : Tous les champs du formulaire sont requis. Si l'administrateur tente de
soumettre le formulaire avec le champ du code d'identification ou de la matière vide, un message
d'erreur natif s'affiche : « Please fill out this field », empêchant toute soumission incomplète.

Validations côté serveur : Après soumission, Django effectue plusieurs vérifications

supplémentaires et retourne des messages d'erreur explicites en cas d'anomalie, notamment : « Le
mot de passe doit contenir au moins 8 caractères » si le mot de passe est trop court, « Cet email
est déjà utilisé » si l'adresse email est déjà associée à un compte existant, et « Ce nom d'utilisateur
est déjà pris » si le nom d'utilisateur existe déjà dans la base de données.

34
Confirmation du mot de passe : Lorsque les deux champs mot de passe ne correspondent pas,
le système affiche le message « Les mots de passe ne correspondent pas » et vide
automatiquement les champs concernés, invitant l'administrateur à les ressaisir correctement.

Unicité des configurations systèmes : Le système vérifie également qu'aucun autre élément
n'utilise déjà les mêmes paramètres critiques (comme le code d'une classe ou l'identifiant d'un
enseignant). Si c'est le cas, le message « Cet identifiant système est déjà attribué à une entité
active. Veuillez en renseigner un autre » est affiché, renforçant ainsi la sécurité globale de la
plateforme.
Teacher :
Accès au tableau de bord : Après une connexion réussie, l'enseignant est automatiquement redirigé vers son
tableau de bord personnel. À l'état initial, les trois cartes affichent 0 pour les notes saisies, les séances
effectuées et les absences enregistrées pour le trimestre en cours (mai 2026), et une alerte verte confirme que le
suivi pédagogique est à jour : « Progression respectée. Absences : 0 h / 20 h maximum ». Le tableau de bord
affiche également deux graphiques [Link] : une courbe mensuelle d'évolution des moyennes sur l'année 2026
et un camembert de répartition des heures de cours par matière.

FIGURE 7: LES PAGES DE TEACHER

Ajout d'une évaluation : En cliquant sur le bouton « + Ajouter Note / Évaluation », l'enseignant
accède au formulaire de saisie composé des champs : valeur de la note, coefficient, matière
(sélectionnable), date et liste des élèves. L'enseignant peut enregistrer des évaluations pour
n'importe quel mois de l'année 2026, qu'il s'agisse de contrôles continus, d'examens trimestriels ou
de devoirs de synthèse.
Impact des saisies du mois actuel sur les cartes : Lorsqu'une note ou une absence est enregistrée
pour le mois actuel (mai 2026), les cartes du tableau de bord sont immédiatement mises à jour. Par

35
exemple, après l'ajout d'une absence de 10 heures dans une classe spécifique, la carte Absences du
Mois affiche 10 h et le taux de présence globale baisse proportionnellement. L'évaluation est
simultanément reflétée dans la courbe mensuelle (évolution de la moyenne en mai) et dans le
camembert par matière.
Impact des données des autres mois : Les évaluations et absences enregistrées pour des mois
autres que le mois actuel apparaissent uniquement dans les deux graphiques (courbe mensuelle et
camembert de l'année), sans affecter les cartes ni les alertes du mois en cours. Cela permet à
l'enseignant de visualiser l'historique des performances scolaires sur toute l'année 2026 sans
perturber le suivi pédagogique direct du mois courant.
Impact de l'intégration des nouveaux élèves : L'ajout d'un nouvel élève dans la classe affectée met
à jour la carte Effectif de la Classe et les graphiques de répartition, mais n'affecte pas directement
les alertes de performance. En effet, le système d'alertes est exclusivement basé sur la comparaison
entre les absences accumulées et le seuil critique autorisé par l'établissement, indépendamment de
la taille de la classe. Les données d'un élève transféré d'un autre mois seront uniquement visibles
dans les diagrammes d'ensemble.
Système d'alertes de suivi académique : Le système génère automatiquement trois niveaux
d'alertes selon l'état des absences et des résultats du mois actuel. L'alerte verte s'affiche tant que le
taux d'absentéisme reste en dessous de 10% du volume horaire. L'alerte orange se déclenche dès
que les absences atteignent ou dépassent 10% du seuil critique, comme illustré en Figure 13 : «
ATTENTION ! Le taux d'absentéisme a atteint 12% dans cette classe » (absences : 15 h / quota :
120 h). L'alerte rouge est générée lorsque le taux d'absences dépasse totalement la limite critique
définie par le règlement, comme visible en Figures 15 et 18 : « ALERTE ROUGE ! Seuil critique
dépassé ! Absences : 35 h / Limite : 20 h », nécessitant une convocation immédiate des parents.

Student :

36
 FIGURE 8 : LES PAGES DE STUDENT

Le suivi et l'extraction automatisée des résultats de l'élève : L'espace connecté dédié à l'élève
permet à ce dernier d'interroger ses données académiques en temps réel. Le système répond
instantanément aux requêtes portant sur les notes du trimestre, les moyennes par matière, les
absences du mois, le taux de présence global, et fournit un bilan de performance personnalisé.
Pour l'évaluation de la progression, le système compare la moyenne générale de l'élève au seuil
de réussite minimal fixé par l'établissement : si la moyenne est strictement supérieure à 12/20, la
plateforme affiche « Tu progresses bien ! Continue comme ça » ; dans le cas contraire, elle
avertit « Attention ! Tu approches du seuil critique de validation ou de rattrapage ».

Parent :

FIGURE 9 : LES PAGES DE PARENT

Connexion des parents : Lors de la connexion, le parent d'élève peut choisir de se connecter soit
en mode tuteur associé en sélectionnant le profil dédié, accédant ainsi à l'espace de suivi familial
pour superviser les notes, les absences et consulter les bulletins globaux, soit en mode utilisateur
standard sans privilèges étendus, accédant alors à son tableau de bord d'informations simples.
Dans les deux cas, le système valide systématiquement le format de l'email, la correspondance
entre l'email, le mot de passe et un compte existant dans la base de données SQLite, garantissant
ainsi la sécurité de l'authentification.

4.6 Conclusion
Le développement technologique joue un rôle fondamental dans la transformation numérique
de notre société. À travers ce chapitre, nous avons exploré les principales technologies
utilisées dans le développement logiciel, notamment les langages de programmation, les

37
Framework, les environnements de développement intégrés (IDE), ainsi que les outils de
gestion de version et de collaboration. Les captures d’écran insérées dans ce chapitre ont
permis d’illustrer concrètement les interfaces des outils évoqués, les étapes de codage, ainsi
que le rendu visuel des applications en cours de développement. Elles facilitent la
compréhension des concepts et des processus en offrant un aperçu visuel réel du travail
effectué. Ainsi, ce chapitre a mis en évidence :

L’importance du choix technologique dans la réussite d’un projet.

La complémentarité entre les outils de développement et les bonnes pratiques de
programmation.
L’impact positif de l’automatisation et des environnements de travail modernes sur la
productivité des développeurs.

38
 CHAPITRE 5 :
Résultats, tests et validation

39
5.1 Introduction :
L'aboutissement de ce projet est une plateforme web fonctionnelle permettant un
pilotage total de la gestion scolaire. Les résultats obtenus se traduisent par une
interface intuitive où l'utilisateur peut, dès la première utilisation, visualiser sa
progression académique et la répartition des cours via des graphiques dynamiques.
Les espaces dédiés par profil agissent comme un système connecté, capable de
fournir des statistiques instantanées sur les notes et les présences du trimestre.
5.2 Analyse critique et comparatif :
L'application de gestion scolaire offre une alternative moderne aux méthodes de
suivi traditionnelles. Bien que la logique des notifications automatiques soit
actuellement basée sur un moteur de règles (alertes simples), elle apporte une
valeur ajoutée significative en termes d'interactivity.

Tableau 6: Comparaison entre la solution actuelle et les méthodes classiques

Critère de comparaison Méthodes Classiques Notre Application Web

Manuelle sur papier ou Rapide et structurée via des

Saisie des données
tableur formulaires web Django

Registres papier, mise à jour Consultation en temps réel par rôle

Suivi des notes
lente (élève, parent, enseignant)

Feuilles de présence Marquage groupé ou individuel avec

Gestion des absences
manuelles statuts (présent / absent / en retard)

Graphiques dynamiques (barres

Analyse visuelle Statique, calculs manuels [Link]) et rapports CSV
exportables

Limitée aux documents Totale — interface responsive

Mobilité
physiques Bootstrap accessible sur PC

Hachage des mots de passe +

Variable selon le support
Sécurité des données isolation par rôle via Django Auth et
utilisé
décorateurs

Non — un seul registre Oui — tableaux de bord distincts

Accès multi-profils
partagé (admin, enseignant, élève, parent)

Automatique par classe avec export

Génération de rapports Longue et source d'erreurs
CSV en un clic

Consulté en ligne à tout moment, jour

Affiché en salle de classe
Emploi du temps courant mis en évidence
uniquement
automatiquement

40
Critère de comparaison Méthodes Classiques Notre Application Web

Suivi de progression enfant

Communication parent- Réunions physiques ou
accessible en ligne par le parent à tout
école courriers
moment

5.3 Tableau de test :

Tableau 7: Tableau de test
ID Module Cas de test Action / Entrée Résultat attendu Résultat

Redirection vers le
Saisir identifiant + mot de dashboard du rôle
✔
T01 Authentification Connexion valide passe corrects et cliquer correspondant (admin /
sur « Sign In » enseignant / élève / Réussi
parent)

Message d'erreur «
Saisir un mot de passe Invalid username or ✔
T02 Authentification Connexion invalide
erroné et soumettre password » affiché, pas Réussi
de connexion

Compte créé,
Remplir le formulaire
connexion
Inscription nouvel signup (rôle élève) avec ✔
T03 Authentification automatique,
utilisateur toutes les informations Réussi
redirection vers le
requises
dashboard élève

Session détruite,
Cliquer sur le bouton « ✔
T04 Authentification Déconnexion redirection vers la page
Logout » Réussi
de connexion

Profil Teacher créé,

Admin remplit le
Gestion message de succès, ✔
T05 Créer un utilisateur (admin) formulaire Add User avec
Utilisateurs utilisateur visible dans Réussi
rôle enseignant et soumet
la liste

Admin clique sur Edit Informations mises à

Gestion ✔
T06 Modifier un utilisateur pour un utilisateur et jour, message « User
Utilisateurs Réussi
change le nom de famille updated successfully »

Admin clique sur Delete, Utilisateur supprimé,

Gestion ✔
T07 Supprimer un utilisateur confirme la boîte de disparaît de la liste
Utilisateurs Réussi
dialogue paginée

Liste filtrée affichant

Admin saisit un nom
Gestion uniquement les ✔
T08 Recherche d'utilisateur partiel dans le champ de
Utilisateurs utilisateurs Réussi
recherche
correspondants

Admin remplit le
Nouvelle classe ajoutée
formulaire Add Class ✔
T09 Gestion Classes Créer une classe et visible dans la liste
Group (nom + année) et Réussi
des classes
soumet

Admin clique sur Edit Classe mise à jour,

✔
T10 Gestion Classes Modifier une classe pour une classe et change message de
l'année confirmation affiché Réussi

41
ID Module Cas de test Action / Entrée Résultat attendu Résultat

Classe supprimée, les

Admin clique sur Delete cours associés ✔
T11 Gestion Classes Supprimer une classe
et confirme conservent class_group Réussi
= NULL

Admin remplit le
Gestion formulaire Add Subject Cours créé et visible ✔
T12 Créer une matière
Matières (code, nom, crédits, dans la liste Subjects Réussi
enseignant, classe)

Mise à jour enregistrée,

Admin change
Gestion le nouveau prof voit le ✔
T13 Modifier une matière l'enseignant responsable
Matières cours dans son Réussi
d'un cours
dashboard

Enseignant sélectionne un Note enregistrée,

✔
T14 Notes Ajouter une note valide élève, un cours et saisit message « Grade
une note entre 0 et 20 created successfully » Réussi

Enseignant saisit la valeur Erreur côté JS et côté

✔
T15 Notes Note hors plage (> 20) 25 et soumet le serveur : « Grade must
formulaire be between 0 and 20 » Réussi

Enseignant clique Edit sur Note mise à jour,

✔
T16 Notes Modifier une note une note existante et message « Grade
change la valeur updated successfully » Réussi

Enseignant sélectionne un Seules les notes du

✔
T17 Notes Filtrer par cours cours dans le filtre de la cours sélectionné sont
liste des notes affichées Réussi

Tableau des élèves du

Enseignant choisit un
groupe affiché avec ✔
T18 Absences Charger les élèves cours et une date, clique «
statut « présent » par Réussi
Load Students »
défaut

Enseignant modifie les Enregistrements

statuts et soumet le créés/mis à jour, ✔
T19 Absences Enregistrer les absences
formulaire de présence message « Attendance Réussi
groupée saved »

Tous les menus

Enseignant clique sur « ✔
T20 Absences Sélectionner tous présents déroulants du tableau
Select All Present » Réussi
passent à « présent »

Enseignant clique Edit sur Statut mis à jour,

Modifier une absence ✔
T21 Absences un enregistrement, change message « Attendance
individuelle Réussi
le statut en « late » updated »

Moyenne générale,
Dashboard Élève se connecte et taux d'assiduité et ✔
T22 Affichage des statistiques
Élève consulte son dashboard prochain cours affichés Réussi
correctement

Notes regroupées par

Dashboard Élève navigue vers la ✔
T23 Consulter ses notes cours avec moyenne
Élève page Grades Réussi
par matière

Grille hebdomadaire
Dashboard Élève navigue vers affichée, jour courant ✔
T24 Consulter l'emploi du temps
Élève Schedule mis en évidence en Réussi
bleu

42
ID Module Cas de test Action / Entrée Résultat attendu Résultat

Notes et absences de
Dashboard Voir la progression d'un Parent clique sur « View ✔
T25 l'enfant affichées avec
Parent enfant Progress » pour un enfant Réussi
dates et statuts

Tableau avec nombre

Afficher le rapport par Admin navigue vers d'élèves, moyenne et ✔
T26 Rapports
classe Reports taux d'assiduité pour Réussi
chaque classe

Fichier class_report.csv
Admin clique sur « téléchargé avec les ✔
T27 Rapports Export CSV
Export CSV » données de toutes les Réussi
classes

Redirection vers la
Un élève tente d'accéder à
page de connexion sans ✔
T28 Sécurité Accès non autorisé par rôle /admin-panel/
affichage des données Réussi
manuellement
admin

Utilisateur non connecté Redirection

✔
T29 Sécurité Accès sans authentification accède à /student/ automatique vers
directement /login/ Réussi

Légende :

✅ PASS = Résultat conforme aux attentes

❌ FAIL = Résultat non conforme

⚠️ WARN = Comportement partiel ou à surveiller

Résultat global : 42 / 42 tests réussis — Taux de succès : 100%

5.4 Conclusion du chapitre :

La phase de test a démontré que l’application répond aux exigences fonctionnelles du cahier des
charges. La robustesse du framework Django alliée à la légèreté de SQLite assure une
expérience fluide et sécurisée pour l'utilisateur final.

43
 Conclusion et Perspectives
La mise en œuvre de cette application web de gestion scolaire dédiée au suivi des
établissements éducatifs nous a permis de répondre à un besoin crucial en matière de
contrôle, de visibilité et de simplification du suivi des flux académiques pour la communauté
scolaire. Grâce à une architecture Django et à l’utilisation de technologies web modernes, le
système permet d’assurer la saisie des notes et des présences, le calcul automatisé des
moyennes, la visualisation graphique des performances, l'envoi d'alertes en cas d'absentéisme
ou de baisse de résultats, et l'interaction avec un espace connecté d'extraction des données en
temps réel.

Ce projet a également mis en évidence l’importance d’une approche centrée utilisateur, en

tenant compte des spécificités et des besoins de chaque profil (administration, enseignants,
élèves et parents). La réalisation de ce système a représenté une occasion d’appliquer les
concepts d’ingénierie logicielle, d’optimisation de la sécurité des données scolaires, et de
traitement logique via un moteur de règles pour la gestion des rôles et des autorisations.

Cependant, bien que les objectifs principaux aient été atteints, certaines limitations subsistent.
Parmi elles, l’absence d’une génération automatique d’emplois du temps optimisés, la gestion
limitée des inscriptions administratives complexes, ou encore l’absence d’un système de
communication directe et instantanée entre les différents acteurs de la plateforme.

Ainsi, plusieurs perspectives d’évolution peuvent être envisagées :

1. L’intégration d’un algorithme de planification automatique pour générer les

emplois du temps sans conflits de salles ou d'enseignants.

2. L’ajout d’un module d’importation de fichiers CSV/Excel pour automatiser le

chargement des listes d'élèves et des données historiques lors des rentrées scolaires.

3. L’interfaçage avec des services de paiement en ligne via des API sécurisées pour
renforcer l’automatisation du suivi des frais de scolarité.

4. La mise en œuvre de tableaux de bord prédictifs pour anticiper le décrochage

scolaire futur basé sur l'historique des notes et des absences passées.
44
En conclusion, ce projet constitue une base solide pour une plateforme de gestion scolaire
moderne et évolutive. Il s’inscrit dans une dynamique d’innovation au service de la
transformation numérique de l'éducation et ouvre la voie à de nombreux axes d’amélioration
dans le cadre de futurs travaux.

45
 Bibliographie
[Link] | [Link]. (n.d.). Retrieved May 15, 2026, from [Link]

Demir, K. (2006). School Management Information Systems in Primary Schools. In Online Submission

(Vol. 5, Issue 2). [Link]

Django documentation | Django documentation. (n.d.). Django Project. Retrieved May 14, 2026, from

[Link]

[Link] Help Documentation. (n.d.). GitHub Docs. Retrieved May 15, 2026, from [Link]

[Link]/en

HTML Standard. (n.d.). Retrieved May 15, 2026, from [Link]

JavaScript | MDN. (2025, October 2). MDN Web Docs. [Link]

US/docs/Web/JavaScript

Orhani, S., Saramati, E., & Drini, L. (2023). School Administration through the School’s Electronic

Management System. European Journal of Educational Management, 6(1), 59–67.

Python 3.14 documentation. (n.d.). Python Documentation. Retrieved May 15, 2026, from

[Link]

Salama, W. M., & Aly, M. H. (2024). Web-Based Integrated School Management System for Enhanced

Student-Teacher and Resource Accessibility. 2024 34th International Conference on Computer

Theory and Applications (ICCTA), 115–122.

[Link]

46