Memoire pre ingenieur Nganmeni Zephirinnganmeni.g.n.f.unblog.fr/files/2013/02/memoire_pre... · JPA...

Conception et Mise en œuvre d’un système de gestion intégrée de stages et de suivi de la formation : Cas de la FMSB

Stage pré-ingénieur effectué par NGANMENI Zéphirin – Année académique 2009/2010

A l’Eternel Dieu, seule source de vie,

de sagesse et d’intelligence.

DÉDICACEDÉDICACEDÉDICACEDÉDICACE



Ce travail n'aurait pas le reflet actuel sans la contribution et le soutien de certaines

personnes à qui nous voulons témoigner notre reconnaissance.

Je remercie tout d'abord le Pr TANGHA Claude qui en plus d'avoir accepté de diriger

nos premiers pas dans un stage, il demeure pour nous un père et un modèle à imiter.

Je remercie également

Le Pr. TETANYE EKOE, Doyen de la FMSB et le Pr. NKO’O vice-Doyen chargé

de la scolarité, d’abord pour avoir accepté de nous accueillir au sein de la célèbre faculté de

médecine et des sciences biomédicales dans le cadre de ce stage mais aussi pour leur regard

critique qui a été d’une importance incommensurable.

Mon Co-stagiaire Monsieur NGANGUE EBONGUE Joseph, pour sa collaboration.

Mes enseignants Dr Georges Edward KOUAMOU, Dr Thomas DJOTIO, Monsieur

Bernabé BATCHAKUI, Monsieur YEKEL, Dr MOUKOP et tous les autres pour

l’encadrement et la culture du sens du travail, d’endurance et de recherche qu’ils nous

inculquent chaque jour.

Mes camarades de classe qui m’ont toujours soutenu durant ce stage à travers l’espace

de partage qu’offre le groupe [email protected] .

Mes frères et sœurs et particulièrement Marie Thérèse, Simplice, Sidonie, Gabriel,

Diane et Guilaine.

Mes amis et particulièrement Philomène, Christian, Carine, Gille, Maurice,

Eliane, Mirianne, qui n’ont ménagé aucun effort pour me soutenir dans ces travaux.

REMERCIEMENTSREMERCIEMENTSREMERCIEMENTSREMERCIEMENTS



API Application Programming Interface DAO Data Access Object EJB Enterprise JavaBeans J2EE Java 2 Enterprise Edition J2SE Java 2 Standard Edition JCA Java Crytography architecture JDBC Java Data Base Connectivity JMS Java Messaging Service JNDI Java Naming and Directory Interface JPA Java Persistence API JSP Java Server Page JSF Java server Faces JDK Java Developpement Kit JRE Java Runtime Environment JTA Java Transaction API ORM Object Relational Mapping PDF Portable Document Format POJO Pain Old Java Object RMI Remo Method Invocation SGBD Système de Gestion de Bases de Données SGBDR Système de Gestion de Bases de Données Relationnelles UI Interface Utilisateur UML Unified Modeling Language XML eXtensible Markup Language JPNL Java Network Lauching Protocol EAR Enterprise ARchive

LISTE DES SIGLES ET ACRONYMESLISTE DES SIGLES ET ACRONYMESLISTE DES SIGLES ET ACRONYMESLISTE DES SIGLES ET ACRONYMES



Tableau 1 : Liste des activités déjà réalisées dans le cadre de ce projet ................................. 13

Tableau 2 : Contenu du fichier de configuration sun-resources.xml ...................................... 26

Tableau 3 : Contenu du fichier de configuration persistence.xml ........................................... 27

Tableau 4 : Exemple du code de l'entité [Connexion] représentant une ligne de la table

[connexion] de la base de données.......................................................................................... 28

Tableau 5 : Exemple de code de l'Ejb qui gère l'accès à l'entité [Connexion .......................... 29

LISTE DES TABLEAUXLISTE DES TABLEAUXLISTE DES TABLEAUXLISTE DES TABLEAUX



Figure 1 : Architecture de l'application .................................................................................... 18

Figure 2 : Présentation des trois couches de l'application ...................................................... 21

Figure 3 : Intégration des conteneurs Ejb3 dans l’architecture ............................................... 21

Figure 4 : Création d'une connexion NetBeans à la base de données ..................................... 25

Figure 5 : Fenêtre de connexion à l'application ....................................................................... 30

Figure 6 : Fenêtre d'accueil ...................................................................................................... 31

Figure 7: Fenêtre de validation des présences ........................................................................ 31

Figure 8 : Fenêtre de suivi des enseignants ............................................................................. 32

Figure 9: Fenêtre de suivi des étudiants .................................................................................. 33

Figure 10 : Générer l'état d'avancement des cours ................................................................. 34

Figure 11: Générer l'état de présence aux cours ..................................................................... 34

Figure 12 : Générer les états d'occupation de ressources ...................................................... 35

Figure 13 : Fenêtre d'évaluation d'un maitre de stages .......................................................... 36

Figure 14 : Générer l'état d'évaluation d'un maitre de stage .................................................. 37

Figure 15 : Fenêtre d'administration étendue ......................................................................... 38

Figure 16 : Fenêtre d'administration restreinte ....................................................................... 39

Figure 17 : Lancement de l'installation du serveur d'application Glassfish ............................. 45

Figure 18 : Indicatif d’une fin réussie de l'installation du serveur d'application Glassfish ...... 45

Figure 19 : Construction et la création d'un domaine pour le serveur Glassfish .................... 46

Figure 20 : Capture d'écran indiquant le démarrage du serveur glassfish .............................. 46

Figure 21 : Connexion à travers un navigateur à la fenêtre de configuration de glassfish ..... 47

Figure 22 : Présentation du menu de configuration de Glassfish ............................................ 48

Figure 23 : Présentation de l'arborescence de Glassfish ......................................................... 48

LISTE DES ILLUSTRATIONSLISTE DES ILLUSTRATIONSLISTE DES ILLUSTRATIONSLISTE DES ILLUSTRATIONS



I.I.I.I. INTRODUCTION GÉNÉRALEINTRODUCTION GÉNÉRALEINTRODUCTION GÉNÉRALEINTRODUCTION GÉNÉRALE

A aucun moment, la place de la documentation n’a cessé de croître au sein

des institutions académiques et de s’affirmer comme un élément essentiel à la

qualité de l’action éducative et pédagogique. Son image a changé ; elle est

désormais liée à la modernité, à l’innovation, et aux nouvelles technologies.

A la FMSB de Yaoundé, présentée ci-dessous, comme dans nombre de nos

institutions scolaires et académiques, la gestion des ressources (personnels

administratifs, techniques, enseignants, étudiants, enseignements, salles de cours

etc.),est encore manuelle. Ce mode de gestion archaïque est inefficace et présente

des inconvénients et risques élevés connus de tous.

C'est au regard de tout cela que, dans le cadre de notre stage pré ingénieure,

nous œuvrons pour une démarche visant la mise en place d'un système

d'information moderne afin de promouvoir les aspects suivants :

• L’amélioration des services

Gestion plus rapide et efficace de la planification des cours, de l’occupation des

salles de cours, des emplois de temps des enseignants, des étudiants ainsi que des

différents stages qu’ils effectuent durant leur cursus académique…

• Amélioration des recherches

Permettre une recherche facile, plus rapide, plus complète d’un document ou

d’une donnée statistique devant renseigner sur un aspect du fonctionnement du

système ou favoriser une prise de décision.

CHAPITRE I:PRÉLIMINAIRESCHAPITRE I:PRÉLIMINAIRESCHAPITRE I:PRÉLIMINAIRESCHAPITRE I:PRÉLIMINAIRES



• Une planification intelligente

Faciliter et améliorer les planifications de toute sorte permettant l’anticipation, la

détection et la correction des incohérences, les redondances et surtout les conflits

pouvant figurer sur les différents plannings.

• La disponibilité des inventaires

Faciliter des inventaires fiables et des états statistiques fidèles pour une meilleure

connaissance et un bon suivi de l'ensemble des ressources du système.

• Possibilité d’extension

Le système doit présenter des prédispositions à s’étendre à travers les aspects

connexes de l’institution universitaire.

En somme, ce système d'information doit inclure les analyses statistiques

autour des effectifs, des postes/emplois et des compétences. Ces analyses visent à

rendre possible l'interprétation qualitative des données et permettre de construire des

actions adaptées aux besoins opérationnels. Une gestion efficace des ressources

n'existant pas sans un management prévisionnel, notre système d'information

s'inscrit également dans une logique prospective et préventive intégrant la dimension

stratégique. Il suppose des outils de pilotage pour le moyen et le long terme servant

à mesurer l'efficacité de la politique mise en œuvre, d'anticiper et de réduire les

dysfonctionnements, de mobiliser le personnel.

Tout système doit prendre en compte les réalités sociales et culturelles de

l’entreprise, d’où la nécessité de maitriser non pas seulement le contexte mais aussi

l’évolution historique de l’entreprise.



