Rapport

Université de Bretagne occidentale Brest Business School
UFR Science et techniques 2, avenue de Provence

MASTER 2 SYSTEMES INFORMATIQUES 29200 Brest.
COMPLEXES
20, avenue Le Gorgeu C.S. 93837
29238 BREST Cedex 3
Migration de L’ERP de l’école BBS
RAPPORT DE STAGE MASTER 2 SIAM UBO

25 mars 2016
Fait par la stagiaire : Melle Karima AIT ARKOUB
Encadrement par : Mr. Laurent GORRY & Mr. Guillou GOULVEN
Remerciements
Je souhaite remercier toute l’équipe BBS « Brest Business School » qui m’a suivi et encadré
tout au long de mon stage. Toute cette attention portée vers moi a rendu mon stage
motivant. Je remercie particulièrement Mr. Laurent GORRY mon encadrant qui m’a
accompagné tout au long de cette expérience professionnelle et qui m’a toujours été de bon
conseil, et Je n'oublie pas, Mr. Erwan LANCHEC, le responsable des systèmes
d’informations du campus, de m’avoir pris comme stagiaire.
Je tiens également à remercier tous les enseignants de l’UBO qui m’ont toujours soutenu
et particulièrement responsable de la formation Mr. Guillou Goulven qui m’a aussi suivi,
soutenu sur différents points, J’aimerais également remercier le responsable des stages Mr.
Jean- Philippe Babau qui m’a soutenu durant ma recherche de stage.
Enfin, j’adresse aussi mes remerciements les plus chaleureux à mes amis qui ont toujours
été là pour moi au cours de cette année.
1
Table des matières
I. GLOSSAIRE .............................................................................................................. 3
II. INTRODUCTION ........................................................................................................ 4
1. RESUME : ............................................................................................................. 4
2. ABSTRACT ............................................................................................................ 5
III. PRESENTATION BBS .................................................................................................... 6
A. STRUCTURE ENTERPRISE BBS « BREST BUSINESS SCHOOL » .................................................. 6
1. HISTOIRE.......................................................................................................... 6
2. SECTEUR D’ACTIVITE ............................................................................................ 6
B. CONTEXTE ENTREPRISE............................................................................................ 7
IV. LE STAGE ............................................................................................................. 8
1. DESCRIPTION SUJET DE STAGE ................................................................................. 8
2. PRISE DE CONNAISSANCE DE SUJET ............................................................................ 8
V. ENVIRONNEMENT DU TRAVAIL ....................................................................................... 10
A. ARCHITECTURE GENERALE ...................................................................................... 10
1. INFRASTRUCTURE INFORMATIQUE .......................................................................... 10
2. ARCHITECTURE APPLICATIVE ................................................................................ 10
VI. TRAVAIL REALISE .................................................................................................. 20
1. TACHE 1 : INTERFACE CONSULTATION DE MODULES (SYLLABUS) .................................... 21
2. TACHE 2 : INTERFACE DE RUBRIQUES QUESTIONNAIRES ................................................. 26
3. TACHE 3 : INTERFACE DE GESTION DE RUBRIQUES ....................................................... 31
4. TACHE 4 : INTERFACES DE SAISIE SYLLABUS................................................................ 35
VII. BILAN DU STAGE .................................................................................................. 59
1. DIFFICULTES RENCONTREES ................................................................................. 59
2. EXPERIENCES PROFESSIONNELLES ACQUISES ............................................................... 59
VIII. CONCLUSION ...................................................................................................... 60
IX. ANNEXES .............................................................................................................. 61
X. RESSOURCES DOCUMENTAIRES..................................................................................... 63
2
I. Glossaire
BBS: Brest Business School
ESC : Ecole Supérieure de Commerce
ESCAE : Ecole Supérieure de Commerce et d’administration des entreprises
MCD : Modèle conceptuel de Données
HTML : HyperText Markup Language / Langage de balisage
ASP : Active server page / page serveur actif
CLI : Common Language Infrastructure
CLR : Common Language Runtime
ORM: Object-relational mapping / Mapping objet relationnel
LINQ: Language-Integrated Query / Requête intégrée au langage
SQL: Structed Query Language / langage de requête structurée
EF : Entity Framework
XML: Extensible Markup Language / Langage à balises extensibles
HTTP: HyperText Transfer Protocol / Protocole de transfert hypertexte
IIS : Internet Information Service / Service d’information d’internet

3
II. Introduction
1. Résumé :
Le travail présenté dans le rapport a été effectué dans le cadre d’un stage de fin
d’études chez BBS. L’objectif de stage est de migrer de L’ERP de l’école BBS sous
l’outil Visual Studio 2013, un environnement de développement intégré, facilite
les tâches de création, débogage et déploiement d’applications pour Windows,
par exemple le Web.
La première phase de mon stage a été consacrée à apprendre la programmation
en c#, ensuite l'étude et l’analyse de l'application et de ses concepts métiers, ainsi
que .NET Framework utilisé qui m’a permis de créer des applications pour une
plate-forme Microsoft donné.
La seconde phase a été consacrée pour l'aspect technique, d’où de migrer
quelques applications et perfectionner leurs fonctionnalités d’une part, et de
développer des nouvelles sur deux projets :
 Etudiant(Etud) qui est dédié à un site intranet étudiant
 Administrateur(Admin) qui est dédié à un site intranet pour les personnels.
L’objectif était d’assurer un bon résultat et répondre aux besoins. Tout au long de
ce rapport, je vais vous présenter en détail le déroulement de mon stage. Dans la
première partie, je vais introduire brièvement BBS et le contexte du projet. Suite
à cela, dans la seconde partie, nous verrons plus particulièrement les objectifs qui
m’ont été confiés. J’ai eu l’opportunité de travailler sur deux écrans de l’outil, le
premier écran dédié pour écrire le programme et l’autre pour afficher l’exécution
de l’application. Enfin, j’aborderai les perspectives et le bilan du travail réalisé
pour aboutir à une conclusion sur ces six mois de stage.
4
2. Abstract
The work presented in the report was conducted as part of an internship

graduation at BBS. The aim of course is to migrate to ERP of BBS School under the
Visual Studio 2013 tool, an integrated development environment facilitates
creation tasks, debugging and deploying applications for Windows, such as Web.
The first phase of my training was dedicated to learn programming in C #, then

the study and analysis of the application and its business concepts and .NET
Framework used that allowed me to create applications for given a Microsoft
platform.
The second phase was devoted to the technical aspect, which migrate some
applications and improve their capabilities on the one hand, and to develop new
projects on two:
 Student (Etud) which is dedicated to a student intranet
 Administrator (Admin) which is dedicated to an intranet site for staff.
The objective was to ensure a good result and needs. Throughout this report, I
will present in detail the course of my internship. In the first part, I will briefly
introduce BBS and context of the project. Following this, in the second part, we
will see more particularly the objectives entrusted to me. I had the opportunity
to work on both screens of the tool, the first dedicated screen to write the
program and the other to show the execution of the application. Finally, I will
address the outlook and the balance sheet of the work to reach a conclusion on
these six-month internship.
5
III. Présentation BBS
A. Structure Enterprise BBS « Brest Business School »
1. Histoire
Fondé en 1962, Brest Business School fut d’abord ESCAE Brest, puis ESC Bretagne
et ESC Bretagne Brest avant de fusionner avec quatre autres grandes écoles pour
former France Business School en 2012. BBS a su conserver le meilleur de chaque
étape de sa vie notamment, des valeurs instructives et une volonté d’innovation
pédagogique.
2. Secteur d’activité
BBS propose, aujourd’hui, une gamme de programmes innovants,
professionnalisant et internationaux à partir du BAC jusqu’à BAC + 5 pour
répondre aux défis majeurs de notre société. Leurs programmes intègrent les
cultures économiques, sociétales, technologiques, les dimensions de créativité,
d’innovation et d’entrepreneuriat.
En tant qu’établissement d’enseignement supérieur et de recherche en
management des organisations, forte d’un corps professoral de 30 professeurs
permanents, d’un centre de recherche et d’un incubateur, l’école met en place
une stratégie de recherche pour accompagner les entreprises dans leurs projets
de développement.
Programmes
Bac +3 : Bachelor en International Management (Brest) et Bachelor en

