N° 2020 -

République Tunisienne
Ministère de l’enseignement supérieur et de la recherche scientifique

Rapport de Stage de Fin d’Etudes

POUR L’OBTENTION DE LA

LICENCE FONDAMENTALE EN SCIENCES DE L’INFORMATIQUE

Intitulé
Conception et réalisation d'une application
web de gestion des absences à l’UT

Elaboré par

KAYUMBA JUNIOR

Encadré par

EMNA KHANFIR

Année Universitaire : 2019-2020

 Remerciement

2019-2020 Page | i
 Dédicace

Je dédie ce mémoire

A mes Parents, Ceux qui n’ont réservé aucun effort pour mon éducation ainsi
que pour ma formation, qui m’ont inculqué le sens des responsabilités, l’amour
ainsi que toute autre valeur.

Je dédie ce mémoire

À toute la famille KAYUMBA ainsi qu’à ma chère et tendre fille Eliana,

qui sont des personnes indispensables dans mon parcours car leurs soutiens et
leur présence m’ont permis de continuer à aller de l’avant.
A tous mes amis, pour leurs soutiens, leurs aides, pour leurs franchises et
leur capacité à me redonner de la force quand tout allait mal et parce que vous
avez cru en moi. .

A l’Enseignantes de l’UT EMNA KHANFIR, qui m’a soutenue, qui m’a

encouragé et aidé tout au long du projet.

JUNIOR

2019-2020 Page | ii
 Tables des matières

Table des matières

TABLE DES MATIÈRES I

LISTE DES FIGURES III

LISTE DES TABLEAUX IV

INTRODUCTION GÉNÉRALE 1

CHAPITRE 1 : PRÉSENTATION DU CADRE DU PROJET 3

1.1. INTRODUCTION........................................................................................................................................4
1.2. ORGANISATION D’ACCUEIL...................................................................................................................4
1.3. PRÉSENTATION DU PROJET...................................................................................................................4
1.4. MÉTHODOLOGIE DE TRAVAIL................................................................................................................4
1.5. PLANIFICATION DU DÉROULEMENT DU PROJET....................................................................................6
1.6. CONCLUSION.........................................................................................................................................7

CHAPITRE 2 : ANALYSE ET SPECIFICATION DES BESOINS 13

3.1. INTRODUCTION....................................................................................................................................13
3.2. OBJECTIFS DU PROJET........................................................................................................................14
3.3. CAPTURE DES BESOINS FONCTIONNELS..............................................................................................14
3.3.1. Acteurs de système.......................................................................................................................14
3.3.2. Description de diagramme de collaboration...............................................................................15
3.3.3. Diagramme de cas d’utilisation du système................................................................................16
3.3.4. Description de cas d’utilisation...................................................................................................16
3.4. CONCLUSION.......................................................................................................................................22

CHAPITRE 3 : ETUDE CONCEPTUELLE 23

4.1. INTRODUCTION....................................................................................................................................24
4.2. LES ERP : ENTREPRISE RESSOURCE PLANNING................................................................................24
4.3. OPENERP...........................................................................................................................................24
4.3.1. Environnement de développement..............................................................................................25
4.3.2. Envirenement d’execution...........................................................................................................26
4.3.3. Environement d’exploitation.......................................................................................................26
4.4. CONCEPTION DE LA SOLUTION............................................................................................................27
4.4.1. Diagramme de séquence..............................................................................................................28
4.4.2. Diagramme de classe...................................................................................................................32
4.4.3. Diagramme d’états de transition.................................................................................................35
4.4.4. Diagramme d’activité...................................................................................................................36
4.5. MODÉLISATION LOGIQUE DES DONNÉES.............................................................................................38
4.5.1. Modèle relationnel.......................................................................................................................38
4.5.2. Notation UML..............................................................................................................................38
4.5.3. Du conceptuel à la logique : Règles de passages........................................................................38
4.5.4. Modèle logique de données..........................................................................................................39

2019-2020 Page | iii

 Tables des matières

4.6. CONCLUSION..........................................................................................................................................40

5.4. CONCLUSION.......................................................................................................................................50

CONCLUSION GÉNÉRALE 51

Bibliographie et Webographie 53

2019-2020 Page | iv
 Liste des figures

Liste des figures

Figure 1. 1 : Schéma explicatif de la méthode SCRUM [2]...................................................................................5

Figure 1. 2 : Diagramme de Gantt [4].....................................................................................................................7

Figure 3. 2 : Diagramme de cas d'utilisation........................................................................................................11

Figure 4. 1 : Architecture MVC [11].....................................................................................................................19

Figure 4. 8 : Diagramme de classes......................................................................................................................21

Figure 5. 2 : Page d’authentification....................................................................................................................46

Figure 5. 3 : Page « Gérer Dossier ».....................................................................................................................47
Figure 5. 4 : Page « Gérer Déclaration »..............................................................................................................48
Figure 5. 5 : Page « Facturation »........................................................................................................................49
Figure 5. 6 : La page Calendrier...........................................................................................................................49
Figure 5. 7 : Page Histogramme « Pourcentage de facturation par Client »......................................................50