II.II.II.II. PRÉSENTATION DE LA FACULTÉ DE MÉDECINE ET DES SCIENCES PRÉSENTATION DE LA FACULTÉ DE MÉDECINE ET DES SCIENCES PRÉSENTATION DE LA FACULTÉ DE MÉDECINE ET DES SCIENCES PRÉSENTATION DE LA FACULTÉ DE MÉDECINE ET DES SCIENCES

BIOMÉDICALESBIOMÉDICALESBIOMÉDICALESBIOMÉDICALES DE YAOUNDÉDE YAOUNDÉDE YAOUNDÉDE YAOUNDÉ (FMSB).(FMSB).(FMSB).(FMSB).

1. Historique

L’histoire de la formation des médecins au Cameroun commence le 28 octobre 1965

par le décret présidentiel N° 65/DF/480 qui crée un e commission chargée d’élaborer

le programme de construction, de fonctionnement et d’enseignement de la faculté

mixte de médecine et de pharmacie de Yaoundé. Cette commission, présidée par le

Dr Simon Pierre Tsoungui, premier ministre, comprend entre autres les ministres de

l’éducation nationale, des finances, du plan et du développement, le commissaire à

la santé publique, le président du conseil de l’ordre des médecins, des experts du

PNUD, de l’OMS et de pays amis ainsi que quelques professeurs déjà sur place.

La mise en place de cette commission fait suite à des missions effectuées par

quelques experts de la France et de l’OMS en 1962 et 1964, missions qui avaient

pour objet de poser les bases d’un programme d’un cycle de formation sur place de

médecins camerounais. Le travail de la commission s’appuie sur des observations de

la conférence des doyens des facultés de médecine d’Afrique noire, qui trouvaient

les programmes occidentaux non pertinents pour les médecins exerçant dans un

contexte tropical. Conscient des enjeux, le PNUD s’était pour la première fois associé

à l’OMS et à d’autres partenaires pour piloter et financer un projet de formation de

médecins, pionniers d’une médecine nouvelle.

Toutes ces étapes aboutissent le 14 juin 1969, à la signature du décret présidentiel

N° 69/DF/256 qui crée au sein de l’université fédér ale du Cameroun fonctionnelle

depuis 1962 une école de médecine d’un type nouveau, le Centre Universitaire des

Sciences de la Santé (CUSS).

Le 19 janvier 1993, le Chef de l’État signe une série de textes consacrant la réforme

universitaire au Cameroun. Celle-ci est marquée par la mise en place de six

universités d’état dont l’université de Yaoundé I qui abrite la faculté de médecine et

des sciences biomédicales.



2. Mission générale

La FMSB a pour missions :

• D’élaborer et de transmettre les connaissances

• De développer la recherche et la formation des hommes

• De porter au plus haut niveau et au meilleur rythme de progrès les formes

supérieures de la culture et de la recherche

• De procurer l’accès à la formation supérieure à tous ceux qui en ont la

vocation et la capacité

• De concourir à l’appui au développement et à la promotion sociale et culturelle

• De développer la pratique du bilinguisme

3. Principales implications de la réforme universit aire pour la FMSB

La réforme universitaire a eu des implications visibles dont les principales sont :

La vocation de l’école pour la multidisciplinarité, la progression des connaissances et

la recherche fondamentale sont accentuées.

L’organigramme administratif de l’ancien CUSS devient l’organigramme type de

toutes les autres facultés, composé d’un doyen, une assemblée de faculté, un

conseil de faculté et une administration centrale. La FMSB devient plus fermement

rattachée au rectorat de l’UYI et perd une partie de son autonomie.

Les enseignants bénéficient du statut spécial du corps de l’enseignement supérieur.

L’année universitaire est répartie en deux semestres.

Les enseignements et les évaluations sont regroupés en crédits, modules et unités

de valeur.

La bourse systématique aux étudiants est supprimée et remplacée par un système

d’aides sélectives.

Il est institué le paiement des frais universitaires.

La durée des études passe de six à sept ans.



4. Offre de formation à la FMSB

En 2007, suite à une prescription du Président de la République Paul Biya, la FMSB

a arrimé ses curricula au système LMD et a ouvert ses filières de pharmacie et de

médecine dentaire. De ce fait, la FMSB propose actuellement 4 filières d’études :

études médicales, études pharmaceutiques, études de médecine bucco-dentaires,

études médico-sanitaires et biomédicales. Les trois premières admettent un tronc

commun et des unités d’enseignement communes le long du parcours qui est de 13

semestres. Le diplôme terminal à l’issue du deuxième cycle est un doctorat

professionnel dans les études médicales, pharmaceutiques et dentaires. Par la suite,

un cycle de spécialisation propose un enseignement post doctoral dans 12 domaines

de spécialité incluant l’anatomie pathologique, l’anesthésie-réanimation, la biologie

clinique, la chirurgie générale, la gynécologie-obstétrique, la médecine interne, la

pédiatrie, la radiologie, l’ophtalmologie, l’oto-rhino-laryngologie, et la santé publique.

En fait, elle offre le seul programme de spécialisation en Afrique Centrale dans les

domaines de l’imagerie médicale, de l’ORL et de l’ophtalmologie. Des sous

spécialisations sont en projet (cardiologie, néphrologie, endocrinologie,

gastroentérologie). La FMSB propose aussi des diplômes d’université dans des

domaines spécifiques (médecine d’urgence, chirurgie endoscopique et reproduction

humaine, échographie, pharmacie et santé publique).

La filière médico-sanitaire et biomédicale propose une licence dans trois domaines :

sciences infirmières, radiologie et imagerie médicale et sciences biologiques. La

maîtrise qui permet des spécialisations admet dans les sciences médico-sanitaires

neuf options: sciences infirmières en médecine interne et spécialités médicales, en

chirurgie et spécialités, en pédiatrie, en gynéco-obstétrique, en anesthésie-

réanimation, en ophtalmologie et en ORL, en radiologie et imagerie médicales et en

santé publique ; dans les sciences biomédicales, sept options : bactériologie –

virologie médicale, parasitologie – mycologie médicale, biochimie médicale,

hématologie médicale, immunologie Médicale, maladies infectieuses,

pharmacognosie médicale. En 2009, le Ministre de l’Enseignement Supérieur a

ouvert dans cette filière un cycle de Ph.D en techniques biomédicales, techniques

médico- sanitaires, nursing et génie sanitaire.



5. Organisation administrative

L’organisation administrative actuelle de la FMSB comprend une assemblée de

faculté, un conseil de faculté, un doyen assisté de trois vice-doyens et des services

administratifs. L’organisation académique comprend onze départements : sciences

morphologiques et anatomie pathologique ; sciences physiologiques ; microbiologie,

hématologie et pathologies infectieuses ; médecine interne et spécialités ; chirurgie

générale et spécialités ; ophtalmologie, O.R.L. et stomatologie ; gynécologie

obstétrique ; pédiatrie ; imagerie médicale et radiothérapie ; santé publique ;

pharmacie et thérapeutique traditionnelle. Tous ces services sont logés dans trois

blocs : un bloc administratif avec un amphithéâtre de 300 places et une bibliothèque

avec 30 000 références et une connexion internet, une unité de sciences

biomédicales et une unité de santé publique.

6. Méthode d’enseignement et d’évaluation

L’année académique est divisée en deux semestres. Le premier semestre s’étend de

mi-octobre à mi-février et le second de mi-mars à juillet. Les enseignements sont

dispensés selon plusieurs modalités complémentaires. Les cours magistraux d’une

durée comprise entre une et deux heures sont prévus au premier et deuxième cycle.

Ils sont dispensés le matin au premier cycle et l’après-midi aux deuxième et troisième

cycles. Les travaux pratiques (TP) et les travaux dirigés (TD) ont lieu soit au

laboratoire, soit sous forme de soins intégrés de santé, dans les institutions

hospitalières et les communautés. Les séminaires et symposiums multidisciplinaires

ont lieu chaque semaine au deuxième cycle. Les stages cliniques et de laboratoire

ont lieu essentiellement à partir du deuxième cycle. Ils incluent plusieurs activités :

rondes d’enseignement aux chevets des malades, consultations d’urgence et

consultations externes programmées, participation aux interventions chirurgicales,

réunions scientifiques du service et exposés illustrés. Il y a également la participation

aux travaux de recherche pour les étudiants de fin de deuxième cycle et de troisième

cycle. Les enseignements font largement appel aux technologies de l’information et

de la communication : vidéo projection, internet, CD ROM. La coordination des

enseignements est effectuée au niveau du département.

L’évaluation des connaissances théoriques a lieu lors des contrôles continus de

connaissances du premier cycle (deux par semestre) et lors de l’examen de fin de



semestre. Celui-ci consiste en une épreuve écrite comportant des questions à choix

multiples (QCM) ou des questions à réponses ouvertes et courtes (QROC).

L’évaluation pratique au premier cycle se fait sous forme de TP en fin de semestre.