Développement Commercial (Vannes)
Bac +5 : Programme Grande Ecole fBS (Master 2) et Master en
International Business
Bac +6 : Exécutive Mastères Spécialisés (Contrôle de gestion et pilotage
de la performance / Gestion patrimoniale et financière / manager de la
supply chain)
L'école accompagne également toutes les entreprises dans leurs projets de

formations des cadres et dirigeants : - formations sur mesure - Exécutive Master
(le programme grande école en version formation continue) - le dispositif de
Validation des Acquis de l'Expérience (VAE)
6
 Les chiffres clés
Figure 1 : les chiffres clés de BBS
B. Contexte Entreprise
« Brest Business School » accueille des étudiants, mais aussi des stagiaires.
De ce fait, la décision de faire migrer ERP de BBS sous une nouvelle technologie
était majeure. Pour ce faire, le responsable du service informatique a décidé de
proposer cette offre au sein de département informatique UBO, afin de terminer
les fonctionnalités du site internet de l’ENT (Espace Numérique de Travail).
L’école de commerce ayant des partenaires internationaux, le site web doit être
fait de manière multi langue. La langue internationale étant l’anglais, elle est la
seule disponible en dehors du français.
7
IV. Le Stage
1. Description sujet de stage
BBS est une école de commerce dont la mission est de former des experts dans
le domaine du management et du commerce. Elle accueille 900 étudiants chaque
année. Le recrutement se fait de BAC à BAC+5. Elle propose également plusieurs
programmes en formation continue. Dans cette optique, il est d’une nécessité
capitale et majeure de mettre en place un site intranet pour son personnel et ses
étudiants, afin que ceux-là puissent bénéficier d’un espace personnel dédié pour
la gestion de leurs cursus scolaire.
2. Prise de connaissance de sujet
L’entretien avec mon maître de stage était axé sur la prise en charge de la refonte
d’un portail intranet pour les étudiants et les personnels.
J’ai pu comprendre que je serai impliquée dans le développement web (orienté
objet) et base de données. Les projets à réaliser seront basés sur les technologies
suivantes : ASP.NET Web Forms pour la couche locale/web (front office) et C#
pour la couche métier (back office).
A noter que l’ancienne application a été développée depuis 2003, mais la

technologie utilisée à l’époque est aujourd’hui obsolète. C’est dans cette
perspective que nous sommes engagés pour mettre en place les interfaces de la
nouvelle application qui sera compatible avec tous les navigateurs. L’application
développée visait d’une part les utilisateurs du référentiel français, mais aussi des
utilisateurs d’autres sociétés et des étrangers qui ne sont pas français.
L’application a donc dû être traduite en anglais. La figure ci-dessous (figure III.1)
nous montre l’ancien intranet de BBS qui ne sollicite pas une version « Anglais »
pour par exemple lors de s’authentifier. La figure ci-dessous (figure 2) après
l’authentification.
8
Figure 2 : Vieux intranet de BBS (Authentification)
Figure 3 : Vieux intranet de BBS (Après l’authentification)
9
V. Environnement du travail
A. Architecture générale
1. Infrastructure informatique
Par l’intermédiaire de son navigateur internet, l’utilisateur accédera aux
ressources dont il a besoin en se connectant avec son login et son mot de passe.
Ainsi, chaque action sur l’interface utilisateur déclenchera des traitements
complexes (accès à divers serveurs, accès aux Base de données). Ceux-ci seront
invisibles pour l’utilisateur. Il recevra uniquement la réponse au besoin formulé.
L’architecture globale est composée d’un serveur SQL, qui communique avec un
serveur IIS et enfin, d’un Active Directory. Les rôles de tous ces serveurs seront
détaillés ci-après.
Le serveur web
C’est un serveur applicatif Microsoft IIS Windows 8. A l’aide du langage ASP.NET,
il permet de construire dynamiquement des pages HTML qui seront transmises
aux postes clients. Il assure de nombreuses tâches même si la prise en charge du
protocole http reste son activité principale. Le protocole http repose sur un
mécanisme de questions et de réponses entre le navigateur de l’utilisateur et le
serveur. La réponse du serveur est composée d’un en-tête et d’un corps séparé
par une ligne vide. L’en-tête donne le code d’erreur (200 pas d’erreur), la taille
du corps est de 70 octets avec un format de sortie text/html.
Le serveur SQL
Le serveur SQL (version 2005) est utilisé pour stocker des données au niveau
local. Il permet entre autres de sauvegarder le contexte des pages ASPX. Ce
stockage se fait dans une base de données SQL Server.
2. Architecture applicative
Framework.Net et Visual Studio Ultimate 2013

Mes précédents stages et travaux avaient été multiplateformes, j’avais travaillé
sur des environnements Linux comme sur des environnements Windows.
Durant ce stage de fin d’études, j’ai découvert la plateforme Visual Studio au
travers du Framework .NET 4.5
10
Visual studio est beaucoup plus un environnement de développement : des plug-
ins viennent s’ajouter afin d’ajouter de nouvelles fonctionnalités. On trouve par
exemple le Team Suite qui permet de travailler en collaboration sur un projet.
Framework .Net est une plateforme de développement et d’exécution créée par
Microsoft destinée au développement de tout type d’applications :
 Applications Windows : application client/serveur (Win Form/WPF), service
windows
 Applications mobiles
 Applications Web (ASP.NET), services web (c’est le type d’application du
notre projet)
Le Framework est indépendant du langage utilisé pourvu que celui-ci réponde à
la CLS (Common Language Specification). La CLS décrit les règles à suivre pour que
le langage soit compatible avec le Framework .Net. La plateforme est
principalement constituée :
 d’une bibliothèque de classe (Base Class Library) qui comprend un grand
nombre de fonctions communes telles que la lecture et l’écriture,
l’interface utilisateur, l’accès aux données, la connexion à une base de
données, etc. La bibliothèque est exploitable par tous les langages
compatibles
 d’une définition commune des types de bases (CTS : Common Type System,
CLS : Common Language Specification)
 d’une machine virtuelle (CLR : Common Language Runtime).
L’environnement de développement utilisé pour la réalisation du projet est
Microsoft Visual Studio 2013, Framework.Net 4.5
A titre d’illustratif conférez-vous à la figure 4 ci-dessous.

11
Figure 4 : Framework.NET 4.5
C#, LINQ, SQL et Entity Framework 4.5
Mappage de la base de données SQL Server en classes objets
 Langage C#
Le C# est un langage de programmation orientée objet crée en 2002 par