2019-2020 Page | v
 Liste des tableaux

Liste des tableaux

Tableau 1. 1 : Plan de travail...................................................................................................................................6

Tableau 3. 1: Description des flux d'information.................................................................................................16

Tableau 3. 2 : Description du cas d’utilisation « Authetification ».....................................................................17
Tableau 3. 3 : Description du cas d’utilisation «Suivre la réception des documents ».......................................18
Tableau 3. 4 : Description du cas d’utilisation «Gérer les articles »...................................................................19
Tableau 3. 5 : Description du cas d’utilisation «Gérer Dossier »........................................................................19
Tableau 3. 6 : Description du cas d’utilisation «Gérer Déclaration ».................................................................20
Tableau 3. 7 : Description du cas d’utilisation «Suivi de dossier aux bureaux de douane»..............................21
Tableau 3. 8 : Description du cas d’utilisation «Gérer facturation»...................................................................22

Tableau 6. 1 : Objectives du projet........................................................................................................................52

2019-2020 Page | vi
 Introduction Générale

Introduction générale

La technologie informatique a favorisé la réorganisation des méthodes administratives,

le développement des compétences nouvelles et l'établissement d'unités d'organisation
nouvelles pour fournir des services automatisés et une bonne gestion de données.
Dans ce cadre s'inscrit notre projet professionnel personnel qui consiste à automatiser
les tâches de suivi des absences des étudiants au sein de l’Université de Technologie de
Sousse (UT).
L’objectif principal du projet consiste à concevoir et à développer une application web
pour la gestion et le suivi des absences des étudiants. A ce jour, cette tache se réalise d’une
manière manuelle ce qui va rendre le travail difficile lorsque le nombre des étudiants devient
très important.
Notre application a été créé dans le but de gérer le travail complet du service scolarité
de l’UT à savoir : l’enregistrement des absences des étudiants, l’impression des fiches
d’absences pour chaque filière, le suivi des absences pour chaque étudiant.
Le présent rapport comporte quatre chapitres. Le premier chapitre présente dans un
premier temps la société d’accueil, puis définit le projet et les travaux requis. En outre, ce
chapitre est consacré à l'étude de l’existant du service scolarité, ainsi qu'à la couverture des
éléments clés des problèmes et difficultés rencontrés, et enfin des solutions.
Le deuxième chapitre présente en détail les exigences fonctionnelles et non
fonctionnelles pour le développement du système.
Le troisième chapitre présente la conception des données et le traitement.
Le quatrième chapitre présente l'environnement de développement, l'architecture de
déploiement et les interfaces créées.
Enfin, on clôture ce rapport avec un récapitulatif et une ouverture aux perspectives de
développement et de perfectionnement de l’application élaborée dans la conclusion.

2019-2020 Page | 1
 Chapitre 1 :
Présentation du cadre du projet

1.1. INTRODUCTION........................................................................................................................................4
1.2. ORGANISATION D’ACCUEIL...................................................................................................................4
1.3. PRÉSENTATION DU PROJET...................................................................................................................4
1.4. MÉTHODOLOGIE DE TRAVAIL................................................................................................................4
1.5. PLANIFICATION DU DÉROULEMENT DU PROJET....................................................................................6
1.6. CONCLUSION.........................................................................................................................................7
 Chapitre 2 : Etude Préalable

1.1.Introduction

Dans ce chapitre, nous présentons le cadre général de notre projet. Nous commençons
par la présentation de l'organisme d'accueil l’Université de Technologie de Sousse. Ensuite,
nous présentons le contexte du projet ainsi que la méthodologie de travail adopté. A la fin de
ce chapitre, nous exposons le plan de déroulement de notre projet.

1.2.Organisation d’accueil

Notre projet de fin d'études a été réalisé à l’Université de Technologie de Sousse (UT).
L’UT, lieu de formation et de recherche, constitue un levier important de croissance
économique, sociale et culturelle du domaine de la technologie et de la communication. C’est
une école en alternance qui oriente et conseille ses étudiants en leur fournissant des
opportunités d’insertion professionnelle nationales et internationales.
Adresse : Avenue Abou Hamed El Ghazali 4000, Sousse

1.3.Contexte du projet

Dans cette section, nous allons analyser, évaluer et critiquer le fonctionnement

habituel du service scolarité, tout en élaborant la liste des solutions possibles.

1.3.1. Etude de l'existant

Chaque jour, Le service scolarité reçoit chaque jour un grand nombre de fiches
d’absence notées par les professeurs, le service accomplisse ses tâches en utilisant des
logiciels de bureautique (Excel). Parmi ses rôles, nous citons :
 Gestion des absences : c’est la tâche principale du service, l’agent doit ajouter,
modifier, consulter et supprimer les absences des étudiants.
 Gestion des étudiants par filière : c’est aussi une tâche importante du service scolarité,