Au deuxième cycle, l’évaluation est basée sur l’examen du cahier journal, le

comportement général (éthique, attitude, humanisme) et un examen final structuré en

cas longs et cas courts. La coordination des évaluations est effectuée par le

département.



I.I.I.I. RÉSUMÉ DE L’ANALYSE ET DE LA CONCEPTIONRÉSUMÉ DE L’ANALYSE ET DE LA CONCEPTIONRÉSUMÉ DE L’ANALYSE ET DE LA CONCEPTIONRÉSUMÉ DE L’ANALYSE ET DE LA CONCEPTION

Il est à noter que ce travail fait suite à une série d’activités d’analyse et de

conception menées par des prédécesseurs dans les mêmes circonstances. Avant de

dérouler la tâche qui nous incombe, nous allons tout d’abord présenter en bref les

différents intervenants ainsi que la synthèse de leurs travaux (en cas de nécessité),

pour favoriser la bonne compréhension de ce document.

Documents Auteurs Superviseurs

Cahier des Charges du Module

de suivi de la formation ; Cahier

d’analyse et conception du

Module de suivi de la formation

(Année Académique 2009-2010)

ANKIAMBOM SALLAH Virgil ;

IGO’O BOOSSE Luc

MAHI NKAK Paul Junior

MALKONBE

(Projet de synthèse)

Pr Claude TANGHA

Dr Georges Edward KOUAMOU

Cahier des Charges du Module

de gestion des stages

(Année Académique 2009-

2010)Cahier d’analyse et

conception du Module de gestion

des stages


NDJOBO Armel Fabrice

NGOUANE Armel

DEFO TOGUEU Michael

Ghislain

NDJANDJA SANDJO Jacob

(Projet de synthèse)

Pr CLAUDE TANGHA

Mr BATCHAKUI Bernabé

Intégration synthétique de

l’analyse conception des Modules

de gestion de stage et de suivi de

la formation


IGO’O BOOSSE Luc

(Mémoire de fin d’étude

d’ingénieur)

Pr CLAUDE TANGHA

Pr. TETANYE EKOE,

Pr. NKO’O

Tableau 1 : Liste des activités déjà réalisées dans le cadre de ce projet

CHAPITRE II : RÉSUMÉ DE L'ANALYSE ET DE LA CHAPITRE II : RÉSUMÉ DE L'ANALYSE ET DE LA CHAPITRE II : RÉSUMÉ DE L'ANALYSE ET DE LA CHAPITRE II : RÉSUMÉ DE L'ANALYSE ET DE LA

CONCEPTION, PRISE EN MAIN DU PROJETCONCEPTION, PRISE EN MAIN DU PROJETCONCEPTION, PRISE EN MAIN DU PROJETCONCEPTION, PRISE EN MAIN DU PROJET



1) Les acteurs du système

L’administration

C’est le principal utilisateur du système. Il concerne le doyen et ses proches

collaborateurs. Ceux-ci ont des privilèges étendus et peuvent obtenir n’importe quels

états ou statistiques leur permettant de prendre les meilleures décisions en matière

de formation ou de suivi de stages.

Le stagiaire

C’est le principal concerné dans le module de gestion des stages. Des objectifs

lui sont assignés au début du stage en fonction de son niveau. Son champ d’action

au sein du système se résume à sa personne et à ses activités.

L’encadreur

Il accompagne le stagiaire dans l’atteinte des objectifs du stage et se charge de

l’évaluation de ce dernier. Son champ d’action se réduit à ses activités et à celles des

stagiaires sous sa responsabilité.

L’opérateur de saisie

C’est un agent de la FMSB ou de la structure d’accueil qui se charge de

renseigner le système sur les activités des enseignants, des stagiaires ou sur

l’évolution des cours. Ces informations vont par la suite faire l’objet d’une validation

par les encadreurs ou toute autre autorité compétente.

L’administrateur du système

Il assure la configuration de l’application, ainsi que des habilitations des autres

utilisateurs. Son existence prend son point d’ancrage dans la potentielle complexité

de l’architecture matérielle et logicielle de cette solution mais aussi et surtout dans le

fait que les divers intervenants ne sont pas pour la plupart des experts en

informatique.



2) Les cas d’utilisation du système

Cas d’utilisation 1: S’identifier dans le système (se connecter)

Ici il est question de se connecter à notre application. L’utilisateur entre son login

et son mot de passe et, s’ils sont validés, il se connecte avec un profil qui définit

ses droits d’accès au système.

Cas d’utilisation 4: Créer un compte

L’administrateur indique les informations personnelles (telles que le nom, le

prénom, l’e-mail, le numéro de téléphone), de même qu’un login et un mot de

passe que l’utilisateur pourra changer à sa guise.

Cas d’utilisation 5: Supprimer un compte

L’administrateur sélectionne un compte ou groupe de comptes et le(s) supprime.

Cas d’utilisation6: Archiver les données

Cette fonctionnalité permettra à l’Administration à la fin de l’année, d’archiver les

informations contenues dans le système, ceci pour une consultation ultérieure.

Cas d’utilisation8 : Mise à jour des présences des enseignants

Cette fonctionnalité permettra à l’acteur de modifier, supprimer les informations

liées aux présences effectives des enseignants aux cours. Il devra pour cela se

servir des fiches et cahiers de textes tenus par les Chefs de classe.

Cas d’utilisation 9: Visualiser les informations de stage

Le stagiaire peut à chaque moment accéder à son compte pour visualiser les

informations le concernant, ainsi que mesurer son avancement dans le stage.

Cas d’utilisation 10: Saisir les données

Il s’agit pour le stagiaire de saisir des informations relatives à son stage dans le

système.



Cas d’utilisation 11: Valider les données saisies

Il s’agit pour l’encadreur de vérifier et valider les informations saisies par un

stagiaire de sa structure hospitalière.

Cas d’utilisation 12: Etablir les états pour une structure hospitalière

Il s’agit pour un membre de l’administration, de visualiser et/ou d’importer (pour

impression) les états pour une structure dans laquelle des stagiaires effectuent

leur stage.

Cas d’utilisation 13: Etablir les états de l’encadrement

Il s’agit pour un membre de l’administration, de visualiser et/ou d’importer (pour

impression) les états pour un encadreur de stage.

Cas d’utilisation 14: Etablir les états des stagiaires

Il s’agit pour l’utilisateur, de visualiser et/ou d’importer (pour impression) les états

d’un étudiant en stage dans une structure hospitalière.

Cas d’utilisation15 : Consulter la liste des enseignants et des cours qu’ils

dispensent.

L’Administration pourra, grâce à cette fonctionnalité consulter la liste des

enseignants et les cours à ceux-ci affectés.

Cas d’utilisation 16: Consulter l’emploi de temps de l’enseignant

Grâce à cette fonctionnalité, l’Administration pourra consulter l’emploi de temps

d’un enseignant précis.

Cas d’utilisation 17: Consulter le récapitulatif des présences/absences des

enseignants

L’opérateur pourra, grâce à cette fonctionnalité consulter pour tous les

enseignants dispensant des cours, les nombres d’heures de cours effectives et le

nombre d’heures d’absences, à partir des heures de cours prévues.



Cas d’utilisation 18: Consulter la liste des départements pour un enseignant

Cette fonctionnalité permet à l’administration de connaître les différentes filières

où un enseignant dispense ses cours.

Cas d’utilisation 19: Consulter la liste des cours nécessitant un rattrapage

L’acteur consulte une liste constituée des Unités d’Enseignement (UE) que

dispense un enseignant précis, et identifie ceux qui nécessitent des séances de

rattrapage.

Cas d’utilisation 20: Consulter le bilan horaire

Cette fonctionnalité permet à l’Administration d’évaluer l’état d’avancement de ses

cours au sein de l’école. Il s’agit en réalité du nombre total d’heures de cours

qu’un enseignant a dispensé, ceci comparé au nombre total d’heures de cours

prévu.

NB : Cela pourra lui être présenté sous forme de pourcentage.

Cas d’utilisation 21: Consulter l’état d’avancement des cours

L’administration pourra, grâce à cette fonctionnalité,consulter pour tous les

enseignants les informations relatives à l’avancement de ceux-ci.

Cas d’utilisation 22: Consulter la liste des cours évalués

L’administration pourra, grâce à cette fonctionnalité connaître l’état des différents

cours, du point de vue de leur évaluation (Contrôle continu, TP, examen).

Cas d’utilisation 26: Se déconnecter

Toute personne connectée au système peut à tout moment se déconnecter

Cas d’utilisation 27: Visualiser son profil

Il s’agit pour l’utilisateur d’observer ses informations personnelles.

Cas d’utilisation 28: Modifier ses informations personnelles

Un utilisateur quelconque peut à tout moment modifier certaines informations

personnelles (par exemple changer son numéro de téléphone).

Conception et Mise en œuvre d’un système

Stage pré-ingénieur effectué par NGANMENI Zéphirin

3) Exigences de réalisation et architecture simplifiée de l’application