Microsoft. Il a été créé afin que la plateforme .Net possède un langage permettant
d’exploiter toutes ces capacités. Au niveau de la syntaxe, le C# se rapproche
beaucoup du Java. En tant que langage orienté objet, le C# prend en charge les
concepts d’héritage, d’encapsulation et de polymorphisme. Les variables et
méthodes sont encapsulées dans des définitions de classes. Une classe peut
hériter d’une seule autre classe parente et peut implémenter plusieurs interfaces.
La compilation d’un code en C# ne donne pas un code binaire utilisable par la
machine directement, contrairement au C ou C++. Le code C# est transformé en
code intermédiaire (CIL). Ce code n’est pas exécutable par la machine vu qu’elle
ne comprend que le binaire. Le code CIL correspondant au programme que l’on
veut distribuer. Sous Windows, ça prend l’apparence d’un .exe. Lorsqu’on exécute
un programme CIL, il est lu par la machine virtuelle (CLR) qui compile en le code
en un vrai programme machine codé en binaire et exécutable par la machine. La
CLR vérifie également la sécurité du code. Le code C# est donc exécuté sous le
contrôle de la machine virtuelle. On parle de code managé.
J’ai travaillé sur une application C#. Ce langage a l’avantage de m’être familier, la
syntaxe ressemble au Java, mais va au-delà de son parent : le C# reprend les
12
atouts des autres langages plus anciens mais développe aussi des notions
nouvelles telles que le « binding », le tout associé à Visual Studio et fusionnant de
raccourcis afin d’accélérer le travail du développeur.
 LINQ
C’est un ensemble de fonctionnalités introduites dans Visual studio qui étend les
fonctions de requêtes puissantes à la syntaxe des langages C# et Visual Basic. Il
exige que les données soient encapsulées dans des objets. Le retour de la requête
est renvoyé sous forme d’une collection d’objets en mémoire qui peut être
énumérée.
LINQ propose des modèles simples d’apprentissage proche de SQL pour
l’interrogation et la mise à jour des données de types sources et de format divers.
Presque tout au long de ce projet LINQ a été utilisé quand il s’agit de
communiquer avec la base de données. Voir par exemple annexe I pour la mise
en œuvre de LINQ.
 DataSet
L’objet Data est une représentation de données résidente en mémoire qui

propose un modèle de programmation relationnel cohérent, quelle que soit la
source des données qu’il contient. Son domaine de travail est toujours en mode
non connecté.
Un objet DataSet représente un jeu de données complet, y compris les tables qui
contiennent et organisent les données et y appliquent des contraintes, ainsi que
les relations entre les tables. L'utilisation d'un objet DataSet peut se faire via
différentes méthodes qui peuvent être appliquées indépendamment les unes des
autres ou combinées. Grace à ces méthodes on peut créer par programmation un
objet DataTable, DataRelation et Constraint dans un objet DataSet, puis remplir
les tables de données.
Remplir l'objet DataSet de tables de données provenant d'une source de données
relationnelles existante à l'aide d'un objet DataAdapter.
13
 DataReader
DataReader est un outil avec lequel on peut extraire de données, ce qui implique
la création d’une instance de l’objet Command, puis la création d’un Reader en
appelant Command.ExecuteReader pour extraire des lignes d'une source de
données. Son utilisation est toujours en mode connecté contrairement au
DataSet.
 SQL
C’est un langage standard qui permet de communiquer avec une base de
données. Avec des fonctions déjà faites, SQL donne aussi la possibilité d’effectuer
des traitements complexes sur des données.
 Entity Framework
C’est un mappeur objet/relationnel qui permet aux développeurs .NET d'utiliser
des données relationnelles à l'aide d'objets spécifiques au domaine (ci-dessous
figure 5)
Figure 5 : Entity Framework
14
 Consultation et insertion de données dans la base
LINQ exige que les données soient mappées dans le domaine correspondant si
elles ne sont pas stockées nativement en tant qu’objets.
Donc l’obligation de créer des classes s’imposent pour le mappage des données,
afin de les utiliser en fonction de nos besoins.
Par conséquent, l’utilisation de Entity Framework est nécessaire pour convertir

les tables de la base de données en classes objets. Cet outil permet d’interagir
avec une source de données de type base de données, en manipulant des objets
directement (sans avoir à écrire du code SQL) grâce à un langage de « requetage
» propre au Net Framework qui est LINQ.
Il est utilisé dans trois scénarios :
Premièrement : Base de données existante.
Deuxièmement : si nous voulons nous concentrer sur nos classes de domaine,
puis créer la base de données de nos classes de domaine.
Troisièmement : Si nous souhaitons concevoir notre schéma de base de données
sur le concepteur visuel, puis créer la base de données et les classes.
Ces 3 modes permettant de générer cette couche d’accès aux données sont
détaillés ci-après:
 Mode EF Database First

Dans ce mode, nous utilisons EF pour nous générer des classes à partir d’une base
de données existante. EF va nous générer via un assistant dans Visual Studio, des
classes correspondantes à nos tables de base de données et un « contexte » qui
est la version « objet » de la base de données elle-même.
 Mode EF Model First

Visual Studio (à partir de VS 2010) d’un outil graphique de modélisation de classes
qui permettra à EF de générer la base de données correspondante (de façon
presque invisible) d’un côté et de nous donner accès au « contexte » et « entités
» de l’autre.
 Mode Code First
Le Mode Code First est le plus intéressant pour nous autres développeurs, car il
nous permet de simplement générer la base de données à partir de nos classes
POCO (des classes toutes simples composées Propriétés).
15
ASP .NET
ASP.Net est un ensemble de technologies créé par Microsoft que les

développeurs peuvent utiliser pour créer des applications Web, des sites Web
dynamiques ou des services Web XML. ASP.Net fait partie de la plateforme .Net.
ASP.Net est basé sur le CLR qui est commun à tous les langages de programmation
compatibles avec le Framework .Net. Ainsi les développeurs peuvent écrire du
code ASP.Net avec n’importe lequel de ces langages, généralement C#,
VisualBasic.Net, JScript.Net mais également des langages indépendants de
Microsoft tel que Python. Les pages ASP.Net constituant l’application sont
exécuté via le Framework .Net et le serveur web IIS.
ASP .NET MVC
Modèle Mise à jour Contrôleur

Lance l’appel au
Stocke les Serveur,
données Récupère les données
Récupère
Notifie, Mis Fait un

à jour appel
Vue
Voit
Figure 6 : MVC
ASP.Net MVC, comme son nom l’indique, implémente en plus l’architecture

Modèle-Vue-Contrôleur. Pour mettre en œuvre le modèle MVC, Microsoft a
16
ajouté un nouvel espace de noms dans le Framework .Net. Il contient toutes les
classes et interfaces permettant de mettre en œuvre l’architecture : classes de
base pour les contrôleurs, classes pour les vues, classes désignant les actions
permettant de créer des liaisons de données entre la vue et le modèle.
Modèle il décrit les données utilisées. C’est

lui qui va interagir avec la base de
données, permettre des mises à
jour, etc.
La vue c’est ce avec quoi l’utilisateur va

interagir. Le but est de représenter
les données que le modèle a
renvoyées et de recevoir les actions
de l’utilisateur (appui sur un bouton,
la saisie d’un texte, sélection d’un
élément, etc.). Ces événements sont
envoyés au contrôleur. La vue ne
fait aucun traitement, elle se
contente d’afficher les résultats et
d’interagir avec l’utilisateur.
Le contrôleur il pilote l’application. Il prend en
charge la gestion des événements
pour mettre à jour la vue ou le
modèle. Il reçoit les interactions de
l’utilisateur et lance les actions à
effectuer. Si une action nécessite un
changement des données, le
contrôleur demande la modification
des données au modèle, et ce
dernier notifie la vue que les
données ont changée pour qu'elles