elle permet l’ajout des listes d’étudiant, l’impression des fiches d’absences par filière.

1.3.2. Problématique

A l'heure actuelle, l’UT ne dispose d’aucun logiciel informatique permettant la gestion

des absences. Le service accompli ses tâches de gestion d’une manière presque manuelle en

2019-2020 Page | 3
 Chapitre 2 : Etude Préalable

utilisant des logiciels de bureautique (Excel, Word, etc.). Ceci rend leurs tâches difficiles,
compliqué, lent et mal structuré.
Pour suivre des absences, l’agent du service scolarité ajoute et la supprime des
absences à l’aide d’un fichier Excel appart pour chaque filière.
Cela a engendré de graves conséquences, entre autres, la difficulté d’accès à
l’information puisque chaque liste d’étudiant est stockée par filière dans un fichier Excel
indépendant, ce qui consiste le parcours de plusieurs fichiers pour consulter les absences des
étudiants. C'est dans ce cadre qu'UT a constaté qu'il est urgent de développer une application
de gestion des absences pour répondre à son propre besoin de la gestion de suivi des absences
de près et d’ajouter et de supprimer automatiquement les absences des étudiants dans les
différents modules.

1.3.3. Solution proposée

Afin de remédier aux problèmes présentés dans la section précédente, l’agent du

service scolarité de l’UT a opté pour réaliser une application web automatisant la gestion et le
suivi des absences des étudiants.
Cette application permet de :
 Faciliter l’ajout et la consultation des absences des étudiants.
 Diminuer les risques d’erreur.
 Faciliter la génération des fiches d’absence pour chaque filière.
 Garantir la sécurité des informations.
 Rendre le travail plus structuré et dynamique.

1.4.Méthodologie de travail

Les méthodes de développement agile [1], aussi appelé développement adaptatif, sont
des méthodes basées sur l'effectif humain et ayant pour objectif la satisfaction du client qui
contribue à la réalisation de l’application entièrement fonctionnelle tout au long de sa
fabrication.
Ces méthodes concrétisent la capacité d’une organisation à créer de la valeur ajoutée et
à ravir son client, tout en s’adaptant à temps aux changements de son environnement.
Dans notre projet, nous avons choisi de travailler avec la méthode SCRUM [2]. Cette
dernière est une méthode agile qui met l'accent sur l'esprit d'équipe et sur le fait que tous les

2019-2020 Page | 4
 Chapitre 2 : Etude Préalable

acteurs doivent avancer dans la même direction. Contrairement à d'autres méthodes agiles
comme XP, Scrum ne préconise pas de pratique d'ingénierie [1].  
Le principe de la méthodologie SCRUM est de développer un logiciel de manière
incrémentale en maintenant une liste totalement transparente des demandes d'évolutions ou de
corrections à implémenter (backlog). Avec des livraisons très fréquentes, toutes les 4
semaines en général, le client reçoit à chaque fois un logiciel possédant toujours plus de
fonctionnalités et en parfait état de fonctionnement. Pour cela, la méthode s'appuie sur des
développements itératifs à un rythme constant d'une durée de 2 à 4 semaines [3].

FIGURE 1. 1 : SCHÉMA EXPLICATIF DE LA MÉTHODE SCRUM [2]

Comme la montre la figure 1.1, SCRUM est basé sur des itérations à périodes courtes
de développement dont les objectifs sont définis à l’avance appelées sprints. D’autre part, la
méthodologie SCRUM est basé sur un référentiel d’exigences appelé le backlog du produit qui
est fourni et tenu à jour par le responsable produit. Ce référentiel est composé de
fonctionnalités constamment priorisées. Avant chaque sprint, les fonctionnalités les plus
prioritaires passent dans le backlog  de sprint et deviennent donc les objectifs à réaliser durant
le sprint.
Un sprint démarre toujours par sa planification en partant de discussions entre le
responsable produit et l’équipe concernant le backlog du produit. A l’issue de cette rencontre,
des tâches sont définies et le sprint peut débuter.

2019-2020 Page | 5
 Chapitre 2 : Etude Préalable

L’équipe de développement est piloté par le Scrum Master qui a pour but de résoudre
les obstacles, participer au développement en cas de besoin et tout mettre en œuvre pour que
les objectifs soient réalisés durant le sprint. Chaque sprint améliore la valeur ajoutée du
produit en ajoutant de nouvelles fonctionnalités qui peuvent être livrées au client.
En suivant cette méthodologie, nous avons fixé un plan d’action dont les grandes
lignes sont les suivantes :
Action 1 - Etude de contexte (Phase de préparation et de cadrage) : consiste à étudier
l'environnement des multiplateformes, définir la problématique et à fixer le cadre du projet.
Action 2 - Conception : cette action consiste à définition des besoins de l'application,
définition des différents modules et leurs besoins, Spécifications fonctionnelles et
spécifications techniques
Action 3 - Réalisation (Phase de construction et de finalisation) : consiste à la
finalisation des modules et l’intégration et tests.