Le langage de programmation choisi est le JAVA (J2SE et J2EE), qui est un de programmation purement orienté objet, développé par Sun Microsystems.

Le logiciel devra aussi se servir des accès distants (RMI, EJB). Pour cela, nous

avons choisi la spécification J2EE, qui fournit l’architecture nécessaire au

développement d’applications distribuées. Cettespécification a les avantages ci

dessous :

La facile extension de l’architecture choisie

La possibilité pour un système qui repose sur J2EE de posséder des

mécanismes de haute

service

La facile-maintenabilité des applications

De plus, l’architecture 3 tiers a été préférée à l’architecture classique

serveur parce qu’elle répond mieux aux différentes

Alléger le poste de travail client

Prendre en compte l’hétérogénéité des plates

Améliorer la sécurité des données

se en œuvre d’un système de gestion intégrée de stages et de suivi de la formation : Cas de la FMSB

ingénieur effectué par NGANMENI Zéphirin – Année académique 2009/2010

Exigences de réalisation et architecture simplifiée de l’application

Le langage de programmation choisi est le JAVA (J2SE et J2EE), qui est un de programmation purement orienté objet, développé par Sun Microsystems.



pplications distribuées. Cettespécification a les avantages ci

La facile extension de l’architecture choisie


mécanismes de haute-disponibilité, afin de garantir une bonne qualité

maintenabilité des applications

Figure 1 : Architecture de l'application

De plus, l’architecture 3 tiers a été préférée à l’architecture classique

pond mieux aux différentes attentes énoncées ci

Alléger le poste de travail client

Prendre en compte l’hétérogénéité des plates-formes

Améliorer la sécurité des données

de stages et de suivi de la formation : Cas de la FMSB

Exigences de réalisation et architecture simplifiée de l’application

Le langage de programmation choisi est le JAVA (J2SE et J2EE), qui est un langage de programmation purement orienté objet, développé par Sun Microsystems.



pplications distribuées. Cettespécification a les avantages ci-


disponibilité, afin de garantir une bonne qualité de

De plus, l’architecture 3 tiers a été préférée à l’architecture classique client-

attentes énoncées ci-après :



Séparer les couches présentation et traitement

Enfin, elle permet de gérer plus facilement un nombre de clients plus

important, ce qui est l’un de nos objectifs.

II.II.II.II. PRISE EN MAIN DU PROJETPRISE EN MAIN DU PROJETPRISE EN MAIN DU PROJETPRISE EN MAIN DU PROJET ET PLANIFICATIONET PLANIFICATIONET PLANIFICATIONET PLANIFICATION

1. Phase de la restitution du contexte par nos préd écesseurs

Au terme de l’année académique, tous les étudiants de quatrième année de

l’école polytechnique sont soumis à un stage pré-ingénieur obligatoire. C’est en

faveur de cette mesure que nous avons bénéficié d’un stage pour une durée de deux

mois auprès de la Faculté de Médecine et des Sciences Biomédicales de Yaoundé. Il

nous a été mandaté de travailler sur le projet d'informatisation de la gestion des

stages et du suivi des cours (ci-dessous présenté) dans cette illustre institution.

Notre première préoccupation est de prendre connaissance du déjà fait et surtout

de ce qui reste à faire dans ce projet. Lors du briefing avec Monsieur Luc IGO’O

BOOSSE, nous nous sommes rendu compte de quelques évidences parmi

lesquelles deuxprincipales nous ont marquées :

Tout d’abord, nous réalisons que nous avons affaire à un projet de grande

envergure et très ambitieux ayant fait l’objet de plusieurs études par divers groupes

d’étudiants dans le cadre des projets de synthèse et ayant donné lieu à un mémoire

d’ingénieur de conception.

Ensuite, il ne fait aucun doute que hors mis quelques documents numériques mis

à notre disposition, nous devons poursuivre ce travail sans aucune assistance

rapprochée.

Après cette entrevue ponctuelle avec IGO’O BOOSSE, nous en avons eu

d’autres avec le Pr CLAUDE TANGHA puis avec le Pr. NKO’O pour des formalités

administratives.



Le processus de prise en main nous a conduitsà la détection et à la correction

de quelques petites erreurs dans la démarche de nos prédécesseurs. C’est ainsi

que :

Le cahier de conception a été allégé d’un fallacieux sous module de gestion

des « activités extra » car celui-ci ne représentait aucune réalité du système et nos

prédécesseurs se sont simplement fiés à leur sens et disent-ils aux informations

recueillies auprès des étudiants.

Nous avons également mis sur pied l’ensemble des tables de la base de

données relationnelle du système, prenant en compte une subtile exigence

administrative jusque-là ignorée qui veut que les emplois de temps soient

dynamiques. Ainsi, un enseignant ne dispose pas d’un emploi de temps

hebdomadaire fixé comme c’est généralement le cas. Chaque emploi de temps est

une description détaillée des activités programmées pour chaque jour de la semaine

et par tranche horaire. (Confer un exemple en annexe).

Tout cela nous a conduits à la réfection (15 à 20%) des diagrammes de

séquences et des classes du système et à reprendre à zéro l’implémentation du

projet quoi que nos prédécesseurs prétendaient s’y êtres penchés jusqu’à un certain

niveau.

A la fin de cette première étape (lundi 5 juillet 2010 – mercredi 14 juillet 2010)

menée de concert avec mon Co-stagiaire, il était temps pour chacun de nous de

s’assigner des objectifs personnels représentés par un certain nombre de tâches

planifiées dans le temps.

2. Identification des tâches

Une application java est souvent découpée en couches, chacune ayant un rôle

bien défini. La nôtre n’échappe pas à la règle:



Figure 2 : Présentation des trois couches de l'application

� la couche [1], appelée ici [ui] (User Interface) est la couche qui dialogue avec

l'utilisateur, via une interface graphique Swing, une interface console ou une

interface web. Elle a pour rôle de fournir des données provenant de

l'utilisateur à la couche [2] ou bien de présenter à l'utilisateur des données

fournies par la couche [2].

� la couche [2], appelée ici [métier] est la couche qui applique les règles dites

métier, c.à.d. la logique spécifique de l'application, sans se préoccuper de

savoir d'où viennent les données qu'on lui donne, ni où vont les résultats

qu'elle produit.

� la couche [3], appelée ici [dao] (Data Access Object) est la couche qui fournit

à la couche [2] des données préenregistrées(fichiers, bases de données, ...) et

qui enregistre certains des résultats fournis par la couche [2].

Chacune de ces couches peut se subdiviser en plusieurs sous couches, chacune

présentantses propres spécifications et offrant plusieurs possibilités

d’implémentation comme le suggère le schéma suivant :

Figure 3 : Intégration des conteneurs Ejb3 dans l’architecture



La couche [Hibernate] vient se placer entre la couche [dao] écrite par le

développeur et la couche [Jdbc]. Hibernate est un ORM (Object RelationalMapping),

un outil qui fait le pont entre le monde relationnel des bases de données et celui des

objets manipulés par Java. Le développeur de la couche [dao] ne voit plus la couche

[Jdbc], ni les tables de la base de données dont il veut exploiter le contenu. Il ne voit

que l'image objet de la base de données, image objet fournie par la couche

[Hibernate].

[Toplink] est une couche d'abstraction qui se veut la plus transparente

possible. L'idéal visé est que le développeur de la couche [dao] puisse ignorer

totalement qu'il travaille avec une base de données.

La couche [4] des objets, image de la BD est appelée "contexte de

persistance". Une couche [dao] s'appuyant sur Hibernate fait des actions de

persistance (CRUD, create - read - update - delete) sur les objets du contexte de

persistance, actions traduites par Hibernate en ordres SQL exécutés par la couche

Jdbc. Pour les actions d'interrogation de la base (le SQL Select), Hibernate fournit au

développeur, un langage HQL (HibernateQueryLanguage) pour interroger le contexte

de persistance [4] et non la BD elle-même.

Les EJB3 sont des POJOs tagués par des annotations qui en font des objets

particuliers lorsqu'ils sont au sein d'un conteneur EJB3. L’EJB3 va pouvoir bénéficier

des services du conteneur (pool de connexions, gestionnaire de transactions, ...). En-

dehors du conteneur EJB3, l'EJB3 est un objet Java normal.

Il ressort de ce développement que l’implémentation de cette application exige

non seulement d’énormes compétences mais surtout de voir un choix judicieux des

outils et une planification rigoureuse du travail. Compte tenu de notre effectif, du

temps imparti pour ce projet et davantage des exigences de l’administration de la

faculté de médecine concernant la présentation d’un prototype fonctionnel à brève

échéance, nous avons fait le choix planifié suivant :

� L’exploitation des outils de génération de NetBeans pour produire et

configurer la couche [JPA] et la couche [Ejb] qui contrôle l'accès aux entités

JPA. Notons que pour cela, Il est intéressant de connaître ces méthodes de

génération automatique car le code généré donne de précieuses