se mettent à jour. Certains
événements de l'utilisateur ne
concernent pas les données mais la
vue. Dans ce cas, le contrôleur
demande à la vue de se modifier
17
Cependant, par défaut de ressources et contrainte de temps, mon maître de
stage, le développeur de BBS, a pris la décision de concevoir l’application avec
ASP .NET WebForms.
Pour simplifier les tâches à réaliser, ASP .NET WebForms ajoute une couche
d'abstraction permettant de masquer la complexité du travail ainsi que toutes les
spécificités de la programmation d'applications Web.
L’ASP.NET WebForms
Au premier abord, l’ASP.NET semble être un langage informatif comme l’HTML

avec quelques balises spéciales comme du PHP. Or ce n’est pas du tout le cas. En
effet, l’ASP.NET a une relation très poussée avec ce que l’on appelle du « code-
behind » : le traitement effectué lors de l’appel d’un contrôle (le clic sur un
bouton) va par exemple appeler une fonction « code-behind » codée en C#.
Grâce à la technologie ASP.NET, le développement WEB est très proche du
développement d’application lourd, on appelle d’ailleurs les projets ASP.NET des
projets WebForm alors que les logiciels lourds sont appelés WinForm. De plus,
l’architecture générale est la même.
 Cycle de vie d’une page ASP .NET WebForms
Lorsqu’une page ASP.NET s’exécute, les différentes phases de son évaluation

constituent son cycle de vie. Celles-ci sont l’initialisation, l’instanciation des
contrôles, la restauration et le maintien de l’état, l’exécution du code relatif à la
gestion des évènements et enfin, le rendu. Ceci permet de savoir exactement, où
placer le code pour que celui-ci fonctionne correctement. Migration de L’ERP de l’école BBS
18
 Les contrôleurs de la boite à outils
GridView Affiche les valeurs d’une source de données

dans une table ou chaque colonne
représente un champ et chaque ligne
représente un enregistrement. Le contrôle
GridView permet de sélectionner, trier et
modifier ces éléments.
DropDownList Représente un contrôle qui permet à
l’utilisateur de sélectionner un seul élément
dans une liste déroulante.
LinkButton Boutons ayant l’apparence d’un lien
Label, Textbox, button, checkbox, Radio Contrôles basiques
Button
Literal Un peu comme un label, mais non
interprété
Hyperlink Lien hypertexte (diffèrent de LinkButton)
UpdatePanel Permet la restitution partielle de sections
d’une page sans publication (postback)
Repeater Composant de bas niveau destiné à créer
des présentations entièrement
personnalisées.
RequiredFieldValidator Convertit le contrôle d’entrée associé en
champ obligatoire
A noter que ces contrôles possèdent tous un identifiant unique ID, et un attribut
runat= « server » qui indique au framework ASP .NET que le balise en question
comporte un fonctionnement serveur. Il peut y avoir aussi des événements par
attributs.
Par exemple : prenons le contrôleur Button, il possède un attribut OnClick qui
appelle une méthode à chaque fois que le bouton est cliqué. Ainsi, le développeur
indique dans cette méthode les traitements à effectuer pour cet événement.
19
VI. Travail réalisé
Ce stage m’a permis de travailler sur différents métier au sein de l’école BBS. J’ai
commencé par une partie d’étude sur les différents logiciels à utiliser, Je ne
connaissais pas le développement sur asp.Net, C# et l’utilisation de SQL Server,
mes premiers jours de stage ont été dédiées à mon auto-formation dans ces
langages.
L’expert technique, Mr. Laurent GORRY, m’a fourni un document intéressant me
permettant d’assimiler les notions de base de l’Asp.Net. Le suivi des tutoriaux et
le développement de mini-projets m’ont permis de me familiariser avec les
langages. Aussi le travail sur le code m’a permet de comprendre la logique qui
avait été adoptée pour coder.
Maintenant que les technologies utilisées côté client et côté serveur pour le
développement des interfaces ont été présentées, je vais définir en détails
l’architecture MVC ci-après, qui est adopté tout au long du développement.
Application
Bien que l’objectif principal d’une application soit de répondre au besoin exprimé
par le client, dans notre cas le client est soit l’étudiant, Professeur ou
Administrateur, il est également nécessaire que l’application remplisse d’autres
critères tels que :
 avoir une interface homme-machine (IHM) intuitive
 avoir des temps de réponses satisfaisants
 gérer la validité des saisies de l’utilisateur
 gérer de façon claire les erreurs éventuelles
20
1. Tache 1 : Interface consultation de modules
(Syllabus)
Description de la mission
Cette mission était de mettre en place toutes les interfaces nécessaires afin que,
l’application réponde au besoin des utilisateurs. L’objectif de mon premier projet
est de faire une prise en main de L’ASP.Net et de la base de données, puis passer
à l’étape de développement de l’interface qui permet aux étudiants de consulter
les modules selon le niveau, la session, l’année et le délai du leurs parcours. Dans
ce qui suit, je vais décrire étape par étape les différentes phases de mon travail
relatif à ce projet.
Etude de la tâche
Cette tâche n’existait pas dans l’ancienne version du site intranet, cette interface
est nouvelle, simple et répond aux besoins des étudiants. L’interface est conçue
avec deux éléments dont le rôle de chacun sera décrit ci-dessous :
 Le DropDownList
Il permet dans cette interface d’afficher la liste des parcours effectués par
l’apprenant depuis son entrée à l’école de commerce.
 Le GridView
Il a pour rôle, ici, d’afficher les modules et les codes de chaque module suivi par
l’apprenant par rapport à son parcours.
Mise en place des données

Le tout premier travail consistait à mettre en place un MCD pour les tables, après
l’acquisition de cette information vient l’étape qui consiste à accéder aux données
et enfin, leur exploitation. J’ai suivi cette logique qui m’a permis d’avoir le MCD
ci-dessous (Figure 7)
21
Figure 7 : MCD de l’interface de consultation des modules par parcours
Nous observons que toutes les tables représentées sont utilisées. Il faut
maintenant mettre en œuvre ce modèle de conception de données pour la
récupération des données. C’est l’objectif de la partie qui suit.
Récupération des données
La première action que j’ai effectuée est de m’occuper du parcours de

l’apprenant. Vu que, ce dernier est un utilisateur alors, la clé de celui-ci
« CleApprenant » est utilisée pour récupérer l’Intitulé, la date de début et la date
de fin du parcours dans la table PlanFormation de même que la clé du parcours
« ClePlanFormation » dans la table Parcours.
Ensuite, il faut récupérer toutes les informations qui sont en relation avec les
modules de l’apprenant. Dans cette situation plusieurs tables entrent en jeu, c'est
pourquoi je ferai un résumé de la technique utilisée dans la partie exploitation
des résultats.
Le mappage de ces données en objets a nécessité la création d’une classe qui

contient tous les attributs utiles des tables du MCD avant l’utilisation de LINQ
pour écrire mes requêtes, afin de récupérer les données et les exploiter.
Aussi le mappage de ces données en objets a nécessité de créer un DataSet afin
d’utiliser la procédure stockée « SGCP_GetModulesByPlanFormationUtilSyllabus »
22
Exploitation des résultats
La première requête LINQ permet de récupérer les informations qui sont liées au
parcours de l’apprenant et de les afficher sur DropdownList.
L’utilisation de DataSet et de la procédure stockée ont permet d’avoir toutes les