1.5.Planification du déroulement du projet

Pour respecter les délais et avoir un contrôle continu sur l'avancement du projet, nous
avons planifié un planning prévisionnel que nous avons ajusté par la suite et au fur et à
mesure de l’avancement du projet.
Dans notre plan de travail, nous avons commencé par étudier l'existant et par
l’élaboration des besoins fonctionnels. En se basant sur ces spécifications, nous avons
développé un prototype de l’application final (Storyboard). Cette étape a durée 4 semaines
avec l’intégration de la maquette fournie par notre designer et valider par le client final.
Par la suite, nous arrivons au développement des différents services et de la partie
Web (BackOffice). Enfin, nous réserverons 3 ou 4 semaines pour l'optimisation de
l'expérience utilisateur, tests et corrections.

La figure 1.2 illustre notre plan de travail.

ID Tache Date de début Date de fin Durée

1 Spécification des besoins 02/02/2020 05/03/2020 32
Développement et intégration des GUI (Graphic
2 06/03/2020 10/04/2020 36
User Interface)
3 Conception de la base de données 11/04/2020 14/05/2020 34
4 Conception et développement du BackOffice 15/05/2020 30/06/2020 47
5 Optimisation, Test et Correction des bugs 01/06/2020 25/06/2020 55
TABLEAU 1. 1 : PLAN DE TRAVAIL

2019-2020 Page | 6
 Chapitre 2 : Etude Préalable

1.6.Conclusion

Ce chapitre a permis d’avoir une idée sur le garde général de notre projet gestion et
suivi des absences qui permet de suivre les absences d’un étudiant dans une matière. Nous
avons essayé d'analyser et d’étudier l'existant, pour pouvoir s’y inspirer et pour connaitre les
fonctionnalités les plus appropriées pour notre future application. Par la suite, nous avons
évoqué la problématique et une solution mentionnant ce que nous devrions faire pour
accomplir notre application.
Nous avons choisi une méthodologie à savoir SCRUM [3] pour sa brièveté d’itération
ce qui permettra de détecter rapidement les anomalies et du correspondre l’application au
besoin de l’utilisateur. Dans ce qui suit, nous abordons l'analyse et la spécification des
besoins.

2019-2020 Page | 7
 Chapitre 2 :
ANALYSE ET SPECIFICATION
DES BESOINS

3.1. INTRODUCTION......................................................................................................................................15
3.2. OBJECTIFS DU PROJET........................................................................................................................15
3.3. CAPTURE DES BESOINS FONCTIONNELS..............................................................................................16
3.3.1. Acteurs de système.......................................................................................................................16
3.3.2. Description de diagramme de collaboration...............................................................................16
3.3.3. Diagramme de cas d’utilisation du système................................................................................17
3.3.4. Description de cas d’utilisation...................................................................................................18
3.4. CONCLUSION.......................................................................................................................................24
 Chapitre 3 : Analyse et Spécification des besoins

3.1.Introduction

La phase de spécification des besoins est une phase importante dans le cycle de vie
d’un projet de développement logiciel. Elle permet de dégager les exigences du produit et
d’en définir les attentes et les spécifications fonctionnelles.
Dans ce chapitre, nous nous focalisons, d’abord, à présenter les acteurs de notre
projet. Ensuite, nous détaillons la capture des besoins non fonctionnels et fonctionnels et la
formalisation de ces besoins en diagramme de cas d’utilisation UML.

3.2.Identification des acteurs

Un acteur est un rôle joué par une entité extérieure qui interagit directement avec le
système. Lors de son interaction avec le système, l’acteur peut consulter ou modifier l’état du
système, en émettant ou en recevant des messages susceptibles d’être porteurs de données.
Notre application de gestion est de suivi des absences est caractérisée par trois acteurs
détaillés comme suit.
 L’administration : Chargé de mettre à jour et de consulter toutes informations
concernant l’université.
 Les enseignants : Personnel de l’université pouvant insérer certaines informations sur
les étudiants.
 L’étudiant : Utilisateurs consultants les informations lui concernant.

3.3.Spécification des besoins

3.3.1. Besoins fonctionnels

Les besoins fonctionnels ou besoins métiers Indique les opérations que le système doit
effectuer, Seules les opérations qui remplissent les conditions peuvent être exécutée. Selon
notre application, nous avons identifié les exigences fonctionnelles :
 Authentification : assure l’accès à l’interface de gestion d’absence.
 Gestion des utilisateurs : assure l’ajout, la modification, la suppression et la
consultation de la liste des utilisateurs.

2019-2020 Page | 9
 Chapitre 3 : Analyse et Spécification des besoins

 Gestion des étudiants : assure l’ajout, la modification, la consultation et la

suppression d’un étudiant.
 Gestion des absences : assure l’ajout, la consultation et la suppression des absences