indicationssur la façon d'écrire des entités JPA ou le code Ejb qui les utilise.

Planning : Tâche à effectuer avant le lundi 26 juillet 2010



� La conception des interfaces utilisateurs pour le client lourd, répondant aux

exigences du système et d’utilisation.

Planning : Tâche à effectuer avant le lundi 02 août 2010

� L’intégration des interfaces ci-dessus mentionnées dans un module client

lourd et la création des interactions entre ce module client et le module des

ejb.


� La conception, la réalisation, l’intégration et la configuration des classes de

génération des états du système.


� La mise en œuvre des différents tests


� Une suspension du stage entre le 1er septembre et le 13 septembre pour la

saison de rattrapage académique.

� La finalisation, la conception d’un exécutable et d’un cahier d’utilisation puis le

déploiement sur des postes de la faculté de médecine et (pour des raisons

d’appréciations) sur un poste au département d’informatique de l’ENSP.

Planning : Tâche à effectuer avant le lundi 20 septembre 2010



I.I.I.I. PRÉLIMINAIRESPRÉLIMINAIRESPRÉLIMINAIRESPRÉLIMINAIRES

1. Création de la base de données

Les données statistiques utiles pour le fonctionnement du système seront

placées dans une base de données que nous désignerons par la suite db_fmsb.

Nous l’avons créée à l’aide d’un consensus entre les outils Mysqlquery Browser et

Navicat Lite. On y comptabilise 27 tables devant stocker l’ensemble des informations

du système.

2. Configuration Hibernate du serveur Glassfish

Selon sa version, le serveur Glassfish V2 livré avec Netbeans peut ne pas

avoir les bibliothèques Hibernate dont la couche Jpa /Hibernate a besoin. Il faut

rajouter les bibliothèques dans le dossier [<glassfish>/domains/domain1/lib] puis

redémarrer le serveur Glassfish.

3. Création d'une connexion NetBeans à la base de d onnées

Pour la création d'une connexion NetBeans à la base de données MYSQL ; ayant

lancé Netbeans, on doit suivre les principaux étapes suivantes :

o Lancer le SGBD MySQL 5 afin que la BD soit disponible

o Dans l'onglet [Files], dans la branche [Data bases], sélectionner le pilote

Jdbc MySQL

o Puis sélectionner l'option "ConnectUsing" permettant de créer une

connexion avec une base MySQL

CHAPITRE IIICHAPITRE IIICHAPITRE IIICHAPITRE III : EXPLOITATION DES OUTILS : EXPLOITATION DES OUTILS : EXPLOITATION DES OUTILS : EXPLOITATION DES OUTILS

DE GÉNÉRATION DE NETBEANSDE GÉNÉRATION DE NETBEANSDE GÉNÉRATION DE NETBEANSDE GÉNÉRATION DE NETBEANS



Figure 4 : Création d'une connexion NetBeans à la base de données

o Donner les informations de configuration qui vous sont demandées

o Puis valider

II.II.II.II. CRÉATION ET CRÉATION ET CRÉATION ET CRÉATION ET CONFIGURATION D’UN PROJET ECONFIGURATION D’UN PROJET ECONFIGURATION D’UN PROJET ECONFIGURATION D’UN PROJET EJBJBJBJB

1. Création d’un projet ejb

o Choisir de créer une nouvelle application, un module Ejb

o Puis choisir la catégorie [Java EE] et le type [EJB Module]

o Choisir un dossier pour le projet

o Puis terminer l'assistant

2. Ajout d'une ressource JDBC au serveur Glassfish

Nous devons ajouter une ressource JDBC au serveur Glassfish

o Dans l'onglet [Services], lancer le serveur Glassfish

o Dans l'onglet [Projects], cliquer droit sur le projet Ejb et sélectionner l'option

[New / Other] permettant d'ajouter un élément au projet.

o Sélectionner la catégorie [Glassfish] et indiquer qu'on veut créer une

ressource JDBC en sélectionnant le type[JDBC Resource]

o Indiquer que cette ressource JDBC va utiliser son propre pool de connexions

o Donner un nom à la ressource JDBC puis passer à l'étape suivante

o On doit définir les caractéristiques du pool de connexions de la ressource

JDBC :

- En donnant un nom au pool de connexions

- En choisissant la connexion NetBeans [db_fmsb] créée précédemment

- Puis, passer aux étapes suivantes en conservant les choix par défaut

jusqu’à la validation.



Celui-ci crée le fichier [sun-resources.xml] dont le contenu est le suivant :

Tableau 2 : Contenu du fichier de configuration sun-resources.xml

III.III.III.III. GÉNÉRATION ET CONFIGURATION DE LA COUCHE [JPA]GÉNÉRATION ET CONFIGURATION DE LA COUCHE [JPA]GÉNÉRATION ET CONFIGURATION DE LA COUCHE [JPA]GÉNÉRATION ET CONFIGURATION DE LA COUCHE [JPA]

1. Création d'une unité de persistance

L'unité de persistance [persistence.xml] configure la couche JPA : elle indique

l'implémentation JPA utilisée (Toplink, Hibernate, ...) et configure celle-ci.

o Cliquer droit sur le projet Ejb et sélectionner [New / Other]

o Sélectionner la catégorie [Persistence] puis en, indiquer que vous voulez créer

une unité de persistance JPA

o Donner un nom à l'unité de persistance créée

o Choisir [Toplink] comme implémentation JPA

o Sélectionner la ressource Glassfish "jdbc/db_fmsb" qui vient d'être créée

o Indiquer qu'aucune action ne doit être faite sur la base, lors de l'instanciation

de la couche JPA

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE resources PUBLIC "-//Sun Microsystems, Inc.//DTD Application Server 9.0 Resource Definitions //EN"

"http://www.sun.com/software/appserver/dtds/sun-resources_1_3.dtd">

<resources>

<jdbc-resource enabled="true" jndi-name="jdbc/dbFmsb" object-type="user" pool-name="dbFmsbPool">

<description/>

</jdbc-resource>

<jdbc-connection-pool allow-non-component-callers="false" associate-with-thread="false" connection-creation-retry-

attempts="0" connection-creation-retry-interval-in-seconds="10" connection-leak-reclaim="false" connection-leak-timeout-in-

seconds="0" connection-validation-method="auto-commit" datasource-

classname="com.mysql.jdbc.jdbc2.optional.MysqlDataSource" fail-all-connections="false" idle-timeout-in-seconds="300" is-

connection-validation-required="false" is-isolation-level-guaranteed="true" lazy-connection-association="false" lazy-

connection-enlistment="false" match-connections="false" max-connection-usage-count="0" max-pool-size="32" max-wait-time-

in-millis="60000" name="dbFmsbPool" non-transactional-connections="false" pool-resize-quantity="2" res-

type="javax.sql.DataSource" statement-timeout-in-seconds="-1" steady-pool-size="8" validate-atmost-once-period-in-

seconds="0" wrap-jdbc-objects="false">

<property name="URL" value="jdbc:mysql://localhost:3306/db_fmsb"/>

<property name="User" value="root"/>

<property name="Password" value=""/>

</jdbc-connection-pool>

</resources>



o Terminer l'assistant

o Le contenu du fichier [persistence.xml] créé par l'assistant est le suivant :

<?xml version="1.0" encoding="UTF-8"?>

<persistence version="1.0" xmlns="http://java.sun.com/xml/ns/persistence"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="http://java.sun.com/xml/ns/persistence

http://java.sun.com/xml/ns/persistence/persistence_1_0.xsd">

<persistence-unit name="projetStageFmsbEjbPU" transaction-type="JTA">

<jta-data-source>jdbc/db_fmsb</jta-data-source>

<exclude-unlisted-classes>false</exclude-unlisted-classes>

<properties/>

</persistence-unit>

</persistence>

Tableau 3 : Contenu du fichier de configuration persistence.xml

2. Création des entités JPA

Etapes à suivre pour la création des entités JPA

o Cliquer droit sur le projet et choisir l'option [New / Other]

o Sélectionner la catégorie [Persistence] puis indiquer que vous voulez

créer des entités JPA à partir d'une basede données existante.

o Sélectionner la source JDBC "jdbc/db_fmsb" que nous avons créée

o Inclure toutes les 27 tables de la base de données associéedans la

génération des entités JPA

o Donner un nom au package des entités JPA

o Choisir le type Java qui va encapsuler les listes d'objets rendus par la

couche JPA


o Les 27 entités JPA générées, une pour chaque table de la base de

données.



Voici par exemple le code de l'entité [Connexion] qui représente une ligne de la table [connexion] de la base [db_fmsb].