informations visibles dans le GridView : Module, son code, et la colonne Lien de
celui-ci, sert à télécharger un PDF Syllabus, une norme Syllabus qui consiste à
donner un aspect pédagogique pour le module recherché.
Grace à la procédure stockée que j’ai mise en place, contenant la clé
« clePlanFormation », «cleUtilisateur» et « keyCripte », a permet d’afficher les
noms des modules avec leurs codes pour un parcours donné de l’apprenant,
Comme montre les figures ci-dessous, cette version est prête et fonctionne déjà
sur le profil Etudiant.
Figure 8 : Interface d’affichage de modules pour un parcours
23
Figure 9 : Interface d’affichage de modules pour un parcours (suite)
Figure 10 : Interface de consultation de PDF Syllabus pour module Anglais
24
Figure 11 : PDF Syllabus pour Module Anglais
Désormais tout apprenant qui se connecte sur le site peut consulter ses
modules sur tout son parcours scolaire au sein de BBS. Pour illustrer la mise en
œuvre de LINQ et procédure stockée dans ce projet, conférez-vous

respectivement à l’annexe I et l’annexe II.
25
2. Tache 2 : Interface de rubriques questionnaires
Cette mission était de développer une application qui permet aux étudiants de
consulter une ou plusieurs rubriques destinées à eux, et répondre aux questions
posées appropriée à la rubrique sélectionnée.
Le remplissage des réponses aux questions de ces rubriques est limité par une
date de fin, et si le remplissage n’a pas été fait avant cette date de limite.
L’étudiant est appelé donc impérativement à saisir les réponses avant une
dernière date limite qu’on appelle « date butoir »
Pour se faire, j’ai créé une rubrique que j’ai appelé « Rubrique pour tester » afin
d’étudier les différents types de réponses proposées par l’administrateur de BBS.
Etude de la tâche
Cette interface n’existait pas dans l’ancienne version du site intranet, cette
interface mise en place, est basée sur un système dynamique, c'est-à-dire les
questions sont dynamiques, changent de questions d’une rubrique à l’autre.
La mission serait alors de présenter une interface avec des questions simples liées
à des types différents de réponses aux besoins des étudiants. L’interface
complète et ergonomique, utilisable sur le profil « Etudiant », et elle est conçue
avec un dropdownlist et un repeater qui contient des éléments dont le rôle de
chacun est décrit ci-dessous :
 Le DropDownList
Il permet dans cette interface d’afficher la liste des rubriques qui n’ont pas été
validé par l’apprenant, cette liste de rubrique est décrit par le nom de la rubrique
concaténée par la date de début et la date de fin de validation.
26
 Le repeater
C’est un contrôle de liste lié aux données qui permet une disposition
personnalisée en appliquant de façon répétée un modèle donné à chaque
élément affiché dans la liste, parmi les éléments on trouve :
 TextBox et TextBox (mutiligne) : Il permet à la saisie d’une réponse.
 DropDownList: il a pour rôle, de lister des réponses.
 RadioButtonList : il permet de choisir une réponse.
 CheckBoxList : il permet de choisir plusieurs réponses.
Mise en place du MCD
C’était mon premier travail pour la création des tables d’un MCD, qui consistait
de créer des tables utiles sur SQL Server, et appliquer les relations entre ces
tables, pour ensuite accéder aux données. Et les tables sont les suivantes :
Table Rub_Apprenant : sert à regrouper les apprenants orientés à la saisie de la
rubrique, contient du champ valide, une façon de savoir si la rubrique est validée
ou non.
Table Rub_rubrique : regroupe tous les noms des rubriques avec leurs dates de
début, date de fin et date de butoir.
Table Rub_question : contient toutes les questions des rubriques avec leurs types
de réponses proposées.
Table Rub_TypeReponse : désigne le type de réponse à la question, par exemple
champ textbox, liste déroulante, champ textbox multiligne, checkBox, ou radio
button.
Table Rub_reponse : contient toutes les réponses des rubriques.
Table Rub_Enregistrement : contient toutes les réponses saisies ou choisis par

l’apprenant après une validation serait faite.
J’ai suivi cette logique qui m’a permis d’avoir le MCD Ci-dessous (figure 12)
27
Figure 12 : MCD de l’interface de rubriques questionnaires
Sachant qu’il peut exister plusieurs rubriques, ce qui fait que nous aurons besoin
de la clé rubrique et des requêtes LINQ, pour accéder aux questions et pour
récupérer les réponses associées à chaque question en utilisant la clé de réponse
et la clé question.
Exploitation des données
Une fois terminé l’étape de récupération des données, il faut passer à leur
manipulation. Avant d’aller plus loin, j’ai proposé une présentation de l’interface
de test pour que les explications soient plus claires. Ci-dessous, la figure 13 et
figure 14 de l’interface rubrique de test. Migration de L’ERP de l’école BBS
Figure 13 : Interface de rubriques questionnaires (choix de rubriques)
28
Figure 14 : Affichage de la rubrique test questionnaires
Désormais tout apprenant concerné pour la rubrique questionnaires, se connecte

sur le site Etudiant, et pour illustrer cela, j’ai pris comme un exemple, un
apprenant BOREL Jean, qui répond aux questionnaires de la rubrique « Vœux de
départ à l’international (du 15/01/2016 au 05/03/2016) »

Ci-dessous (figure 15) et (figure 16)
29
Figure 15 : Profile d’un apprenant
Figure 16 : Affichage de la rubrique questionnaire pour un apprenant
30
3. Tache 3 : Interface de gestion de rubriques
Comme expliqué précédemment, qu’il existe le site intranet administrateur. Dans

ce qui suit, toutes les applications que je vais décrire sont mise en œuvre sur le
profil administrateur. L’objectif principal de cette mission était de développer une
application qui reprend toutes les réponses de la rubrique questionnaires, et les
afficher sous forme d’un tableau, pour ensuite explorer ces résultats sous un
format csv.
Etude de la tâche
Cette interface n’existait pas dans l’ancienne version du site intranet, cette
application est nouvelle, elle passait d’une interface à une autre.
Pour ce faire, j’ai créé une interface qui donne une possibilité aux personnels de
BBS de voir toutes les rubriques de l’apprenant, et via un lien approprié à la
rubrique, on peut passer à une autre interface, ce dernier a le rôle de revoir toutes
les réponses des questionnaires sous une forme de tableau Gridview.
Mon maitre de stage m’avait recommandé de créer deux boutons, quand
l’utilisateur appuie sur « csv », un fichier automatiquement se télécharge en
format (.csv), ainsi que s’il appuie sur « csv simple » il recevait le fichier de même
format que le précédent, la différence se pose sur la façon d’afficher les réponses,
Dans le cas « csv » les réponses sont affichées en colonnes, par contre, dans le
cas « csv simple » les réponses sont affichées en lignes. L’interface est conçue
avec une table et des éléments dont le rôle de chacun est décrit ci-dessous :
 Le textBox : son rôle est d’inviter l’utilisateur s’il souhaite, de saisir le nom
de rubrique afin de rechercher la rubrique souhaitée.
 GridView 1: « bind », ce qu’on appelle aussi chargement des données

(dans notre cas chargement de la liste rubrique avec leurs dates), peut se
faire au moment de chargement de l’application, l’utilisateur peut aussi
saisir le nom de la rubrique, ainsi que le bind de GridView1 se fait juste pour
la rubrique choisie. Tout ce travail grâce à des requêtes LINQ que j’ai créée.
 GridView 2: Ce deuxième permet, à son tour avec la présence de la clé