ainsi que la modification d’une absence déjà ajoutée (l’ajout d’une justification). Elle
assure aussi l’impression des fiches d’absence par filière.
 Gestion des Matières : assure l’ajout, la modification, la consultation et la suppression
d’une matière.
 Gestion des filières : assure l’ajout, la modification, la consultation et la suppression
d’une filière.
 Gestion des Classes : assure l’ajout, la modification, la consultation et la suppression
d’une classe.

3.3.2. Besoins non fonctionnels

Les besoins non fonctionnels présentent des exigences internes au système et cachées
aux utilisateurs :
 Exigences d’ergonomie

– Une interface conviviale, lisible et facile à utiliser.

– Rapidité du temps de réponse car il joue un rôle fondamental.
Il doit être court.
– Utiliser des listes contenant des valeurs correctes afin d’éviter la saisie et par
conséquent les erreurs de saisie.

 La Sécurité

– Traçabilité et journalisation des transactions et des opérations effectuées

– Le système doit être sécurisé avec l’obligation pour chaque utilisateur de saisir un
mot de passe et un login.
– L’authentification : Elle est assurée par un module d’authentification et
d’autorisation, il gère l’accès entre les utilisateurs et l’application par un login et un mot de
passe.

 Architecture du système

2019-2020 Page | 10
 Chapitre 3 : Analyse et Spécification des besoins

L’architecture du système permet de fixer les parties intervenantes dans le système et

leurs interactions.

3.4.Analyse des besoins

Cette section est consacrée à la capture des besoins soulevés par ce projet. Nous
commençons par une capture détaillée de l’application et ce dans le but de résoudre les
lacunes de gestion de transit de la société détectées précédemment.

3.4.1. Diagramme de cas d’utilisation du système

Le diagramme des cas d’utilisation permet de structurer les besoins des utilisateurs et
les objectifs d’un système. En effet, il identifie les acteurs et leurs interactions avec le
système. Afin de mieux comprendre tous les volets du notre application, nous l’avons
décomposé en huit cas d’utilisations. Par la suite, nous allons détailler les principaux cas
d’utilisation.
La figure ci-dessous (Figure 3.1) représente le diagramme des cas d’utilisation :

2019-2020 Page | 11
 Chapitre 3 : Analyse et Spécification des besoins

FIGURE 3. 1 : DIAGRAMME DE CAS D'UTILISATION

3.4.2. Description de cas d’utilisation

Chaque cas d’utilisation est détaillé avec ses scénarios : un scénario nominal est le cas
le plus fréquent, les scénarios alternatifs et les scénarios d’exceptions.

3.4.2.1. Cas d’utilisation authentification

Le tableau ci-dessous (Tableau 3.2), représente la description de cas d’utilisation
d’authentification :

Titre : Authentification
Acteur : Tous les acteurs
Objectif : Accès au système selon les fonctionnalités attribuées
Ce scenario permet à tout acteur de d’identifier auprès du système et d’accéder
Description
aux modules qui lui sont attribuées
Pré-
Existence des informations utilisateur dans la base de données du système
condition
Post- ------

2019-2020 Page | 12
 Chapitre 3 : Analyse et Spécification des besoins

condition
Action de l’acteur Action de système
Scénario 1 Se connecter au système
alternatif Vérifier login et mot de passe, valider et
2
autoriser l’accès selon les droits d’accès.

1 Se connecter au système
Exception
Vérifier login et mot de passe. Retour à
2
1(Login ou mot de passe incorrecte)
TABLEAU 3. 1 : DESCRIPTION DU CAS D’UTILISATION « AUTHETIFICATION »

3.4.2.2. Cas d’utilisation Gérer Absence

Ce cas d’utilisation concerne la gestion des absences, opération effectuée par
l’administration qui peut ajouter, modifier et supprimer une absence.
Le tableau ci-dessous (Tableau 3.2), représente la description de ce cas d’utilisation :

Titre : Gérer Absence

Acteur : Admin
Objectif : Suivre et contrôler la liste de présence
Ce scénario permet de faire les opérations d’ajout, de modification et de
Description
suppression d’une absence.
Pré-condition Authentification au système avec le compte Admin.
Post-
------
condition
Action de l’acteur Action de système
1 Afficher la liste des absences enregistrés.
Demande l’ajout
2
d’une absence
Scénario 3 Afficher l’interface d’ajout d’une absence
alternatif Saisir les informations
4
de l’étudiant absent.
Enregistrer les informations de l’étudiant dans
5 la base de données du système et afficher la liste
des absences enregistrés

Saisir les informations

1
Exception de dossier à ajouter.
a. Données insuffisantes.
2
b. Données incorrectes
TABLEAU 3. 2 : DESCRIPTION DU CAS D’UTILISATION « SUIVRE LES DIFFÉRENTES
ABSENCES »

3.4.2.3. Cas d’utilisation Gérer les utilisateurs

Ce cas d’utilisation consiste à saisir les informations des différents utilisateurs. Le
tableau ci-dessous (Tableau 3.4), représente la description de ce cas d’utilisation :