/* * To change this template, choose Tools | Templates * and open the template in the editor. */ package projetStageFmsbEjb.entities; import java.io.Serializable; import javax.persistence.Basic; import javax.persistence.Column; import javax.persistence.Entity; import javax.persistence.GeneratedValue; import javax.persistence.GenerationType; import javax.persistence.Id; import javax.persistence.NamedQueries; import javax.persistence.NamedQuery; import javax.persistence.Table; /** * * @author Nganmeni */ @Entity @Table(name = "connexion") @NamedQueries({ @NamedQuery(name = "Connexion.findAll", query = "SELECT c FROM Connexion c")}) public class Connexion implements Serializable { private static final long serialVersionUID = 1L; @Id @GeneratedValue(strategy = GenerationType.IDENTITY) @Basic(optional = false) @Column(name = "num_con") private Integer numCon; @Basic(optional = false) @Column(name = "login") private String login; @Basic(optional = false) @Column(name = "password") private String password; @Column(name = "code_droit") privateIntegercodeDroit; @Column(name = "groupe") private String groupe; public Connexion() { } public Connexion(IntegernumCon) { this.numCon = numCon; } public Connexion(Integer numCon, String login, String password) { this.numCon = numCon; this.login = login; this.password = password; } public Integer getNumCon() { return numCon; }

public void setNumCon(Integer numCon) { this.numCon = numCon; } public String getLogin() { return login; } public void setLogin(String login) { this.login = login; } public String getGroupe() { return groupe; } public void setGroupe(String gpe) { this.groupe = gpe; } public String getPassword() { return password; } public void setPassword(String password) { this.password = password; } public Integer getCodeDroit() { return codeDroit; } public voidsetCodeDroit(IntegercodeDroit) { this.codeDroit = codeDroit; } @Override public inthashCode() { int hash = 0; hash += (numCon != null ? numCon.hashCode() : 0); return hash; } @Override public boolean equals(Object object) { // TODO: Warning - this method won't work in the case the id fields are not set if (!(object instanceofConnexion)) { return false; } Connexion other = (Connexion) object; if ((this.numCon == null &&other.numCon != null) || (this.numCon != null && !this.numCon.equals(other.numCon))) { return false; } return true; } @Override public String toString() { return "entities.Connexion[numCon=" + numCon + "]"; } }

Tableau 4 : Exemple du code de l'entité [Connexion] représentant une ligne de la table [connexion] de la base de données.



IV.IV.IV.IV. GÉNÉRATION ET CONFIGURATION DE LA COUCHE [EJB] D’ACCÈS GÉNÉRATION ET CONFIGURATION DE LA COUCHE [EJB] D’ACCÈS GÉNÉRATION ET CONFIGURATION DE LA COUCHE [EJB] D’ACCÈS GÉNÉRATION ET CONFIGURATION DE LA COUCHE [EJB] D’ACCÈS

AUX ENTITÉS JPAAUX ENTITÉS JPAAUX ENTITÉS JPAAUX ENTITÉS JPA

Pour générer la couche EJB d’accès aux entités JPA que nous avons créé

précédemment, nous devons suivre les étapes suivantes :

o Cliquer droit sur le projet et, sélectionner l'option [New / Other]

o Sélectionner la catégorie [Persistence] puis le type [Session Beans for

Entity Classes]

o Les entités JPA créées précédemment sont présentées

o Les sélectionner toutes

o Donner un nom au package des ejb qui vont être générés

o Indiquer que les Ejb doivent implémenter à la fois une interface locale

et distante


Voici par exemple, le code de l'Ejb qui gère l'accès à l'entité [Connexion], donc à la

table [connexion] de la base de données [db_fmsb] :

Tableau 5 : Exemple de code de l'Ejb qui gère l'accès à l'entité [Connexion]

/* * To change this template, choose Tools | Templates * and open the template in the editor. */ package projetStageFmsbEjb.session; import projetStageFmsbEjb.entities.Connexion; import java.util.List; import javax.ejb.Remote; /** * * @author Nganmeni */ @Remote public interface ConnexionFacadeRemote { voidcreate(Connexion connexion); voidedit(Connexion connexion); voidremove(Connexion connexion); Connexion find(Object id); List<Connexion>findAll(); List<Connexion>findRange(int[] range); intcount(); }



Après avoir exploité les outils de génération automatique de NetBeans pour générer

la partie mécanique de l’application, il nous faut maintenant écrire la partie intelligente du

programme (code métier). Cette partie est essentiellement constituée des interfaces

utilisateur et d’un ensemble de codes de traitement de données. Pour plus de détails, nous

présenterons ci-dessous les interfaces Swing ainsi que les spécifications requises pour une

bonne navigation à travers l’application.

I.I.I.I. PRÉLIMINAIREPRÉLIMINAIREPRÉLIMINAIREPRÉLIMINAIRE

1. La fenêtre de connexion

Figure 5 : Fenêtre de connexion à l'application

L’application démarre avec une fenêtre de connexion qui demande le login et le mot

de passe de l’utilisateur. Pour un utilisateur qui ne dispose pas encore d’un login, il est

possible d’en créer directement ici car en entrant un login non existant et un mot de passe,

le système vous propose de créer un compte sous cette identité. Notons qu’un tel utilisateur

ne dispose d’aucun droit de modification, il ne peut que consulter certaines informations.

Pour pouvoir disposer de droit plus élevé, il doit consulter l’administrateur qui est le seul à

pouvoir attribuer les droits aux utilisateurs.

CHAPITRE VCHAPITRE VCHAPITRE VCHAPITRE V : : : : IMPLÉMENTATION DU MODULE IMPLÉMENTATION DU MODULE IMPLÉMENTATION DU MODULE IMPLÉMENTATION DU MODULE

CLIENT SWINGCLIENT SWINGCLIENT SWINGCLIENT SWING



2. La fenêtre d’accueil

Figure 6 : Fenêtre d'accueil

Après la phase d’identification, nous présentons à l’utilisateur une interface d’accueil/aide

constituée de plusieurs rubriques :

• Le logo de l’université de Yaoundé I dont la Faculté de Médecine et des Sciences

Biomédicales constitue une des institutions.

• Un texte défilant qui présente de façon synoptique chaque rubrique de la fenêtre.

• Un onglet pour accéder au module de gestion de la formation.

• Un onglet pour accéder au module de suivi des stages.

• Un onglet pour accéder au module d’administration restreinte.

• Un onglet pour accéder au module d’administration étendue.

• Les aides détaillées pour chaque module du système.

IIIIIIII. . . . LE MODULE DE GESTION DE LA FORMATIONLE MODULE DE GESTION DE LA FORMATIONLE MODULE DE GESTION DE LA FORMATIONLE MODULE DE GESTION DE LA FORMATION

1.1.1.1. Gestion des présences aux cours par filière

Figure 7: Fenêtre de validation des présences



L’onglet présence permet de valider la présence des enseignants aux cours. Ainsi,

l’opérateur de saisie remplit grâce à la fiche de présence ou du cahier de texte, la présence

aux cours. Il doit pour cela remplir les champs : filière, option, cycle et niveau, unité

d’enseignement, nature de l’activité tranche horaire, date et observation (présent ou

absent) pour identifier une tranche horaire précise pour une classe donnée. Dans un

tableau, on peut directement consulter le rendu de la base de données qui indique l’état de

présence au cours pour ce cours et pour cette classe. Il est également possible de visualiser

l’état de présence aux cours pour l’ensemble des cours de la filière choisie en cliquant sur

afficher la totalité. Les champs surmontés du symbole étoile (*) sont obligatoires pour la

validation des données entrées sur une fenêtre.

2.2.2.2. Suivi des enseignants

Figure 8 : Fenêtre de suivi des enseignants

L’onglet enseignant ouvre sur une fenêtre de suivi des enseignants. Sur cet espace,

après le choix d’un enseignant par son nom, on peut visualiser les autres informations sur

celui-ci : la discipline, le contact, le grade etc. C’est ici que l’on assigne une activité à un

enseignant en précisant entre autre la date, l’heure, la filière, l’option, le cycle et le niveau,

l’unité d’enseignement et la nature de l’activité.

Un mécanisme du système gère les conflits de programmation de telle sorte qu’un

même enseignant ne peut être programmé dans deux classes à la même tranche horaire. De

la même façon, on ne peut programmer deux activités pour une même filière durant une

tranche horaire précise sauf en cas d’une activité collégiale. Dans ce dernier cas, l’opérateur

de saisie doit l’autoriser à travers une fenêtre de dialogue qui s’ouvre dès qu’une telle

possibilité se présente. L’occupation des salles de cours est également soumise à un contrôle



de conflit de la sorte que deux activités distinctes ne peuvent pas être programmées dans

une même salle de classe.

Pour supprimer une activité assignée à un enseignant, l’utilisateur identifie la tranche

horaire concernée dans le tableau et clique simplement dessus et une boîte de dialogue

s’ouvre à cet effet comme l’indique la capture d’écran ci-dessus. A défaut, on peut

également remplir l’essentiel des informations nécessaires à l’identification de l’activité en

question puis cliquer sur le bouton supprimer et confirmer la suppression.

Le bouton imprimer permet d’imprimer l’emploi de temps d’un enseignant. C’est une

représentation par tableau de l’ensemble des activités assignées à cet enseignant. Confère

annexe pour un exemple d’emploi de temps.

3.3.3.3. Etudiant

Figure 9: Fenêtre de suivi des étudiants

L’onglet étudiant permet de consulter la liste de tous les étudiants d’une filière donnée.

Il est également possible de consulter la liste de tous les étudiants de l’école en cliquant sur

récapitulatif.



4.4.4.4. Les états

a) Etat d’avancement des cours

Figure 10 : Générer l'état d'avancement des cours

La fenêtre état d’avancement des cours présente pour une unité d’enseignement

choisie et pour une classe donnée, le nombre d’heures requises pour le cours magistral, le

nombre d’heures requises pour les travaux dirigés et pratiques, le nombre d’heures déjà

assignées aux enseignants pour le cours magistral et pour les travaux dirigés et pratiques. On

y consulte également le nombre d’heures déjà effectuées ainsi que le pourcentage effectué.

Le tableau présente la trace des différentes activités pour cetenseignement. Toutes ces

informations peuvent êtres imprimées en fichier pdf en utilisant le bouton imprimer (confer

annexe pour un document type).

b) Etat de présence aux cours