31
rubrique, l’affichage des réponses pour les questions de la rubrique, ces questions
sont enseignées par l’administration de BBS. Ce travail est fait grâce à l’utilisation
de l’objet « DataTable » pour créer des colonnes et des lignes dynamiquement et
représente aussi une table de donnée en mémoire, en parallèle j’avais besoin
aussi de la requête LINQ.
Consulter l’annexe III pour avoir un aperçu d’une partie du code que j’ai mis en
place sur ce contrôle « GridView ». Les (figures 17, 18,19, 20, 21, 22) ci-dessous
montrent l’évolution de l’application.
Figure 17 : Affichage de la rubrique version1
32
Figure 20 : Affichage des réponses de la rubrique Vœux de départ à l’international

33
Figure 21 : Affichage du fichier .csv
Figure 22 : Affichage du fichier .csv version simple
34
4. Tache 4 : Interfaces de saisie Syllabus
En arrivant en phase de migration, l’objectif principal de cette mission était de

développer une interface qui sert à chercher le module, créer des rubriques de
formulaires syllabus pour les personnels de BBS. Ces formulaires doivent
permettre aux enseignants de saisir les informations générales, résumé du cours,
résumé du cours en anglais, bibliographie, sélectionner les intervenants
pressentis, évaluer le module, créer des séances.
Après la saisie de toutes les informations de module concernées à l’enseignant,
et l’enregistrement des formulaires, il est important en final de demander une
validation du formulaire.
Histoire de l’existant
L’application existait dans l’ancienne version du site intranet, était basée sur un
système de pagination, c’est-à-dire qu’après chaque validation, on passait d’une
interface à une autre. La mission était alors de se rejoindre dans une réunion afin
de changer le processus de syllabus, et se mettre d’accord sur différents points
sur la migration. Dans ce qui suit, je vais schématiser pour décrire l’ancien
processus de syllabus, de même pour le processus syllabus qui a été mis en place.
Rm : Responsable du module.
Dy : Doyen.
Resp dépt : Responsable de département.

DP : Direction des programmes.
DE : Direction d’études
35
Ancien Processus Syllabus : (la figure 23)
RM saisit module en
chantier
Envoi mail
Resp.dépt auto au
Dy ne valide pas
ne valide resp.dépt
module.
pas module
Responsable du Envoi mail au RM
département évalue pour demander
module modification
Envoi mail au
Dy pour
Resp.dépt demande de
valide et envoi validation
mail auto au DP
DP réalise feuille de route

(groupes et intervenants)
Dy évalue module
Envoi mail
aux assistants
DE
Etudes planifie les séances Envoi mail au RM pour

accord du syllabus.
Basculement du module
en chantier en module
valide
36
Nouveau Processus Syllabus qui est mis en place : (la figure 24)
RM saisit module en
chantier
Envoi mail
Resp.dépt auto au
ne valide resp.dépt
pas module
Responsable du
département évalue
module
Resp.dépt
valide et envoi
mail auto au DP
DP réalise feuille de route

(groupes et intervenants)
Envoi mail
aux assistants
DE
Etudes planifie les séances

37
Dans ce qui suit, je vais décrire étape par étape les différentes phases de mon
travail relatif à ce projet.
Etape1 : Interface Recherche Module
Cette recherche est nécessaire pour chercher le module en chantier, qui veut dire
un module qui n’a pas été validé par le responsable de département, ni par le
doyen. Aussi pour apporter des modifications du syllabus.
Le tout premier travail consistait à mettre en place un MCD pour les tables, après
l’acquisition de cette information vient l’étape qui consiste à accéder aux données
et enfin, leur exploitation. J’ai suivi cette logique qui m’a permis d’avoir le MCD
ci-dessous (figure 25).
Figure 25 : MCD de l’interface recherche module

38
Toutes ces tables représentées sont utilisées. Il faut maintenant mettre en œuvre
ce modèle de conception de données pour la récupération des données. C’est
l’objectif de la partie qui suit.
La première action que j’ai effectuée est de m’occuper de la recherche module, il

faut lister que les modules en chantier et selon l’année souhaitée, avec leurs
départements, leurs disciplines, leurs intervenants précisaient par un code.
Dans cette situation, toutes les tables du MCD entrent en jeu, notamment la clé
année dans la table « Annee » est utilisée pour récupérer tous les modules de
l’année souhaitée.
Le mappage de ses données en objets a nécessité la création d’une classe qui

contient tous les attributs utiles des tables du MCD avant l’utilisation de LINQ
pour écrire mes requêtes, afin de récupérer les données et les exploiter.
La première requête LINQ permet de récupérer les informations qui ont été
demandées d’être affichées dans le tableau GridView.
Les autres requêtes apportent plus sur l’aspect de facilité ce qu’on appelle
« Le filtrage », pour faciliter à l’utilisateur les saisies de quelques informations qui
sont disponibles dans la base de données : comme rechercher le nom du module
qui est conçue par un lien, l’intervenant et le code. Mais ce n’est tout, il m’a fallu
d’utiliser LINQ aussi pour sélectionner le département et la discipline pour
invoquer l’affichage avec celles-ci.

Comme le montre (les figure 26, 27) ci-dessous, l’interface simple, ergonome et
fonctionne déjà.
39
Figure 26 : l’interface recherche module version1
Figure 27 : l’interface recherche module version2
40
Cependant, mon maître de stage voulait une autre option « Sorting », plus
adéquate, qui peut trier les colonnes du tableau avec un tri ascendant (flèche en
bas) ou descendant (flèche en haut), seulement en double clic sur l’entête de la
colonne. Ceci est déjà mis en place dans le code. Ci-dessous la figure 28, montre
le « Sorting ».
Figure 28 : l’interface recherche module option « Sorting »
41
Interface Informations Syllabus
Comme expliqué précédemment, notre mission était d’utiliser le nom de
mudule comme un lien pour accéder à l’interface formulaires.
L’objectif de cette interface est de placer plusieurs rubriques de formulaires
dans la même page web. Pour commencer, je vais décrire chaque rubrique
étape par étape, avec son MCD qui est mis en place.
Etape2 : Informations générales

Dans cette rubrique de formulaire « Informations générales », elle a rôle et
d’enlever une bonne partie des informations inutiles, d’afficher toutes les
informations suivantes : Nom de discipline, nom du professeur, titre du module
en version française et anglaise, programme.
Par respect de la norme AACSB approprié à BBS, on avait ajouté les champs
Learning objectives et Learning goal par programme.
Mise en place des données
Un MCD mis en place pour les tables : module, discipline, et je devais créer deux
tables supplémentaires : ModuleProgSyllabus et ProgrammeSyllabus.
Après l’acquisition de cette information vient l’étape qui consiste à accéder aux
données et enfin, leur exploitation.
Pour éviter des bugs dus aux migrations, mon maitre m’a demandé d’ajouter
des valeurs dans la table module : Cletypemodule =1 et Cleuniversite =1
J’ai suivi cette logique qui m’a permis d’avoir le MCD ci-dessous (figure 29).
42
Figure 29 : MCD pour Informations générales
L’utilisation de requête LINQ a permet de récupérer les informations sur le

formulaire sur un simple clic du nom module. Comme le montre la figure 30
Figure 30 : Etape Informations générales
43
Une fois cliquer sur le lien « Edit » le tableau de figure 28 s’invite à remplir les
champs Learning goal et Learning goal en anglais, par suite faire de Update afin
de finaliser l’opération ou cancel en cas d’annulation. Comme le montre la figure
31.
Figure 31 : Etape Informations générales (suite)
44
Etape3 : Intervenants pressentis
Description
Dans cette rubrique de formulaire « Intervenants pressentis», elle a rôle d’ajouter

ou supprimer le nom du professeur à la liste des intervenants pressentis par ordre
alphabétique.
Cette rubrique reste inchangé par rapport à l’ancienne version.il n’est toutefois
pas nécessaire d’afficher discipline, département, qualifications…Seuls nom et
prénom suffisent.
Méthodes suivie et résultats obtenus
Un MCD mis en place pour les tables : « Professeur », « Utilisateur »,