2019-2020 Page | 13
 Chapitre 3 : Analyse et Spécification des besoins

Titre : Gérer des utilisateurs

Acteur : Admin
Objectif : Saisie des utilisateurs.
Ce scénario permet de faire la saisie des utilisateurs.
Description
Pré-condition Authentification au système avec le compte admin.
Post-condition ------
Action de l’acteur Action de système
1 Lister utilisateurs
2 Afficher liste des utilisateurs.
3 Choisir numéro utilisateur
4 Afficher utilisateurs choisi
Demande l’ajout d’un nouvel
Scénario 5
utilisateur
alternatif
Afficher l’interface d’ajout d’un
6
nouvel utilisateur
Saisir les informations de
7
l’utilisateur à ajouter.
Enregistrer les informations dans la
8
base de données du système
TABLEAU 3. 3 : DESCRIPTION DU CAS D’UTILISATION « GÉRER LES UTILISATEURS »

3.4.2.4. Cas d’utilisation Gérer Classes

Ce cas d’utilisation consiste à attribuer et faire le suivi des classes attribuer aux
différents étudiants. Le tableau ci-dessous (Tableau 3.4), représente la description de ce cas
d’utilisation :

Titre : Gérer Classes

Acteur : Admin
Objectif : Attribuer et faire le suivi des classes aux différents étudiants.
Ce scénario permet de faire la saisie des documents réceptionné de la part
Description
du client.
Pré-condition Authentification au système avec le compte admin.
Post-condition ------
Action de l’acteur Action de système
1 Lister classes à attribuer
2 Afficher la liste des classes disponibles.
3 Choisir numéro dossier
4 Afficher classe choisi
Demande l’ajout d’une
Scénario 5
nouvelle classe
alternatif
Afficher l’interface d’ajout d’une
6
nouvelle classe
Saisir les informations de
7
classe à attribuer.
Enregistrer les informations dans la base
8
de données du système

2019-2020 Page | 14
 Chapitre 3 : Analyse et Spécification des besoins

TABLEAU 3. 4 : DESCRIPTION DU CAS D’UTILISATION « GÉRER CLASSES »

3.4.2.5. Cas d’utilisation Gérer Etudiant

Le tableau ci-dessous (Tableau 3.6), représente la description de cas d’utilisation
« Gérer étudiant ». Ce cas d’utilisation permet de gérer et suivre la liste des étudiants.

Titre : Gérer Etudiant

Acteur : Admin
Objectif : Gérer la liste d’étudiant
Description ----
Pré-condition Authentification au système avec le compte Admin.
Post-condition ------
Action de l’acteur Action de système
1 Lister dossiers a déclaré
2 Afficher la liste des étudiants
3 Choisir le dossier a déclaré
Scénario
4 Afficher l’interface d’ajout étudiant
nominal
Saisir les informations de la
5
déclaration.
Enregistrer les informations dans la base
6
de données du système

Afficher les informations de l’étudiant

1
choisi
Scénario
Modifier les informations de
alternatif 2
la déclaration
Enregistrer les informations dans la base
3
de données du système

Saisir les informations de

1
Exception l’étudiant.
a. Données insuffisantes.
2
b. Données incorrectes
TABLEAU 3. 5 : DESCRIPTION DU CAS D’UTILISATION « GÉRER ETUDIANT »

3.4.2.6. Cas d’utilisation « Gérer filière »

Ce cas d’utilisation consiste à attribuer une filière à chaque étudiant.

Le tableau ci-dessous (Tableau 3.8), représente la description de ce cas d’utilisation :

Titre : Gérer filière

Acteur : Admin
Objectif : Ce scénario permet d’attribuer une filière à chaque étudiant.
Description -----
Pré-condition Authentification au système avec le compte admin.
Post-condition ------

2019-2020 Page | 15
 Chapitre 3 : Analyse et Spécification des besoins

Action de l’acteur Action de système

1 Lister étudiants à attribué
Afficher la liste des étudiants qui n’ont
2
pas de filière
3 Choisir un étudiant à attribué
Scénario Afficher l’interface d’ajout avec
nominal 4 quelques informations sur l’étudiant
choisi
Saisir les informations pour
5
choisir une filière
Enregistrer les informations dans la
6
base de données du système.

Rechercher les étudiants à

1
attribué
2 Choisir un étudiant a modifié
Scénario Afficher les informations de l’étudiants
3
alternatif à attribué
Modifier les informations
4
d’attribution
Enregistrer les informations dans la
5
base de données du système

Saisir les informations de

1
Exception facturation
a. Données insuffisantes.
2
b. Données incorrectes
Rechercher le numéro de
3
l’étudiant attribuer à modifier.
4 Erreur (Etudiant introuvable)
TABLEAU 3. 6 : DESCRIPTION DU CAS D’UTILISATION « GÉRER FILIÈRE »

3.5.Conclusion