Figure 11: Générer l'état de présence aux cours



La présence aux cours présente les statistiques de présence pour un enseignant

donné. Pour cela, l’utilisateur choisit simplement par le nom l’enseignant concerné et

l’ensemble d’informations sur celui-ci s’affiche. Ensuite, l’utilisateur peut décider pour un

enseignant qui intervient dans des unités d’enseignement distinctes de consulter les

présences par unité d’enseignement. Les statistiques sont disponibles et une trace sur

l’ensemble des interventionshonorées ou manquées de l’enseignant peut être consultée

dans un tableau.

L’ensemble de ces informations est imprimable vers un fichier de type pdf en utilisant

le bouton imprimer. (Nous présentons en annexe un exemple type d’un tel document).

c) Etat d’occupation des salles et des filières

Figure 12 : Générer les états d'occupation de ressources

Cette page présente un planning d’occupation des salles de cours en indiquant pour chaque

tranche horaire, l’activité qui a lieu dans la salle, la filière concernée, l’enseignant

responsable.

Dans le même tableau, il est également possible de visualiser l’emploi de temps d’une classe

donnée. Toutefois, un message s’affiche en haut du tableau pour indiquer s’il s’agit de

l’emploi de temps d’une filière ou celui d’une salle de cours, ceci en fonction du choix de

l’utilisateur.

Le bouton imprimer nous permet d’imprimer dans un fichier pdf l’ensemble de ces

informations (confère annexe).



III. LE MODULE DE SUIVI DES STAGESIII. LE MODULE DE SUIVI DES STAGESIII. LE MODULE DE SUIVI DES STAGESIII. LE MODULE DE SUIVI DES STAGES

1) Evaluation d’un encadreur

Figure 13: Fenêtre d'évaluation d'un maitre de stages

La page d’évaluation d’un encadreur permet aux usagers d’évaluer un encadreur encore

appelé maître de stage. Après avoir identifié le stage sur lequel s’appuie l’évaluation, on doit

identifier le maître de stage que l’on désire évaluer. On doit également s’identifier puis

remplir un tableau de notation en précisant pour chaque critère une note qui va de 0 à 3 en

fonction de l’appréciation de l’évaluateur. Une indication donnant un sens à chaque poids

figure en haut du tableau.

2) Evaluer un service

Le principe est le même que lorsqu’on évalue un encadreur, c’est simplement les critères

d’évaluation qui changent.

3) Evaluer un étudiant

Compte tenu de la diversité des critères d’évaluation d’un étudiant pendant le stage, ce

sous-module n’est pas encore entièrement fonctionnel. Le principe ne sera pas très distinct



des cas précédents sauf qu’ici, il faudra organiser les critères d’évaluation en fonction de

chaque département.

4) Les états

a) Etat d’évaluation d’un maître de stage

Figure 14 : Générer l'état d'évaluation d'un maître de stage

Cette fenêtre présente pour un enseignant donné, la moyenne de toutes les évaluations

portées sur cet enseignant pendant une période donnée et pour un service précis. La

moyenne calculée ici est la moyenne arithmétique. On peut également lire sur cette page le

nombre de personnes ayant évalué le maître en question.

b) Etat d’évaluation d’un service

C’est identique à l’état d’évaluation d’un maître de stage sauf qu’il porte sur un service

et présente la moyenne arithmétique des jugements portés sur ce service selon les

différents critères disponibles.

c) Etat d’évaluation d’un étudiant

C’est le récapitulatif de tous les stages effectués par l’étudiant, avec possibilité de

consulter les détails de notation de l’étudiant.



II.II.II.II. L’ADMINISTRATION L’ADMINISTRATION L’ADMINISTRATION L’ADMINISTRATION 1) Administration étendue

Figure 15 : Fenêtre d'administration étendue

Le module d’administration étendue propose les onglets stage, encadreur, stagiaire,

attribution, étudiant, enseignant, UE et classe. Chacun de ces rubriques permet

d’enregistrer, de supprimer ou de modifier les informations sur l’élément sélectionné.

Notons que dans chaque cas, l’utilisateur consulte directement le rendu de la base de

données dans un tableau.

Attribution ouvre sur une fenêtre qui permet d’attribuer un stage à un étudiant de même

qu’un encadreur pour un stage. Il n’est pas possible d’assigner un même stage à deux

étudiants distincts.



2) L’administration restreinte

Figure 16 : Fenêtre d'administration restreinte



1.1.1.1. FFFFONCTIONNEMENT DE ONCTIONNEMENT DE ONCTIONNEMENT DE ONCTIONNEMENT DE JAVA WEB STARTJAVA WEB STARTJAVA WEB STARTJAVA WEB START

Java Web Start est une technologie qui permet le déploiement d'application standard

à travers le réseau.

Développé avec la plate forme Java 2, il permet l'installation d'une application grâce

à un simple clic dans un navigateur.

Java Web Start permet la mise à jour automatique de l'application si une nouvelle

version est disponible sur le serveur et assure unemise en cache locale des

applications pour accélérer leur réutilisation ultérieure.

La sécurité des applications exécutées est assurée par l'utilisation du bac à sable

(sandbox) comme pour une applet ; dèslors, pour certaines opérations, il est

nécessaire de signer l'application.

Java Web Start utilise et implémente une API et un protocole nommé Java Network

Lauching Protocol (JPNL).

Le grand avantage de Java Web Start est qu'il est inutile de modifier une application

pour qu'elle puisse être déployéeavec cette technologie (à condition que les fichiers

contenant des ressources soient accédés en utilisant la méthodegetResource () du

class loader).

L'application doit être packagée dans un fichier jar qui sera associé sur le serveur à

un fichier particulier de lancement.L'utilisation d'une application via Java Web Start

implique la réalisation de plusieurs étapes :

• Packager l'application dans un fichier jar en le signant si nécessaire

• Créer le fichier de lancement .jnlp

• Copier les deux fichiers sur le serveur web

CHAPITRECHAPITRECHAPITRECHAPITRE : : : : DÉPLOIEMENT PARDÉPLOIEMENT PARDÉPLOIEMENT PARDÉPLOIEMENT PAR

JAVA WEB STARTJAVA WEB STARTJAVA WEB STARTJAVA WEB START



1. Package de l’application

J2EE propose une spécification pour décrire le mode d'assemblage et de

déploiement d'une application J2EE.

Une application J2EE peut regrouper différents modules : modules web, modules

EJB ... Chacun de ces modules possède son propre mode de packaging. J2EE

propose de regrouper ces différents modules dans un module unique sous la forme

d'un fichier EAR (Entreprise ARchive) au sein d’une application d’entreprise. Une

application d'entreprise permet le déploiement simultané sur un serveur

d'application, de la couche [web] et de la couche [ejb] d'une application,

respectivement dans le conteneur de servlets et dans le conteneur Ejb.

Le fichier EAR produit par une application d’entreprise est composé de :

· Un ou plusieurs modules

· Un répertoire META−INF contenant un fichier descripteur de déploiement nommé

application.xml

Pour créer une Application d’entreprise, nous procédons de la façon suivante :

• On crée un nouveau projet

• On choisit la catégorie [Enterprise]

• On choisit le type [Enterprise Application]

Un projet d'entreprise peut comprendre jusqu'à trois types de modules :un module

Ejb, un module web, un module dit client. On peut demander en même temps que la

création du projet d'entreprise, la création de ces trois modules qui seront videsau

départ.

Nous voulons déployer un module Client Swing et un module Ejb existants déjà. Il

est donc inutile de créer de nouveaux modules.

Nous créons un projet d'entreprise sans modules. Nous devons ensuite lui ajouter

ses modules Clientet ejb.

Après ces opérations, on fait le clean and build du projet d’entreprise et des fichiers

de configuration sont créés.

De même que le fichier .ear qui va être utilisé pour le déploiement.



2. Certification

La signature d'une archive est très importante, elle permet de savoir qui a fait