« ModuleProfesseur », « Module ». C’est l’objectif de ce MCD ci-dessous (figure
32).
Figure 32 : MCD Intervenants pressentis











45
Après l’ajout ou la suppression d’un professeur ou plusieurs professeurs, la table
« ModuleProfesseur » sert à stocker la mise à jour des intervenants pressentis.
Toutefois lors de l’ajout, il faut vérifier s’il le nom n’existe pas dans la base de
donnée. Sachant que chaque intervenant a sa propre clé dans la table
« ModuleProfesseur ». Ce qui fait que j’avais besoin à des requêtes LINQ, pour
ajouter, supprimer, et enfin faire d’Update.

manipulation. Avant d’aller plus loin, une présentation de l’interface s’impose
pour que les explications soient plus claires.
Après l’acquisition de cette information vient l’étape qui consiste à accéder aux
données et enfin, leur exploitation, comme l’illustre les figures 33 et 34 ci-
dessous. L’interface d’intervenants pressentis dans le cas d’ajout de professeur.
Figure 33 : Etape Intervenants pressentis version1
46
Figure 34 : Etape Intervenants pressentis version2
47
Etape4 : Résumé cours
Description
Dans cette rubrique de formulaire « Résumé cours», elle a rôle d’afficher le

résumé du cours en français et en anglais par la suite de sauvegarder en cas de
changement ou modification.
Cette rubrique reste inchangée par rapport à l’ancienne version. Mais il n’est
toutefois pas nécessaire d’afficher les objectifs pédagogiques (en français et
anglais)…Seuls résumé du cours, et résumé du cours en anglais suffisent.
Le résumé en français et en anglais est un champ de type texte sans limiter du nb

de caractères. Ils se trouvent dans la table « Module », champs « résuméCours »
et « résuméCoursAnglais ». Un bouton est mis en place afin d’enregistrer des
changements sil y’aura lieu. J’avais besoin des requêtes LINQ pour l’affichage et
mise à jour. Ci-dessous (figure 35) de résumé cours.
Figure 35 : Etape résumé de cours
48
Etape5 : Evaluation
Description
Cette mission de cette rubrique « Evaluation» est basée sur l’évaluation d’un
examen, si l’examen est écrit ou oral, elle a rôle de désigner le type détaillé de
l’examen (Evaluation individuelle ou contrôle continu).
Etude de l’existant
Cette rubrique est partiellement changée par rapport à l’ancienne version. Un lien
link mis en place pour « Edit » au lieu d’un bouton link, de même pour « Delete »,
tous les champs sont obligatoires sauf « description ».
La mission serait alors de présenter une nouvelle interface avec ces petits
changements, simple à utiliser, ergonome, plus conviviale que celle proposée.
Méthode suivie et résultats obtenus
Ce schéma (figure 36) ci-dessous représente le MCD qui permet de réaliser le

système d’évaluation des professeurs, il contient trois tables :
« ControleModule », « TypeDetailleCC », « TypeEvaluationControleModule »
Figure 36 : MCD Etape Evaluation
49
La table « TypeDetailleCC » sert à récupérer le type détaillé de l’évaluation, la

seconde table« TypeEvaluationControleModule » sert à récupérer le type de
l’évaluation, et la troisième table « ControleModule » sert à stocker le poids en
pourcentage. Et enfin, pour enregistrer toutes les informations, le système a mis
toutes ses précautions pour que tous les champs soient remplis sauf le champ
description.
Le système doit contrôler aussi la somme des poids qui doit être à 100% mais il
ne sera pas bloquant et donc il lancera un message d’alerte pour avertir
l’utilisateur.
Par conséquent, j’avais besoin à des requêtes LINQ, pour contrôler toutes ces
informations, et une retouche pour une mise à jour.
manipulation et l’exploitation.
Le fonctionnement de l’interface est très simple, l’utilisateur se connecte, choisit
la rubrique « Evaluation », un tableau d’évaluation Gridview représenté est mis
en place notamment pour des modifications ou suppression respectivement sur
les liens boutons « Edit » et « Delete ». L’utilisateur peut à tout moment changer
le type d’évaluation, le type détaillé et son poids. Ensuite, Le lien bouton « Insert »
sert pour ajouter une nouvelle évaluation. L’interface se présentera comme
l’illustre les figures 37 et 38
Figure 37 : Etape d’évaluation version1
50
Figure 38 : Etape d’évaluation version2
51
Etape6 : Séances
Description
Cette mission de cette rubrique « Séances» est basée sur création des séances
par type de public : Régulier Fr, Régulier Anglais, Alternant Fr, Alternant Anglais,
Formation continue.
Cette rubrique est partiellement changée par rapport à l’ancienne version.la
figure 39 ci-dessous montre étape séance dans l’ancienne version.
Figure 39 : Etape séance dans l’ancienne version
52
Les modifications demandées sur Ajout/modification d’une séance suite à la
dernière réunion sont :
 Remplacer le label ‘thème’ par titre de la séance en Français et en
Anglais
 Format : garder que : Cours magistral, travaux dirigés, groupe de
discussion, séance à distance et examen, il ne faut pas supprimer les
autres, juste désactiver de façon à ce qu’on ne les voit pas apparaître
dans la liste
 Durée : Temps de cours hors pause (à préciser dans le label) et au
format décimal (1h30 équivaut à 1,5), ce principe existe déjà
 Contenu en Français et en Anglais : à conserver, prévoir un tooltip pour
montrer avec un exemple ce que signifie le contenu.
 Travail préparatoire demandé et non travail pédagogique demandé en
Anglais et en Français, prévoir un petit tooltip aussi
 Besoins matériels : ajouter dans la liste « espace co working »
 Objectifs pédagogiques : à retirer car ce champ existe déjà à la 1ère
étape (learning objectives)
La mission serait alors de présenter une nouvelle interface avec ces changements,
simple à utiliser, ergonome, plus conviviale que celle proposée.
Méthode suivie et résultats obtenus
Ce schéma (figure 40) ci-dessous représente le MCD qui permet de réaliser le

système des séances des professeurs, il contient cinq tables :
«Module », « PlanGeneraleModule », «Séance », «TypeFormation » et enfin
«TypeSéance ».
53
Figure 40 : MCD Etape séance
Respectivement, les tables TypeFormation, Séance, TypeSeance,

PlanGeneralModule, Module servent à récupérer : le type de formation pour
afficher les séances, le titre de la séance en français et en anglais, le format de la
séance, la durée, contenus en français et anglais, travail préparatoire, travail
pédagogique en anglais.
Et enfin, pour valider toutes les informations, le système a mis toutes ses
précautions pour que tous les champs obligatoires soient remplis.
Par conséquent, j’avais besoin à des requêtes LINQ, pour contrôler toutes ces
informations, et faire de mise à jour.
manipulation et l’exploitation.
Le fonctionnement de l’interface est très simple, l’utilisateur se connecte, choisit
la rubrique « Séance ».A ce moment, le système l’invite à sélectionner le type de
formation souhaité concaténé par le nombre de formations de ce type de
54
formations (comme l’illustre figure 38), l’objectif était basé de prévoir le résultat
à l’utilisateur. Ensuite, il choisit de cliquer sur nouvelle séance s’il le souhaite, et
voit apparaitre une interface « Ajout séance » pour remplir les champs et par suite
enregistrer la séance. L’interface se présentera comme l’illustre la figure 41 et la
figure 42.
Figure 41 : Interface étape séance