Nous avons présenté, tout au long de ce chapitre, les objective de notre projet. Nous
avons essayé d'analyser et de spécifier les besoins de notre projet. Ceci était à travers le
diagramme de collaboration informatisé et le diagramme de cas d’utilisation.
Dans ce qui suit, nous élaborons la phase de conception qui est la phase qui suit la
capture des besoins.

2019-2020 Page | 16
 Chapitre 3 :
ETUDE CONCEPTUELLE

4.1. INTRODUCTION....................................................................................................................................24
4.2. LES ERP : ENTREPRISE RESSOURCE PLANNING................................................................................24
4.3. OPENERP...........................................................................................................................................24
4.3.1. Environnement de développement..............................................................................................25
4.3.2. Envirenement d’execution...........................................................................................................26
4.3.3. Environement d’exploitation.......................................................................................................26
4.4. CONCEPTION DE LA SOLUTION............................................................................................................27
4.4.1. Diagramme de séquence..............................................................................................................28
4.4.2. Diagramme de classe...................................................................................................................32
4.4.3. Diagramme d’états de transition.................................................................................................35
4.4.4. Diagramme d’activité...................................................................................................................36
4.5. MODÉLISATION LOGIQUE DES DONNÉES.............................................................................................38
4.5.1. Modèle relationnel.......................................................................................................................38
4.5.2. Notation UML..............................................................................................................................38
4.5.3. Du conceptuel à la logique : Règles de passages........................................................................38
4.5.4. Modèle logique de données..........................................................................................................39
4.6. Conclusion............................................................................................................................................40
 Chapitre 4 : Etude Conceptuelle

4.1.Introduction

Le présent chapitre est consacré à la conception de notre application. Nous présentons

d’abord, la technologie utilisée qui est les ERP. Puis, nous présentons l’architecture logicielle
du système et enfin le Framework et les techniques utilisés. Nous expliquerons par la suite
l'état statique de l’application à l’aide du diagramme de classe et l’état dynamique à travers les
diagrammes de séquence et de diagramme d’état de transition.
A la fin de ce chapitre, nous présentons le schéma de la base de données utilisée dans
l'application.

4.2.Architecture logicielle de notre solution

Un MVC [10] est une architecture utilisée en génie logiciel. Dans des applications
complexes qui présentent des lots de données aux utilisateurs, nous souhaitons souvent
séparer les données (modèle) et l'interface utilisateur (vue), de sorte que les changements à
l'interface utilisateur n'affectent pas le traitement des données, et que les données peuvent être
réorganisées sans changer l'interface utilisateur.
Le MVC résout ce genre de problème en découplant l'accès des données et la logique des
applications de la présentation des données et de l'interaction utilisateur, en introduisant un
composant intermédiaire : « le contrôleur ».
Dans l'architecture MVC, les rôles des trois entités sont les suivants :
 Model : concerne les objets déclarés pour définir des tables notre base de données ;
 View : définies les interfaces utilisateurs (entrées et sorties) ;
 Controller : le contrôleur est C# qui contrôle la gestion des événements et
synchronisation.

2019-2020 Page | 18
 Chapitre 4 : Etude Conceptuelle

FIGURE 4. 1 : ARCHITECTURE MVC [11]

4.3.Environnement de développement logiciel

L'environnement logiciel de notre solution comprend :

 Le système de gestion de base de données relationnelle SQL Server Management

2019,
 Visual Studio 2019 pour la réalisation de notre application,
 IIS un conteneur web libre de Microsoft,
 L'outil de modélisation Star UML.

4.4.Choix technologiques

Dans cette partie, nous nous intéressons aux langages, aux bibliothèques et aux
techniques de programmation utilisées tout au long de la réalisation de notre application.

4.4.1. Plateforme Visual Studio 2019

Visual studio est un ensemble complet d'outils de développement permettant de