l'archive de manière fiable. C'est une façon de prouver qu'il s'agit bien de votre

travail. C'est une sorte de signature électronique. Elle va permettre à notreapplication

d'avoir le droit d'accéder aux fichiers systèmes, à la communication sur le réseau ...,

à l'identiqued'un programme java standard.

Le principe de la signature marche sur un cryptage clé privée/clé public. La

signature va ajouter quelques lignes dans le fichier manifest ainsi que d'autres

fichiers permettant de confirmer qu'il s'agit de vous et que l'archive n'a pas

étémodifiée après signature.

Il faut d'abord obtenir une clé privée associée à des clés publiques. Celles-ci vont

être stockées dans une petite basede données appelée « Keystores ». Chaque clé

est identifiée par un alias, généralement le nom du signataire. Unkeystore peut

contenir la signature de plusieurs personnes.

Principe

• Il faut d'abord générer un certificat :

On se place en ligne de commande dans le fichier contenant les fichiers à signer

et on exécute la commande : keytool -genkey -alias signature -keystore monStore.

Il faut alors répondre aux différentes questions (nom, prénom, société,

adresse,....). Cela génère un certificat "signature'qui est stocké dans un dépôt

"monStore".

• Ensuite pour signer le jar, on utilise la commande suivante :

jarsigner -keystore monStore -signedjar sMonJar.jar monJar.jar signature.

Cela génère le jar "sMonJar.jar" qui est la version signée avec le certificat "signature"

du jar "monJar.jar".

3. Le fichier JNPL

Ce fichier au format XML permet de décrire l'application.

La racine de ce document XML est composée du tag <jnpl>. Son attribut codebase

permet de préciser l'url ou sont stockés les fichiers précisés dans le document via

l'attribut href.



Le tag <information> permet de fournir des précisions qui seront utilisées par

le gestionnaire d'application sur le poste client. Ce tag possède plusieurs nœuds

enfants :

- Le nœud<Title> donne le nom de l'application

- Le nœud <Vendor> précise le nom de l'auteur de l'application

- Le nœud <Homepage>précise une page HTML qui contient des informations

sur l'application grâce à son attribut href.

- Le nœud <Description> donne une description de l'application. Il estpossible

de préciser plusieurs types de description grâce à l'attribut kind. Les valeurs

possibles sont : one−line, short et tooltip. Pour utiliser plusieurs descriptions, il

faut utiliser plusieurs tags Description avec l'attribut kind adéquat.

- Le nœud < Offline−allowed> : ce tag précise que l'application peut être

exécutée dans un mode déconnecté. L'avantage de ne paspréciser ce tag et

de s'assurer que la dernière version de l'application est toujours utilisée mais

ellenécessite obligatoirement une connexion pour toute exécution.

- Le nœud <Icon> permet de préciser une URL vers une image de 64 x 64

pixels au format gif ou JPEG grâce àl'attribut href.

Le tag <security> permet de préciser des informations concernant la sécurité.

- Le nœud <All−permissions> indique que l'application a besoin de tous les

droits pour s'exécuter. L'application doit alors être obligatoirement signée. Si

ce tag n'est pas précisé alors l'application s'exécute dans le bac à sable et

possède les mêmes restrictions qu'une applet au niveau de la sécurité

Le tag <resources> permet de préciser des informations sur les ressources

utilisées par l'application. L'attribut os permet de préciser des paramètres pour un

système d'exploitation particulier.

- Le nœud <J2se>permet de préciser les JRE qui peuvent être utilisés par

l'application. Les valeurs utilisables par l'attributversion sont 1.2, 1.3 et 1.4. Il

est possible de préciser un numéro de version particulier ou d'utiliser

lecaractère * pour préciser n'importe quel numéro de release. L'ordre des

différentes valeurs fournies estimportant.

- Le nœud <Jar>permet de préciser un fichier .jar qui est utilisé par l'application.

- Le nœud <Nativelib> permet de préciser une bibliothèque utilisée par

l'application qui contient du code natif.



- Le nœud <Property> permet de préciser une propriété système qui sera

utilisable par l'application. L'attribut name permet de préciser le nom de la

propriété et l'attribut value permet de préciser sa valeur.

Le tag <application−desc> permet de préciser la classe qui contient la méthode

main () grâce à son attribut main−class.

- Le nœud <Argument> permet de préciser des arguments à l'application tel

qu'il pourrait être fourni sur une ligne de commande.

4. Installations et configuration du serveur d’application

a. Installation du serveur Glassfish

• Etape 1 : téléchargement

Le jar du serveur glassfish est disponible sur le site

suivant :https://glassfish.dev.java.net/ en plusieurs versions. Nous avons téléchargé

glassfish-installer-v2.1-b60e-windows.jar.

• Etape 2 : Création du répertoire d’installations

Créer un répertoire d’installation et y placer le fichier .jar téléchargé à l’étape 1.

• Lancement de l’installation du serveur glassfish.

Lancez un ’Invite de commande’ et se déplacer jusqu’au répertoire de dépôt du

fichier téléchargé puis, lancer la commande : java -Xmx256m -jar glassfish-installer-

v2.1-b60e-windows.jar

Lire la licence jusqu’au bout en utilisant le scrolling vertical. Ce n’est qu’à la fin de la

lecture que le bouton ‘accept’ devient actif, accepter la licence en cliquant dessus.

L’installation démarre.



Figure 17 : Lancement de l'installation du serveur d'application Glassfish

Figure 18 : Indicatif d’une fin réussie de l'installation du serveur d'application Glassfish

Une fois l’installation terminée, un répertoire ’glassfish’ est disponible. Il vous permettra de

construire Glassfish.

• Construction de glassfish

Avant d’exécuter cette partie, il faut s’assurer que le chemin du jdk figure dans la

liste des variables d’environnement sous le nom de JAVA_HOME. Sinon créer une

variable d’environnement sous ce nom qui indique le chemin du jdk installé.

Attention : le chemin s’arrête au répertoire jdk et non celui du bin comme nous en

avons l’habitude.



Se déplacer dans le répertoire glassfish et exécuter la commande

suivante :lib\ant\bin\ant -f setup.xml . Cela lance la construction (BUILD) du serveur

Glassfish.

L’installeur de Glassfish se met à l’œuvre et indique le ’BUILD SUCCESSFULL’.

Figure 19 : Construction et la création d'un domaine pour le serveur Glassfish

Glassfish est désormais correctement installé. Reste à le démarrer et à le configurer.

• Démarrage de glassfish

Toujours dans l’invite de commande et dans le répertoire glassfish, lancez la

commande : bin\asadmin.bat start-domain domain1

Figure 20 : capture d'écran indiquant le démarrage du serveur Glassfish



b) Configuration du serveur glassfish

Accédez à l’interface d’administration avec votre navigateur à l’adresse : http://localhost:4848

Figure 21 : Connexion à travers un navigateur à la fenêtre de configuration de Glassfish



Entrez les login/pwd par défaut : admin/adminadmin . L’interface d’administration s’affiche alors

Figure 22 : Présentation du menu de configuration de Glassfish

c) Exploitation de l’arborescence du serveur Glassfish

Figure 23 : Présentation de l'arborescence de Glassfish

Pour déployer une application sous la forme d'un fichier ear, il suffit de copier le fichier dans le sous répertoire glassfish\domains\domains\autodeploy et l’application est automatiquement déployée dès le démarrage du serveur.



CONCLUSIONCONCLUSIONCONCLUSIONCONCLUSION

Après les travaux d’analyse et de conception effectués par nos prédécesseurs, il était

question pour nous durant ce stage d’implémenter la solution proposée et de la mettre à la

disposition des utilisateurs. Pour cela, nous nous sommes imprégnés du contexte et du

contenu du projet à travers des multiples prises de contact avec des responsables de projet.

Ce qui nous a conduits à la détection et à la correction de quelques imperfections qui ont

accompagné les travaux de conception. Cela a donné lieu à une adaptation du diagramme

des classes et de quelques diagrammes de séquences. Nous avons ensuite exploité la

puissance génératrice pour générer la partie mécanique du programme, à savoir tout ce qui

concerne l’accès à la base de données et à la gestion de persistance rendu possible grâce à la

technique qu’offrent les EJB3.

Ces travaux ont donné lieu à un prototype qui est appelé à s’étendre et s’améliorer

avec le temps. Ce fut également pour nous une expérience enrichissante, une occasion

d’expérimenter les connaissances théoriques que nous avions abordées en classe dans un

projet pratique.



BIBLIOGRAPHIEBIBLIOGRAPHIEBIBLIOGRAPHIEBIBLIOGRAPHIE

Memoire pre ingenieur Nganmeni Zephirinnganmeni.g.n.f.unblog.fr/files/2013/02/memoire_pre... · JPA...

Documents

Transcript of Memoire pre ingenieur Nganmeni Zephirinnganmeni.g.n.f.unblog.fr/files/2013/02/memoire_pre... · JPA...