55
Figure 42 : Interface ajout séance
56
Etape7 : Bibliographie
Description
Dans cette rubrique de formulaire « Bibliographie», elle a rôle d’afficher l’ouvrage

de référence en français et en anglais, références complémentaires en français et
en anglais aussi, par la suite de sauvegarder en cas de changement ou
modification.
Cette rubrique reste inchangée par rapport à l’ancienne version, sauf les labels
qui ont été changés.
Remplacer le label « bibliographie obligatoire » par « ouvrage de référence »
Ce champ est obligatoire et il a fallu de prévoir en français et en anglais.
Remplacer le label ‘bibliographie conseillée’ par ‘références complémentaires’
(Français et anglais) et ce champ n’est pas obligatoire.
Sinon le bouton d’enregistrement est identique à l’ancienne version, dans la table
« module »
L’ouvrage de référence en français et en anglais est un champ de type texte sans

limiter du nb de caractères, champs « références complémentaires » prévu aussi
en français et en anglais. Ils se trouvent dans la table « Module », Un bouton est
mis en place afin d’enregistrer des changements sil y’aura lieu. J’avais besoin de
requête LINQ pour l’affichage et mise à jour. Ci-dessous (figure 43) de
bibliographie.
57
Figure 43 : Interface bibliographie
58
VII. Bilan du stage
1. Difficultés rencontrées
La première difficulté était de me familiariser avec la base de données et de

connaître son architecture globale sachant que celle-ci contient plus de 500
tables.
Ensuite, l’utilisation de LINQ posait un sérieux problème dans la mesure où son
nom même m’était inconnu.
2. Expériences professionnelles acquises
Cette période d’application professionnelle m’a permis de découvrir des sujets et

des techniques que je n’avais jamais étudiés. Ce stage m’a, du reste, donné la
possible de mettre en pratique les connaissances théoriques acquises durant mes
différentes formations.
Sur le plan technique, les outils et le langage utilisé étaient, pour la plupart,
entièrement nouveaux pour moi.
J’ai beaucoup appris au contact des différentes personnes avec lesquelles j’ai
travaillé. J’ai souvent été amené à collaborer et à communiquer avec mes
collègues en leur demandant soit une aide ou un avis.
De plus, j’ai pu bénéficier d’une certaine indépendance qui a stimulé ma force de
proposition et de créativité. Mes capacités d’autonomie et d’initiatives ont été
mises à l’épreuve et ont aussi évoluées positivement pendant cette expérience.
J’ai pu renforcer ma capitale confiance, notamment en démontrant mes capacités
à dépasser les difficultés et à trouver des solutions malgré les difficultés.
Ces six mois de stage m’ont permis de me familiariser avec les différents aspects
du métier d’ingénieur en informatique : de l’analyse au développement.
59
VIII. Conclusion
Ces six mois de stage ont été très enrichissants. En effet, j’ai eu l’opportunité de
gérer entièrement mon projet, en m’appropriant des méthodes et des
technologies que je découvrais. Ils m'ont permis de consolider mes connaissances
théoriques en les mettant en pratique.
J’ai eu, en outre, la chance de pouvoir mettre mes compétences de futur
ingénieur à l’épreuve, notamment grâce aux libertés de choix et d’actions qui
m’ont été laissées dans mon travail, mais aussi grâce à un excellent encadrement.
En somme, malgré les difficultés rencontrées en début de stage, je suis parvenu
à monter les solutions sur les technologies ASP .NET, LINQ, C#
60
IX. Annexes
 Annexe I : Mise en œuvre de LINQ
 Annexe II : Mise en œuvre de procédure stockée

61
 Annexe III :
62
X. Ressources documentaires
 Documentation technique
https://msdn.microsoft.com : Site de la documentation de Microsoft

http://www.dotnet-tricks.com/ : Requêtes LINQ
http://www.w3schools.com/css : site official du langage CSS
www.asp.net : Site officiel de la plateforme .NET et d’ASP.NET, en anglais
Livre de « Brice-Arnaud GUERIN » : ASP.Net 4 avec C# sous Visual Studio 2010
 Forums et blogs
http://stackoverflow.com
http://www.codeproject.com
63

Rapport

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Rapport

Transféré par

Droits d'auteur :

Formats disponibles

Université de Bretagne occidentale Brest Business School

UFR Science et techniques 2, avenue de Provence

Migration de L’ERP de l’école BBS

RAPPORT DE STAGE MASTER 2 SIAM UBO

Migration de L’ERP de l’école BBS

BBS: Brest Business School

ESC : Ecole Supérieure de Commerce

ESCAE : Ecole Supérieure de Commerce et d’administration des entreprises

MCD : Modèle conceptuel de Données

HTML : HyperText Markup Language / Langage de balisage

ASP : Active server page / page serveur actif

CLI : Common Language Infrastructure

CLR : Common Language Runtime

ORM: Object-relational mapping / Mapping objet relationnel

LINQ: Language-Integrated Query / Requête intégrée au langage

SQL: Structed Query Language / langage de requête structurée

XML: Extensible Markup Language / Langage à balises extensibles

HTTP: HyperText Transfer Protocol / Protocole de transfert hypertexte

IIS : Internet Information Service / Service d’information d’internet

The work presented in the report was conducted as part of an internship

The first phase of my training was dedicated to learn programming in C #, then

Bac +3 : Bachelor en International Management (Brest) et Bachelor en

L'école accompagne également toutes les entreprises dans leurs projets de

Figure 1 : les chiffres clés de BBS

seule disponible en dehors du français.

2. Prise de connaissance de sujet

A noter que l’ancienne application a été développée depuis 2003, mais la

Figure 3 : Vieux intranet de BBS (Après l’authentification)

Framework.Net et Visual Studio Ultimate 2013

A titre d’illustratif conférez-vous à la figure 4 ci-dessous.

C#, LINQ, SQL et Entity Framework 4.5

Mappage de la base de données SQL Server en classes objets

Le C# est un langage de programmation orientée objet crée en 2002 par

L’objet Data est une représentation de données résidente en mémoire qui

Migration de L’ERP de l’école BBS

Figure 5 : Entity Framework

Par conséquent, l’utilisation de Entity Framework est nécessaire pour convertir

 Mode EF Database First

 Mode EF Model First

ASP.Net est un ensemble de technologies créé par Microsoft que les

ASP .NET MVC

Modèle Mise à jour Contrôleur

Notifie, Mis Fait un

ASP.Net MVC, comme son nom l’indique, implémente en plus l’architecture

Modèle il décrit les données utilisées. C’est

La vue c’est ce avec quoi l’utilisateur va

données ont changée pour qu'elles

Au premier abord, l’ASP.NET semble être un langage informatif comme l’HTML

 Cycle de vie d’une page ASP .NET WebForms

Lorsqu’une page ASP.NET s’exécute, les différentes phases de son évaluation

GridView Affiche les valeurs d’une source de données

Mise en place des données

Récupération des données

La première action que j’ai effectuée est de m’occuper du parcours de

Le mappage de ces données en objets a nécessité la création d’une classe qui

L’utilisation de DataSet et de la procédure stockée ont permet d’avoir toutes les

Figure 8 : Interface d’affichage de modules pour un parcours

Migration de L’ERP de l’école BBS

Figure 10 : Interface de consultation de PDF Syllabus pour module Anglais

œuvre de LINQ et procédure stockée dans ce projet, conférez-vous

Mise en place du MCD

Table Rub_Enregistrement : contient toutes les réponses saisies ou choisis par

Récupération des données

Exploitation des données