générer des applications Web, des Services Web XML, et des applications mobiles. Visuel
Studio fait appel à plusieurs langages (C++, C#, VB). Par ailleurs, ces langages permettent de
mieux utiliser les fonctionnalités du Framework .NET, qui fournit un accès à des technologies
clés simplifiant le développement d'applications Web et de Services Web XML grâce à Visual
Web Développer. Dans ce projet, on a utilisé comme langage de programmation :

2019-2020 Page | 19
 Chapitre 4 : Etude Conceptuelle

4.4.2. Framework Angular 8

Angular est un cadriciel côté client, open source, basé sur TypeScript, et co-dirigé par l'équipe
du projet « Angular » à Google et par une communauté de particuliers et de sociétés. Angular
est une réécriture complète de AngularJS, cadriciel construit par la même équipe.

4.4.3. Langage de programmation C#.Net

Est un langage de programmation orientée objet, commercialisé par Microsoft depuis 2002 et
destiné à développer sur la plateforme Microsoft .NET.

4.4.4. Base de données SQL Server

Microsoft SQL Server est un système de gestion de base de données en langage SQL
incorporant entre autres un SGBDR développé et commercialisé par la société Microsoft. Il
fonctionne sous les OS Windows et Linux (depuis mars 2016),

4.5.Diagramme de classe

Le diagramme de classes [13] exprime, d’une manière générale, la structure statique

d’un système en termes de classes et de relations entre elles. Une classe permet de décrire un
ensemble d’objets (attributs et comportements), tandis qu’une relation ou association permet
de faire apparaître des liens entre ces objets.
Le schéma ci-dessous (Figure 4.8) représente le diagramme de classe de l’application
de gestion de transit.

2019-2020 Page | 20
 Chapitre 4 : Etude Conceptuelle

FIGURE 4. 2 : DIAGRAMME DE CLASSES

4.6.Déroulement des Sprints

4.6.1. Sprint1 « Gérer Etudiant »

4.6.1.1. Conception détailler du sprint1

Le sprint gérer étudiant permet à l’administration d’enregistrer un étudiant au

système en saisissant son nom, sa date de naissance, son matricule ainsi que sa spécialité.
Le Gestionnaire étudiant vérifie ces informations qui sont stockées dans la base de
données (entité étudiant). Si ces informations existent dans l’entité étudiant alors

2019-2020 Page | 21
 Chapitre 4 : Etude Conceptuelle

Gestionnaire étudiant affiche la page d’insertion suivant les privilèges et le rôle de

l’étudiant. La figure ci-dessous (Figure 4.1) représente l’interface de la gestion d’étudiant.

2019-2020 Page | 22
 Chapitre 4 : Etude Conceptuelle

Sprint2 « Gérer Absence »

Après avoir préparé la conception du sprint 2, nous nous sommes concentrées sur la phase de
codage pour élaborer les différentes interfaces de la partie gestion des absences. Nous
commençons par présenter les interfaces relatives à la gestion des absences. Les figures
suivantes illustrent cette tâche :

2019-2020 Page | 23
 Chapitre 4 : Etude Conceptuelle

Sprint3 « Gérer Enseignants »

Après avoir préparé la conception du sprint 3, nous nous concentrerons sur l'étape de codage
pour développer différentes interfaces pour la partie gestion des enseignants. Nous présentons
d'abord l'interface liée à la gestion des enseignants. La figure suivante illustre cette tâche :

2019-2020 Page | 24
 Chapitre 4 : Etude Conceptuelle

Sprint4 « Gérer Filière »

1.1. Après avoir préparé la conception du sprint 4, nous nous concentrerons sur l'étape de
codage pour développer différentes interfaces pour la partie gestion des filières. Nous
présentons d'abord l'interface liée à la gestion des filières. La figure suivante illustre
cette tâche :

1.2. Conclusion
2019-2020 Page | 25
 Chapitre 4 : Etude Conceptuelle

Ce chapitre avait pour objectif la présentation de la conception détaillée de la solution.

Dans ce chapitre nous avons présenté le diagramme de classes et quelques captures d’écran de
l’application ; Par la suite, nous avons présenté le modèle logique de notre base de données.

2019-2020 Page | 26
 Chapitre 5 : Réalisation et Intégration

Conclusion générale

Le présent projet de fin d'études a pour but la mise en place d'une application web de
gestion des notes. Ce projet nous a aidés à améliorer nos connaissances en informatique.

Dans ce projet, nous avons commencé par présenter quelques généralités et notre
problématique. Ainsi, se pose la difficulté de l’établissement, nous nous sommes donc
occupés d’observer son fonctionnement, d’en relever les défauts, et d’envisager des
solutions aux problèmes qu’il rencontre.

Ensuite, nous avons cité les besoins afin d’accomplir une telle application. Puis, nous avons
présenté les objectifs qui doivent être atteints et parmi lesquels nous avons cité le gain de
temps concernant les tâches quotidiennes de l’agent et du chef de département. Par la suite,
nous avons détaillé le contexte du travail et nous avons cité les différentes fonctionnalités
qui doivent être satisfaites par notre application.

Au cours de ce travail, nous avons pu étudier l’approche orientée objet présentée par le
langage de modélisation UML pour analyser et spécifier les besoins dans un premier temps
et pour concevoir notre application dans un deuxième temps, afin d’appliquer des règles de
transformation pour obtenir finalement notre base de données.

Ce projet a été pour nous l’occasion d’approfondir notre connaissance des langages de
programmation tels que HTML et de découvrir l’environnement Visual Studio Microsoft SQL
Server Management, . . .

Pour conclure, au cours de notre projet, nous avons entamé une démarche, à mi-chemin
entre la gestion du projet et l’auto-formation, qui a permis de mettre la main sur de
nombreuses ressources et composants. Ceci nous a permis de passer toutes les étapes de

2019-2020 Page | 27
 Chapitre 5 : Réalisation et Intégration

développement (gestion de projet, analyse, conception, réalisation, débogage, tests) avec

succès et ce, selon le calendrier au préalablement défini.

2019-2020 Page | 28
 Bibliographie

2019-2020 Page | 29