Ministère de l’Enseignement Supérieur
Et de la Recherche Scientifique Université de Tunis
Institut Supérieur de Gestion
RÉALISATION D’UN MODULE LIÉ À
L’APPLICATION
« BOOBLEE »
--------------------------------------------------
Elaboré par
Bayrem Knaïssi
Filière
Licence Fondamentale en Informatique de Gestion
Encadré par :
--------------------------------------------------
Encadrant professionnel:
Mr. Mohamed Hamroun
Encadrant pédagogique :
Mme. Latifa Rabai
Année Universitaire
2014 - 2015
REMERCIEMENTS
C’est avec un grand honneur et un grand plaisir que je dédie ces lignes afin de remercier toute personne ayant contribué de près ou de loin à l’accomplissement de ce projet.
Je tiens à remercier Madame Latifa Rabai. Vous m’avez guidé à chaque étape de la réalisation de ce travail.
Vous m’avez toujours réservé le meilleur accueil malgré vos obligations professionnelles.
Je saisis cette occasion pour vous exprimer ma profonde gratitude tout en témoignant mon respect.
Je remercie également toute l’équipe d’IntilaQ et Microsoft pour leur accueil chaleureux au sein de leurs locaux, ainsi les conditions hyper favorables pour travailler.
Je ne vais pas céder l’opportunité pour remercier Monsieur Ahmed Kaddour pour cette expérience aussi bénéfique.
Outre, je tiens à remercier toute l’équipe de la Startup Disrupt CK que je valorise cette expérience passée avec eux.
Je remercie Monsieur Zied Jallouli. J’ai eu le privilège de travailler parmi votre équipe et d’apprécier vos qualités et vos valeurs.
Votre sérieux, votre compétence et votre sens du devoir m’ont énormément marqués.
Je tiens aussi à témoigner ma gratitude surtout à Monsieur Mohamed Hamroun pour son encadrement, son assistance, son soutien, ses précieux conseils ont été d’une grande aide pour la concrétisation du travail.
Je remercie aussi Monsieur Ewald Bos pour sa collaboration, son aide et ses
conseils qui ont été capitaux pour l’acheminement de ce travail.
DédicacesJe dédie ce travail
A mon père, source d’inspiration, celui qui s'est toujours sacrifié pour me voir réussir.
A ma mère, source de tendresse et d’amour, le symbole de la bonté par excellence et l'exemple du dévouement qui n'a cessé de m'encourager et de prier pour moi.
Je vous dois ce que je suis aujourd’hui et ce que je serai demain et je ferai toujours de mon mieux pour rester votre fierté et ne jamais vous décevoir.
A mon frère, qui n’a jamais cessé de croire en moi, d’être toujours là à mes côtés et de sacrifier pour mon bien être, je te souhaite un avenir radieux, plein de bonheur et de succès.
A tous les membres de la famille, qui m’ont encouragé et ceux qui ont oublié de le faire.
A mes chers amis, qui ont été toujours présents avec leur soutien.
A tous les membres du club ISG MICROSOFT, qui grâce à eux, j’ai effectué ce stage, ils étaient une vraie famille. J’étais, je suis et je serai toujours là pour vous.
Au club radio isg, qui m’a permis de connaitre une nouvelle personnalité, je n’oublierai jamais les bons et mauvais moments vécus dans ce club.
A la nouvelle famille, récemment découvert « Peña Madridista Tunez », que je la souhaite un avenir radieux.
A « Stack Over Flow » et « CodeProject », qui étaient un soutien à toutes les situations difficiles.
Au ministère de transport et aux fournisseurs d’accès à internet, source d’inspiration pour leurs mauvais services qui m’ont accablé durant ces trois années d’études.
Et finalement, à mon modèle, que je lui souhaite un futur rayonnant comme on l’a tracé ensemble : moi-même.
TABLE DES MATIÈRES
TABLE DES FIGURES...............................................................................................................8
TABLE DES TABLEAUX..........................................................................................................11
INTRODUCTION GÉNÉRALE..................................................................................................1
CHAPITRE I :.............................................................................................................................3
ÉTUDE PRÉLIMINAIRE............................................................................................................3
INTRODUCTION..................................................................................................................3
I. PRÉSENTATION DU CADRE DE STAGE..........................................................................3
1. Présentation de l’organisme d’accueil........................................................................3
2. Présentation de la startup Disrupt CK........................................................................4
3. Présentation du projet.................................................................................................4
II. MÉTHODOLOGIE DE TRAVAIL..................................................................................5
1. Les méthodes agiles...................................................................................................5
2. Les principales méthodes Agiles................................................................................5
3. Scrum.........................................................................................................................6
4. Langage de modélisation (UML)...............................................................................7
III. SPÉCIFICATIONS DES BESOINS.................................................................................7
1. Les besoins fonctionnels............................................................................................7
2. Les besoins non fonctionnels.....................................................................................8
3. Identification des acteurs............................................................................................8
4. Le pilotage du projet par Scrum.................................................................................9
5. Découpage du projet...................................................................................................9
6. Backlog Product.......................................................................................................10
7. Structuration en sprints et planification...................................................................13
CONCLUSION...................................................................................................................15
CHAPITRE II............................................................................................................................16
SPRINT 1 : GESTION DES PRODUITS, DES PROGRAMMES ET LEUR ASSOCIATION...16
INTRODUCTION................................................................................................................16
I. SPÉCIFICATION DES BESOINS....................................................................................16
1. Le Sprint Backlog.....................................................................................................16
2. Prototypes d’interface..............................................................................................20
II. ANALYSE...............................................................................................................21
1. Diagramme de cas d’utilisation des fonctionnalités.................................................21
2. Description des scénarios du déroulement des « users stories » de cette fonctionnalité : Diagrammes de collaborations..................................................................23
III. CONCEPTION..........................................................................................................28
1. Diagramme de classes du premier sprint : Gestion des produits et programmes et leur association...................................................................................................................28
2. Schéma de la base de données..................................................................................29
IV. IMPLÉMENTATION..................................................................................................29
1. Diagrammes de composants.....................................................................................29
2. Test...........................................................................................................................31
CONCLUSION...................................................................................................................33
CHAPITRE III...........................................................................................................................34
SPRINT 2 : TAGGING DES PRODUITS SUR LES « FRAMES » DES PROGRAMMES.......34
INTRODUCTION................................................................................................................34
I. SPÉCIFICATION DES BESOINS....................................................................................34
1. Le Sprint Backlog.....................................................................................................34
2. Prototypes d’interfaces.............................................................................................36
II. ANALYSE...............................................................................................................38
1. Diagramme de Cas d’utilisation des fonctionnalités................................................38
2. Description des scénarios du déroulement des « users stories » de cette fonctionnalité : Diagrammes de collaborations..................................................................40
III. CONCEPTION..........................................................................................................43
1. Diagramme de classes du deuxième sprint : Tagging des produis sur les « frames » des programmes..................................................................................................................43
2. Schéma de la base de données..................................................................................44
IV. IMPLÉMENTATION..................................................................................................44
1. Diagramme de composants......................................................................................44
2. Test...........................................................................................................................45
CONCLUSION...................................................................................................................47
CHAPITRE IV...........................................................................................................................48
SPRINT 3 : GROUPEMENT DES PRODUITS........................................................................48
INTRODUCTION................................................................................................................48
I. SPÉCIFICATION DES BESOINS....................................................................................48
1. Sprint Backlog..........................................................................................................48
2. Prototypes d’interfaces.............................................................................................51
II. ANALYSE...............................................................................................................52
1. Diagramme de Cas d’utilisation des fonctionnalités................................................52
2. Description du déroulement des « users stories » de cette fonctionnalité : Diagrammes de collaboration.............................................................................................54
III. CONCEPTION..........................................................................................................60
1. Diagramme de classes du troisième sprint : Groupement des produits................60
2. Schéma de la base de données..................................................................................61
IV. IMPLÉMENTATION..................................................................................................62
1. Diagrammes de composants.....................................................................................62
2. Test...........................................................................................................................63
CONCLUSION...................................................................................................................65
CHAPITRE V :..........................................................................................................................66
RÉALISATION..........................................................................................................................66
INTRODUCTION................................................................................................................66
I. ENVIRONNEMENT DE DÉVELOPPEMENT....................................................................66
1. Environnement matériel...........................................................................................66
2. Environnement logiciel............................................................................................67
II. ARCHITECTURE......................................................................................................69
III. CHOIX TECHNOLOGIQUES......................................................................................70
1. ASP.Net....................................................................................................................70
2. Web API : RESTful..................................................................................................71
3. Client : sous patron MVC.........................................................................................71
4. ORM.........................................................................................................................72
5. Entity Framework.....................................................................................................73
6. Les langages de programmation...............................................................................73
IV. GESTION DE PROJET..............................................................................................75
1. Tableau des taches effectuées..................................................................................75
2. Diagramme de Gantt................................................................................................76
CONCLUSION...................................................................................................................76
CONCLUSION GÉNÉRALE.....................................................................................................77
ANNEXES.................................................................................................................................79
ANNEXE 1 : ETUDE APPROFONDIE SUR LES MÉTHODES AGILES ET LA MÉTHODE « SCRUM »......................................................................................................................79
1. Les bases de la méthode Scrum................................................................................79
2. Pourquoi Scrum ?.....................................................................................................80
ANNEXE 2 : LES RÈGLES DE PASSAGE D’UN MODÈLE OBJET À UN MODÈLE RELATIONNEL..................................................................................................................81
RÉFÉRENCES..........................................................................................................................82
TABLE DES FIGURESFigure 1 : Processus de Scrum [7]..............................................................................................6
Figure 2 : Découpage du projet.................................................................................................10
Figure 3 : Exemple de schéma de découpage en Releases.......................................................14
Figure 4 : Découpage en sprints du projet................................................................................14
Figure 5 : Planning du déroulement du projet..........................................................................15
Figure 6 : Prototype d'interface 1..............................................................................................20
Figure 7 : Prototype d'interface 2..............................................................................................20
Figure 8 : Prototype d'interface 3..............................................................................................21
Figure 9 : Diagramme de cas d'utilisation de la fonctionnalité : Gestion produits...................21
Figure 10 : Diagramme de cas d'utilisation de la fonctionnalité : Gestion programmes..........22
Figure 11 : Diagramme de cas d'utilisation de la fonctionnalité : Gestion des produits connectés aux programmes.......................................................................................................22
Figure 12 : Diagramme de collaboration d'un ajout d'un produit.............................................23
Figure 13 : Diagramme de collaboration d’une consultation d’un produit...............................23
Figure 14 : Diagramme de collaboration d’une modification d’un produit..............................24
Figure 15 : Digramme de collaboration d’une suppression d’un produit.................................24
Figure 16 : Digramme de collaboration d’un ajout d’un programme.......................................25
Figure 17 : Digramme de collaboration d’une consultation d’un programme..........................25
Figure 18 : Digramme de collaboration d’une modification d’un programme.........................26
Figure 19 : Digramme de collaboration d’une suppression d’un programme..........................26
Figure 20 : Diagramme de collaboration d'une affectation d’un produit à un programme......27
Figure 21 : Diagramme de collaboration d’un retirement d’un produit d’un programme........27
Figure 22 : Diagramme de collaboration d’une consultation de produits d'un programme bien déterminé...................................................................................................................................28
Figure 23 : Diagramme de classes du premier sprint................................................................28
Figure 24 : Diagramme de composants de la fonctionnalité : Gestion des produits.................29
Figure 25 : Diagramme de composants de la fonctionnalité : Gestion des programmes..........30
Figure 26 : Diagramme de composants de la fonctionnalité : Gestion des produits connectés aux programmes........................................................................................................................30
Figure 27 : Test des services web (liste des produits)..............................................................31
Figure 28: Test des services web (programme bien déterminé)...............................................31
Figure 29 : Test de l'application (liste des programmes)..........................................................32
Figure 30 : Test de l'application (ajout d'un programme).........................................................32
Figure 31 : Test de l'application (La liste des produits connectés au film)..............................33
Figure 32 : Prototype d'interface 1............................................................................................37
Figure 33 : Prototype d'interface 2............................................................................................37
Figure 34 : Prototype d'interface 3............................................................................................38
Figure 35 : Diagramme de cas d'utilisation de la fonctionnalité : Gestion des frames de programmes...............................................................................................................................39
Figure 36 : Diagramme de cas d'utilisation de la fonctionnalité : Gestion des produits connectés aux frames des programmes.............................................................39
Figure 37 : Diagramme de collaboration d’affectation d’un "frame" à un programme............40
Figure 38 : Diagramme de collaboration de consultation des « frames » des programmes.....40
Figure 39 : Diagramme de collaboration de suppression d’un frame d’un programme...........41
Figure 40 : Diagramme de collaboration : Consultation des produits connectés aux frames de programmes...............................................................................................................................41
Figure 41 : Diagramme de collaboration : Affectation d’un produit à un frame de programme...................................................................................................................................................42
Figure 42 : Diagramme de collaboration : Détachement d’un produit d'un frame du programme................................................................................................................................42
Figure 43 : Diagramme de classes du sprint 2..........................................................................43
Figure 44 : Diagramme de composants : Gestions des "frames" de programmes....................44
Figure 45 : Diagramme de composants de la fonctionnalité Gestion des produits connectés aux frames des programmes......................................................................................................45
Figure 46 : Test des services web (Les frames d'un programme).............................................45
Figure 47 : Test de l'application (récupération des frames et l'insertion dans une Timeline)...46
Figure 48 : Test de l'application (Déplacer le produit).............................................................46
Figure 49 : Test de l'application (Création du tag)...................................................................47
Figure 50 : Prototype d'interface 1............................................................................................51
Figure 51: Prototype d'interface 2.............................................................................................51
Figure 52 : Prototype d'interface 3............................................................................................52
Figure 53 : Diagramme de cas d'utilisation de la fonctionnalité : Gestion des groupes..................................................................................................................53
Figure 54 : Diagramme de cas d'utilisation de la fonctionnalité : Gestion des célébrités.............................................................................................................................53
Figure 55 : Diagramme de cas d'utilisation de gérer les groupes de produits..........................54
Figure 56 : Diagramme de collaboration : Ajouter un groupe..................................................55
Figure 57 : Diagramme de collaboration : Modifier un groupe................................................55
Figure 58 : Diagramme de collaboration : Consulter les groupes............................................55
Figure 59 : Diagramme de collaboration : Supprimer des groupes..........................................56
Figure 60 : Diagramme de collaboration : sélectionner le type du groupe...............................56
Figure 61 : Diagramme de collaboration : Affecter un groupe à une célébrité........................57
Figure 62 : Diagramme de collaboration : Tagger un groupe...................................................57
Figure 63 : Diagramme de collaboration : Affecter un produit à un groupe............................58
Figure 64 : Diagramme de collaboration : Consulter les groupes des produits........................59
Figure 65 : Diagramme de collaboration : Supprimer un produit du groupe............................59
Figure 66 : Diagramme de classes du 3ème sprint : Groupement de produits.........................60
Figure 67. Diagramme de composants de la fonctionnalité : Gestion des groupes..................62
Figure 68 : Diagramme de composants de la fonctionnalité : Gestion des groupes de produits...............................................................................................62
Figure 69 : Diagramme de composants de la fonctionnalité : Gestion des célébrités...............................................................................................................63
Figure 70 : Test web services (récupérer les produits de chaque groupe)................................63
Figure 71 : Test de l'application (Récupérer les groupes)........................................................64
Figure 72 : Processus de sélection des tags...........................................................................64
Figure 73 : Test de l'application (Affectation des tags à un groupe déjà disponible)...............64
Figure 74: Test de l'application (Gestion des célébrités)..........................................................65
Figure 75 : Architecture de l'application...................................................................................70
Figure 76 : Architecture du patron MVC [10]..........................................................................72
Figure 77 : Les méthodes de l'ORM Entity Framework [12]...................................................73
Figure 78 : Tableau des taches..................................................................................................75
TABLE DES TABLEAUXTableau 1 : Le "Backlog Product"...........................................................................................11
Tableau 2 : Sprint Backlog du sprint 1.....................................................................................17
Tableau 3: "Sprint Backlog" du sprint 2...................................................................................35
Tableau 4 : Sprint Backlog du sprint 3.....................................................................................48
1
INTRODUCTION GÉNÉRALE
Si l’audiovisuel attire à lui tant de talents, c’est grâce à une image faite de modernité et
d’innovation. Et pour cause, l’apparition des écrans mobiles smartphones et tablettes, a
permis de multiplier ces dernières années les supports de diffusion, de même que les
nouveaux formats. [1]
Ce secteur couvre ainsi un marché aussi colossal entre les producteurs, les marques et les
utilisateurs.
Pour bien assimiler le contexte, on va faire un aperçu sur le marché afin de voir les différentes
prises de positions des différents intervenants au marché.
D’emblée les créateurs de contenu ont vécu des situations acharnées à cause de l’activité
concurrentielle : le fait d’injecter des fonds colossaux pour un incertain revenu. Les modèles
de financement et de revenus sont contestés aujourd'hui.
Près de 100% des utilisateurs des magnétoscopes numériques (DVR)1 (comme TIVO)
ignorent les publicités, diminuant l’audience de la diffusion de 50%, tandis que les taux de
publicité sont multipliés par 4 au cours de ces dernières années.
La production américaine produit environ 600 longs métrages par an, environ 370 émissions
de télévision diffusées en direct et l’année dernière 56 nouvelles séries étaient produites avec
un taux de réussite moyen de 35%.2
Pour le cas des marques, les fournisseurs sont conscients du pouvoir des films, séries et
célébrités. Ils ont dépensé beaucoup de ressources dans le placement et l’endossement des
produits sur le marché audiovisuel.
Alors que pour l’utilisateur, le téléspectateur américain regarde environ 293 minutes par jour.
50 millions de demandes sont faites chaque année à la recherche des produits vus dans une
vidéo regardée. [2]
1 Digital Video Recorder2 Source Neilson
2
Aujourd'hui, nous savons que 85% des propriétaires de smartphones et de tablettes utilisent
leurs appareils en regardant la télévision : 40% d'entre eux utilisent leurs tablettes tous les
jours en regardant la télévision et 45% de cette utilisation est pour le shopping3.
Des efforts ont été faits pour profiter de ce comportement avec des applications de premier et
second écran, mais à cause de la complexité de l’écosystème, aucune application n’a vraiment
eu un tel succès.
C’est dans ce cadre que la startup Disrupt CK est en train de développer une application qui
permet aux téléspectateurs de découvrir et d'acheter des produits qu'ils voient dans une vidéo
pendant son visionnage ou après. Ce projet se divise en deux grandes parties :
Une application pour les téléspectateurs.
Un CMS4 permettant de faire le traitement vidéo et la gestion des métadonnées.
Le présent document décrit le travail qu’on a réalisé en cinq chapitres qui représente un
module lié à l’application développée par la startup qui nous permettra par la suite d’assigner
ou d’affecter un ensemble de produits à un groupe bien déterminé.
Le premier chapitre présente le cadre général de notre projet, la spécification des besoins ainsi
que la méthodologie du travail. Le second chapitre qui s'intitule "Gestion des produits, des
programmes et leur association" présente la conception détaillée et la réalisation de la
première phase. Le troisième chapitre "Tagging des produits aux frames" décrit la phase
suivante et le quatrième chapitre "Groupement des produits" illustre la dernière phase du
projet. Le cinquième chapitre expose tous les outils utilisés pour la conception et le
développement de l’application. Enfin, on clôture ce rapport par une conclusion présentant
une récapitulation du travail ainsi que les apports et les avantages qu’on a acquis grâce à ce
projet.
3 Source Neilson
4 Content Management System
3
Chapitre I : Etude Préliminaire
CHAPITRE I : ÉTUDE PRÉLIMINAIRE
Introduction
L’étude d’un projet est une démarche stratégique qui va nous permettre d’avoir une vision
globale sur ce dernier visant ainsi à bien organiser le bon déroulement du projet.
Cette étude fera donc l’objet du premier chapitre qui sera consacré à la présentation de
l’organisme d’accueil, la présentation du projet et ses objectifs ainsi que la définition
méthodologie de développement et ses piliers.
I. Présentation du cadre de stage
1. Présentation de l’organisme d’accueil
Pour soutenir la jeunesse tunisienne et lui permettre de réaliser leurs aspirations
à l’entreprenariat, le Qatar friendship fund (QFF) collabore avec Startup Factory appartenant
à Tunisiana (Ooredoo) et Microsoft Innovation Center et lancent un projet nommé IntilaQ
destiné à éveiller chez les jeunes tunisiens l’esprit de l’entreprenariat. [3]
Il s’agit d’un incubateur qui offre un soutien technique et financier aux étudiants, chercheurs
et entrepreneurs.
IntilaQ vise à être le meilleur environnement de création d'entreprise en Tunisie, le pilote
le plus reconnu de l'innovation des TIC5, et la destination de choix pour les créateurs
d'emplois (entrepreneurs).
Comme on a déjà mentionné, cet organisme place les entrepreneurs au cœur de son projet
et met également en œuvre, en parallèle du soutien financier, un programme d’incubation
spécifique pour chaque startup.
5 Technologies de l'information et de la communication
4
Chapitre I : Etude Préliminaire
2. Présentation de la startup Disrupt CK
Plusieurs startups ayant bénéficié du soutien d’IntilaQ représentent un éventail riche et varié
en termes d’innovation, parmi ces startups, on évoque Disrupt CK, l’organisme qui m’a offert
l’opportunité de passer mon projet de fin d’étude et participer à leur projet révolutionnaire.
Le projet se divise en deux grandes parties : Une application pour les téléspectateurs
et un CMS permettant de faire le traitement vidéo et la gestion des métadonnées. [4]
3. Présentation du projet
Ce projet immense permet aux téléspectateurs le droit de connaitre n’importe quel produit
présent dans une vidéo quel que soit un film, une série ou une émission et même
le commander.
A part les produits, le projet permet aux utilisateurs d’avoir les informations sur les films,
les acteurs, les musiques de films,...
Le cycle de vie de ce projet aura une partie pour les clients qui sera représentée par une
application mobile qui permettra de se synchroniser avec la vidéo pour reconnaitre
le programme (reconnaissance audio).
Entre temps dans la partie Back-End, il y a un CMS qui permet la gestion des données :
Il s’agit d’une application web qui permet de préparer les métadonnées de chaque film
et chaque composant qu’on aura recours.
En premier lieu une fonctionnalité permettra de gérer les vidéos, pour ensuite découper la
vidéo en images ensemble de « frames » puis associer des produits aux frames qui seront
représentés par des « tags ».
Donc dès que l’utilisateur fera la synchronisation avec la vidéo via l’équipement, il aura
toutes les informations des images avec des tags qui lui permettront de se renseigner
sur les détails des produits ou des célébrités.
5
Chapitre I : Etude Préliminaire
Dans ce marathon et à l’occasion de notre projet de fin d’étude, on fera le développement de
ce module :
« Products Group » : C’est le fait d’assigner ou d’affecter un ensemble de produits
à un seul « frame », c’est-à-dire non déplacer les produits un par un pour le marquage mais le
bloc en entier.
Pour bien expliquer ce concept, on suggère un exemple simplifié : dans un film, un acteur
porte une veste, des lunettes et une montre où il fait beaucoup de scènes avec ça.
Donc on les associe par un groupe, le même pour une scène qui se répète avec les mêmes
produits (un tableau, une télé, un divan...).
Pour concrétiser cette tâche, on doit parvenir à gérer les programmes, les produits,
les célébrités, assurer l’affectation et permettre de tagguer des produits sur les frames.
II. Méthodologie de travail
Chaque personne peut songer à une idée, peut résoudre un problème et trouver des solutions
pour faciliter n’importe tache, mais, concrétiser cette idée est le problème majeur.
C’est pour cela qu’on doit opter pour les solutions les plus optimales pour avoir recours à une
méthodologie efficace qui permet de gérer un cycle de vie d’un projet.
1. Les méthodes agiles
Les méthodes agiles se proclament comme une méthodologie efficace qui représente
une approche de gestion de projet et de développement itérative et incrémentale et qui vise
à réduire le cycle de vie du logiciel et permet de satisfaire les besoins du client. [5]
Cette méthode se base sur des cycles courts et permet de découper le projet en petits blocs
et les hiérarchiser en fonction des besoins.
On fera une étude plus approfondie dans l’annexe de ce rapport à propos les méthodes agiles.
2. Les principales méthodes Agiles
SCRUM
EXtreme Programming (XP)
6
Chapitre I : Etude Préliminaire
Rapid Application Development (RAD)
Crystal clear
Après avoir fait beaucoup de recherches et avoir mené beaucoup d’interviews avec des parties
qui travaillent avec les méthodes agiles, on a opté pour l’utilisation de la méthode SCRUM.
3. Scrum
La méthode Scrum est une méthode agile, créée en 2002, dont le nom est un terme emprunté
au rugby qui signifie « la mêlée » qui permet de produire un logiciel dans la durée la plus
courte. [6]
Ce processus s'articule en effet autour d'une équipe soudée, qui cherche à atteindre un but.
Cette méthodologie se progresse par une série d'itérations appelées sprints, qui durent de deux
à quatre semaines. Le produit envisagé est conçu, codé et testé pendant ce sprint.
A chaque fin de sprint, on peut voir fonctionner le produit courant et décider soit de le livrer,
soit de continuer à l'améliorer pendant un autre sprint.
Voici le processus sur lequel est basé Scrum :
Figure 1 : Processus de Scrum [7]
Le «Product Backlog » : C’est l'ensemble des fonctionnalités du produit que l'on veut
développer.
Le «Sprint Backlog» : C’est une liste de tâches identifiées par l'équipe à remplir
pendant un sprint.
« Burndown charts » : Met en relief le taux de travail restant dans un sprint.
7
Chapitre I : Etude Préliminaire
Ce sont les principaux artéfacts qu’on peut les générer lors de l’utilisation de la méthode
Scrum.
Durant un développement d’un projet avec la méthode Scrum il y a une interaction avec
plusieurs intervenants :
Le « Product Owner » qui porte la vision du produit à réaliser.
Le « Scrum Master » c’est une personne chargée de veiller à la mise en application
de la méthode et au respect de ses objectifs.
L’équipe de développement qui réalise le produit.
La durée de vie d’un projet en Scrum est rythmée par un ensemble de réunions clairement
définies et strictement limitées dans le temps.
On amplifiera cette étude concernant la méthode Scrum dans l’annexe.
4. Langage de modélisation (UML)
UML (Unified Modeling Language) : Une dizaine d'années après le début de son utilisation
dans le cadre de projets de développement orienté objet, UML s'est imposé comme standard.
Ce langage est né de la fusion de plusieurs méthodes existant auparavant et est devenu
désormais la référence en termes de modélisation objet. La modélisation objet consiste à créer
une représentation informatique des éléments du monde réel auxquels on s'intéresse,
sans se préoccuper de l'implémentation, ce qui signifie indépendamment d'un langage
de programmation. Il s'agit donc de déterminer les objets présents et d'isoler leurs données
et les fonctions qui les utilisent. [8]
Après le choix de la méthodologie, on a choisi UML comme un langage de modélisation afin
de concevoir le projet.
III. Spécifications des besoins
Avant de démarrer un projet, il est nécessaire de le définir et de le planifier afin de bien
le piloter et d'atteindre les objectifs voulus par le client.
1. Les besoins fonctionnels
La définition des besoins fonctionnels est une description abstraite des services
que le système est sensé fournir pour répondre aux attentes des utilisateurs.
8
Chapitre I : Etude Préliminaire
Notre système doit permettre de :
Gérer les produits
Gérer les programmes
Gérer les célébrités
Gérer les produits connectés à un programme
Gérer les « frames » de programme
Gérer les produits connectés à un « frame »
Gérer les tags
Gérer Les groupes
Gérer les groupes de tags
On explicitera ces besoins dans le « Product Backlog »
2. Les besoins non fonctionnels
Les besoins non fonctionnels sont des besoins qui ont un aspect visible pour l’utilisateur,
mais qui ne sont pas reliés directement au comportement du système.
Ils présentent les exigences internes primordiales pour le système tel que les contraintes liées
à l’environnement et à l’implémentation, et les exigences en matière de performances,
d’extensibilité et de fiabilité.
Les besoins non fonctionnels de notre système se décrivent comme suit :
L’ergonomie : Le logiciel doit être agréable et facile à utiliser et les interfaces doivent
être homogènes et cohérentes pour les utilisateurs afin de les aider à formuler des
requêtes correctes.
La fiabilité : Le système doit présenter des résultats précis et justes.
La maintenance et réutilisabilité : Le système doit être facile à modifier pour
s’adapter aux nouveaux besoins.
Les contraintes techniques : La solution doit être développée avec ASP.NET. Visual
studio 2013 pour implémenter les services web (Type RESTful) et la partie cliente.
L’architecture : L'application admet une architecture orientée service qui consiste
à consommer des Web services par l'application web.
9
Chapitre I : Etude Préliminaire
La modélisation : La modélisation de l’application va se faire à travers
la méthodologie UML qui permettra de spécifier, visualiser et modéliser les différents
besoins du futur produit d'une manière standard.
3. Identification des acteurs
Un acteur est une personne, un matériel ou un logiciel qui interagit avec le système dans
le but de réaliser une ou plusieurs fonctions concernant les cas d’utilisations.
Dans ce module, on aura recours à un seul acteur, c’est le tagueur.
4. Le pilotage du projet par Scrum
Comme on a déjà mentionné, on choisira la méthodologie agile de Scrum, car cette méthode
offre la possibilité d’un développement rapide et permet la réutilisabilité des fonctionnalités
séparément de la plateforme.
Cette méthode invoque la participation de plusieurs intervenants, dans le contexte de notre
projet, Mr Mohamed Hamroun, Mr Ewald Bos et Mr Zied Jalouli, seront à la fois
les propriétaires et les directeurs de produit puisqu’ils satisfont les différents prérequis de
ces deux rôles tout en notant que je suis, moi-même, le seul membre de l’équipe Scrum.
Avant de s’emparer dans le vif du sujet, on doit évoquer une planification et une structuration
du projet, c’est un pilier des méthodes agiles.
5. Découpage du projet
La structuration d'un projet consiste à diviser le projet en différents lots d'activités
afin d'avoir des sous-parties dont la complexité est plus facilement maitrisable.
Voici ci-dessous la structuration de notre projet :
10
Chapitre I : Etude Préliminaire
Figure 2 : Découpage du projet
6. Backlog Product
Scrum se base sur des artéfacts bien déterminés, parmi ces derniers on note
le « Product Backlog ».
Le Backlog du produit est l’artefact le plus important de Scrum. En effet, il s’agit de
l’ensemble des caractéristiques fonctionnelles ou techniques qui constituent le produit
souhaité.
Le tableau suivant décrit le Backlog produit et évoque les « User Stories » :
Tableau 1 : Le "Backlog Product"
ID Fonctionnalité ID User stories Priorité
Projet de fin d'étude
Release 1 : Products
group
Gestion des produits et de programmes
Gestion des "frames" de programmes
Gestion des "tags"
Gestion des groupes
Gestion des célebrités
11
Chapitre I : Etude Préliminaire
1 Gestion de
produits
1.1 En tant que taggueur, je veux ajouter un ou
plusieurs produits.
Elevé
1.2 En tant que taggueur, je veux modifier un
produit déterminé.
Elevé
1.3 En tant que taggueur, je veux supprimer un
produit déterminé.
Elevé
1.4 En tant que taggueur, je veux afficher la liste
des produits
Elevé
1.5 En tant que taggueur, je veux consulter un
produit bien déterminé
Elevé
2 Gestion des
programmes
2.1 En tant que taggueur, je veux ajouter un ou
plusieurs programmes.
Elevé
2.2 En tant que taggueur, je veux modifier un
programme déterminé.
Elevé
2.3 En tant que taggueur, je veux supprimer un
programme déterminé.
Elevé
2.4 En tant que taggueur, je veux afficher la liste
des programmes
Elevé
2.5 En tant que taggueur, je veux consulter un
programme bien déterminé.Elevé
3 Gestion des
célébrités
3.1 En tant que taggueur, je veux ajouter une ou
plusieurs célébrités.
Faible
3.2 En tant que taggueur, je veux modifier une
célébrité déterminée.
Faible
3.3 En tant que taggueur, je veux supprimer une
célébrité déterminée.
Faible
3.4 En tant que taggueur, je veux afficher la liste
des célébrités.
Faible
3.5 En tant que taggueur, je veux consulter une
célébrité bien déterminée.
Faible
4 Gestion des
produits
4.1 En tant que taggueur, je veux connecter un
produit à un programme.
Elevé
12
Chapitre I : Etude Préliminaire
connectés à des
programmes
4.2 En tant que taggueur, je veux retirer un produit
d’un programme.
Elevé
4.3 En tant qu’agent de tagging, je veux consulter
les produits connectés à un programme bien
déterminé.
Elevé
5 Gestion des
« frames »
connectés aux
programmes
5.1 En tant qu’agent de tagging, je veux associer
un « frame » à un programme.
Elevé
5.2 En tant qu’agent de tagging, je veux activer la
visualisation d’un frame.
Moyenne
5.3 En tant qu’agent de tagging, je veux désactiver
la visualisation d’un frame.
Moyenne
5.4 En tant qu’agent de tagging, je veux consulter
les frames d’un programme bien déterminé
Elevé
5.5 En tant qu’agent de tagging, je veux supprimer
un frame d’un programme
Moyenne
6 Gestion des
produits connectés
aux frames de
programmes
6.1 En tant qu’agent de tagging, je veux connecter
un produit à un « frame »
Elevé
6.2 En tant qu’agent de tagging, je veux détacher
un produit d’un « frame »
Elevé
6.3 En tant qu’agent de tagging, je veux
positionner les tags qui représentent les
produits dans un « frame ».
Moyenne
6.4 En tant qu’agent de tagging, je veux visualiser
les produits connectés aux frames.
Elevé
7 Gestion de groupes 7.1 En tant qu’agent de tagging, je veux ajouter un
groupe.
Moyenne
13
Chapitre I : Etude Préliminaire
7.2 En tant qu’agent de tagging, je veux consulter
la liste des groupes
Moyenne
7.3 En tant qu’agent de tagging, je veux modifier
un groupe.
Moyenne
7.4 En tant qu’agent de tagging, je veux supprimer
un groupe.
Moyenne
7.5 En tant qu’agent de tagging, je veux affecter un
groupe à une célébrité
Moyenne
7.6 En tant qu’agent de tagging, je veux
sélectionner le type du groupe
Moyenne
8 Gestion des
groupes de produits
8.1 En tant qu’agent, je veux affecter un ou
plusieurs produits à un groupe bien déterminé
(regroupement des tags)
Moyenne
8.2 En tant qu’agent, je veux détacher un produit
d’un groupe bien déterminé.
Faible
8.3 En tant qu’agent, je veux affecter un groupe à
un « frame » bien déterminé
Faible
8.4 En tant qu’agent, je veux visualiser les
composants d’un groupe.
Faible
On a choisi les priorités précédentes d’après l’apparence chronologique et l’importance entre
quelques « users stories ».
7. Structuration en sprints et planification
L’adoption de la méthode Scrum nécessite le découpage du système en des Releases.
Un Release est une série de Sprints qui se termine quand les incréments successifs constituent
un produit présentant suffisamment de valeurs à ses utilisateurs.
Ci-dessous, un schéma qui décrit le concept du découpage des Releases en Sprints suivi par
un autre schéma qui montre le découpage de notre projet et pour conclure une planification
que l’on suivra durant la période du stage.
14
Chapitre I : Etude Préliminaire
Figure 3 : Exemple de schéma de découpage en Releases
Figure 4 : Découpage en sprints du projet
On conclut par la planification, voici le planning qu’on suivra pour gérer ce projet durant
la période de stage :
Sprint 2 Taggage des prodiuts aux frames
Sprint 3 Groupement des produits
Sprint 1 Gestion des produits et des programmes et leur
association
15
Chapitre I : Etude Préliminaire
Figure 5 : Planning du déroulement du projet
Conclusion
Dans ce chapitre, on a préparé notre planification de travail, on a capturé les besoins
fonctionnels de notre application, les rôles des utilisateurs.
Par la suite on a généré le produit Backlog ainsi que le plan de release de notre projet.
Dans la partie qui suit, on explicitera le cycle de développement du premier Sprint.
02/02 - 15/02Autoformation et
analyse de la situation
16/02 - 28/02étude préliminaire
et familiarisation avec le projet
01/03 - 29/03Sprint 1
30/03 - 26/04 Sprint 2
27/04 - 17/05Sprint 3
18/05 - 22/05Finition
et enchainment entre les sprints
23/05Déposer le rapport
16
Chapitre II : Sprint 1 : Gestion des produits, des programmes et leur association
CHAPITRE IISPRINT 1 : GESTION DES PRODUITS,
DES PROGRAMMES ET LEUR ASSOCIATION
Introduction
Comme explicité dans le chapitre précédent, le sprint est une suite de taches élaborées
auparavant par les parties prenantes de la méthodologie Scrum.
Chaque sprint aura des buts aussi déterminés définis auparavant par l’équipe, ensuite on doit
évoquer les histoires utilsasteurs qui appartiennent à ce sprint.
Notre premier sprint évoque le fait de gérer les produits et les programmes et connecter
des produits à un programme bien déterminé.
Donc à la fin de ce chapitre on aura comme finalité, une liste des produits et des programmes
et la permission de les gérer et le fait de les associer.
I. Spécification des besoins
On va décortiquer les « user stories » ainsi à une description des scénarios de déroulement de
chaque « user story », conception globale, et on achève par la programmation et test.
1. Le Sprint Backlog
Le sprint Backlog est un outil qui facilite la répartition des tâches et qui fait la mise au point
du travail tout en précisant les tâches que contient chaque user-story du Product Backlog.
Notre Backlog sprint se présente comme suit :
17
Chapitre II : Sprint 1 : Gestion des produits, des programmes et leur association
Tableau 2 : Sprint Backlog du sprint 1
ID « User Story » id Tache
1 En tant que taggueur, je veux
ajouter un ou plusieurs produits.
1.1 Ajouter une classe produit dans le Web
API
1.2 Configurer la table « Product », grâce à
l’Entity Framework, la classe contexte
1.3 Ajouter la méthode d’ajout dans le web
services
1.4 Créer la méthode qui consommera le web
service
1.5 Tester l’ajout des produits
2 En tant que taggueur, je veux
afficher la liste des produits.
2.1 Ajouter la méthode de la récupération de
la liste des produits dans la partie web
services
2.2 Tester la récupération de l’ensemble des
produits
3 En tant que taggueur, je veux
supprimer un produit déterminé.
3.1 Ajouter la méthode de la suppression dans
le contrôleur du web services
3.2 Ajouter la méthode de la suppression dans
le contrôleur de l’application client
3.3 Tester la suppression des produits
4 En tant que taggueur, je veux
modifier un produit déterminé.
4.1 Ajouter la méthode de la modification
dans le contrôleur du web services
4.2 Ajouter la méthode de la modification
dans le contrôleur de l’application client
4.3 Tester la suppression des produits
5 En tant que taggueur, je veux
consulter un produit bien
déterminé
5.1 Ajouter la méthode de la récupération d’un
produit bien déterminé
5.2 Tester la récupération des détails d’un
produit
18
Chapitre II : Sprint 1 : Gestion des produits, des programmes et leur association
6 En tant que taggueur, je veux
ajouter un ou plusieurs
programmes.
6.1 Ajouter une classe programme dans le
Web API
6.2 Configurer la table « program », grâce à
l’Entity Framework, la classe contexte
6.3 Ajouter la méthode d’ajout dans
l’application client qui consommera le
web service
6.4 Tester l’ajout des programmes
7 En tant que taggueur, je veux
afficher la liste des programmes.
7.1 Ajouter la méthode de la récupération de
la liste des programmes
7.2 Tester la récupération de l’ensemble des
programmes
8 En tant que taggueur, je veux
supprimer un programme
déterminé.
8.1 Ajouter la méthode de la suppression dans
le contrôleur de l’application client
8.2 Tester la suppression des programmes
9 En tant que taggueur, je veux
modifier un programme déterminé
9.1 Ajouter la méthode de la modification
dans le contrôleur de l’application client
9.2 Tester la modification des programmes
10 En tant que taggueur, je veux
consulter un programme bien
déterminé
10.1 Ajouter la méthode de la récupération d’un
programme bien déterminé
10.2 Tester la récupération des détails d’un
programme
11 En tant que taggueur, je veux
connecter un produit à un
programme.
11.1 Ajouter une classe « ProductProgram »
dans le Web API
11.2 Configurer la table « ProductProgram »,
grâce à l’Entity Framework, la classe
contexte
11.3 Ajouter la méthode de l’affectation au web
services
19
Chapitre II : Sprint 1 : Gestion des produits, des programmes et leur association
11.4 Ajouter la méthode d’affectation d’un
produit à un programme à l’application qui
consommera les web services
11.5 Tester l’affectation des produits aux
programmes
12 En tant que taggueur, je veux
retirer un produit d’un programme.
12.1 Ajouter la méthode de la suppression d’un
produit d’un programme
12.2 Tester la suppression
13 En tant qu’agent de tagging, je
veux consulter les produits
connectés à un programme.
13.1 Ajouter la méthode de la récupération de
la liste des produits connectés à un
programme
13.2 Tester la récupération de l’ensemble des
produits connectés à un programme
2. Prototypes d’interface
20
Chapitre II : Sprint 1 : Gestion des produits, des programmes et leur association
Avant de s’emparer avec la partie analytique, on exposera quelques prototypes d’interfaces de
ce sprint pour y mettre en évidence les fonctionnalités et bien les assimiler.
La liste des programmes :
Figure 6 : Prototype d'interface 1
Ajouter un nouveau programme :
Figure 7 : Prototype d'interface 2
Récupérer un programme bien déterminé :
21
Chapitre II : Sprint 1 : Gestion des produits, des programmes et leur association
Figure 8 : Prototype d'interface 3
II. Analyse
Pour suivre une méthodologie basée sur le prototypage, on va traiter des fonctionnalités, donc
on va collecter plusieurs « users stories » en une fonctionnalité bien déterminée.
1. Diagramme de cas d’utilisation des fonctionnalités
Diagramme de cas d’utilisation de la fonctionnalité « Gestion produits »
Le Taggueur aura le privilège de manipuler et de gérer les produits, il pourra soit ajouter,
modifier, supprimer ou consulter la liste des produits.
Figure 9 : Diagramme de cas d'utilisation de la fonctionnalité : Gestion produits
Diagramme de cas d’utilisation de la fonctionnalité « Gestion programmes »
22
Chapitre II : Sprint 1 : Gestion des produits, des programmes et leur association
Le taggueur aura le privilège de manipuler et de gérer les programmes, il pourra soit ajouter,
modifier, supprimer ou consulter la liste des programmes.
Figure 10 : Diagramme de cas d'utilisation de la fonctionnalité : Gestion programmes
Diagramme de cas d’utilisation de la fonctionnalité « Gestion des produits connectés
aux programmes »
Le taggueur pourra gérer et faire des associations entre les produits et les programmes,
et par la suite il pourra soit ajouter, soit supprimer.
Figure 11 : Diagramme de cas d'utilisation de la fonctionnalité : Gestion des produits
connectés aux programmes
23
Chapitre II : Sprint 1 : Gestion des produits, des programmes et leur association
2. Description des scénarios du déroulement des « users stories » de cette
fonctionnalité : Diagrammes de collaborations
Diagrammes de collaborations liés à la fonctionnalité : Gestion des produits
Diagramme de collaboration du « user story » : Ajouter des produits
Le taggueur demande le formulaire d’ajout de produit, le système affiche le formulaire, après
le taggueur remplit les champs nécessaires et clique sur le bouton « Add ».
Le système interagit et vérifie les données saisies et enregistre le nouveau produit et affiche
un message de succès.
Figure 12 : Diagramme de collaboration d'un ajout d'un produit
Diagramme de collaboration du « user story » : Consulter les produits
Le taggueur demande la liste des produits à consulter et le système affiche la liste des
produits.
Figure 13 : Diagramme de collaboration d’une consultation d’un produit
24
Chapitre II : Sprint 1 : Gestion des produits, des programmes et leur association
Diagramme de collaboration du « user story » : Modifier un produit
Le taggueur sélectionne un produit déterminé pour le modifier, le système récupère
les données et affiche le formulaire de modification, ainsi le chef édite les données et clique
sur le bouton « Edit » et le système vérifie les données saisies et enregistre le produit modifié
et affiche un message de succès.
Figure 14 : Diagramme de collaboration d’une modification d’un produit
Diagramme de collaboration du « user story » : Supprimer un produit
Le taggueur choisit le produit à supprimer, le système affiche un message de confirmation,
ainsi l’acteur confirme son choix et le système supprime le produit et affiche un message
de succès.
Figure 15 : Digramme de collaboration d’une suppression d’un produit
25
Chapitre II : Sprint 1 : Gestion des produits, des programmes et leur association
Diagrammes de collaborations liés à la fonctionnalité : Gestion des programmes
Diagramme de collaboration du « user story » : Ajouter un programme
Le taggueur demande le formulaire d’ajout de programme, le système affiche le formulaire,
après le taggueur remplit les champs nécessaires et clique sur le bouton « Add ».
Le système interagit et vérifie les données saisies et enregistre le nouveau programme
et affiche un message de succès.
Figure 16 : Digramme de collaboration d’un ajout d’un programme
Diagramme de collaboration du « user story » : Consulter les programmes
Le taggueur demande la liste des programmes à consulte et le système affiche la liste des
programmes.
Figure 17 : Digramme de collaboration d’une consultation d’un programme
Diagramme de collaboration du « user story » : Modifier un programme
Le taggueur sélectionne un programme déterminé pour le modifier, le système récupère
les données et affiche le formulaire de modification, ainsi le chef édite les données et clique
26
Chapitre II : Sprint 1 : Gestion des produits, des programmes et leur association
sur le bouton « Edit » et le système vérifie les données saisies et enregistre le programme
modifié et affiche un message de succès.
Figure 18 : Digramme de collaboration d’une modification d’un programme
Diagramme de collaboration du « user story » : Supprimer un programme
Le taggueur choisit le programme à supprimer, le système affiche un message
de confirmation, ainsi l’acteur confirme son choix et le système supprime le produit et affiche
un message de succès.
Figure 19 : Digramme de collaboration d’une suppression d’un programme
Description du déroulement des « users stories » de cette fonctionnalité :
Gestion des produits connectés aux programmes
Diagramme de collaboration du « user story » : Connecter un produit à un
programme
Le taggueur choisit le programme à lui affecter le produit, puis un formulaire d’ajout
de produit s’intervient, ainsi le système affecte le produit à un programme et il affiche
un message de succès.
27
Chapitre II : Sprint 1 : Gestion des produits, des programmes et leur association
Figure 20 : Diagramme de collaboration d'une affectation d’un produit à un programme
Diagramme de collaboration du « user story » : Retirer un produit d’un
programme
L’agent sélectionne la liste des produits connectés à un programme déterminé et le système
affiche la liste. L’acteur sélectionne le produit à retirer de la liste et demande de retirer
ce produit. En réponse, le système retire le produit de la liste des produits connectés
à un programme et affiche un message de succès.
Figure 21 : Diagramme de collaboration d’un retirement d’un produit d’un programme
Diagramme de collaboration du « user story » : Consulter la liste des produits
connectés à un programme
L’agent de tagging demande la liste des produits connectés à un programme et le système
affiche la liste.
28
Chapitre II : Sprint 1 : Gestion des produits, des programmes et leur association
Figure 22 : Diagramme de collaboration d’une consultation de produits d'un programme bien déterminé
III. Conception
1. Diagramme de classes du premier sprint : Gestion des produits et
programmes et leur association
Figure 23 : Diagramme de classes du premier sprint
29
Chapitre II : Sprint 1 : Gestion des produits, des programmes et leur association
2. Schéma de la base de données
En suivant les règles du passage du schéma conceptuel au schéma relationnel, on optera
comme suit :
On fera un petit aperçu sur les règles de passages dans l’annexe
Product (IdProduct, ProductName, ProductDescription, ProductCode, ProductImage)
Program (IdProgram, ProgramTitle, ProgramDescription)
ProductProgram (IdProductProgram, #IdProduct, #IdProgram)
IV. Implémentation
1. Diagrammes de composants
Diagramme de composants de la fonctionnalité : « Gestion des produits »
Figure 24 : Diagramme de composants de la fonctionnalité : Gestion des produits
30
Chapitre II : Sprint 1 : Gestion des produits, des programmes et leur association
Diagramme de composants de la fonctionnalité « Gestion des programmes »
Figure 25 : Diagramme de composants de la fonctionnalité : Gestion des programmes
Diagramme de composants de la fonctionnalité : « Gestion de l’association des
produits aux programmes »
Figure 26 : Diagramme de composants de la fonctionnalité : Gestion des produits connectés aux programmes
31
Chapitre II : Sprint 1 : Gestion des produits, des programmes et leur association
2. Test
On effectuera quelques jeux d’essai pour tester les services web grâce à l’extension Postman et on testera l’application elle-même
Test des services web
La méthode invoque toute la liste des produits.
Figure 27 : Test des services web (liste des produits)
La méthode a abouti à un programme bien déterminé
Figure 28: Test des services web (programme bien déterminé)
32
Chapitre II : Sprint 1 : Gestion des produits, des programmes et leur association
Test de l’application
Cette interface, montre la récupération des films
Figure 29 : Test de l'application (liste des programmes)
Cette interface montre le formulaire de l’ajout d’un nouveau film
Figure 30 : Test de l'application (ajout d'un programme)
33
Chapitre II : Sprint 1 : Gestion des produits, des programmes et leur association
Cette interface montre les produits déjà connectés à ce programme et l’option d’affecter un programme
Figure 31 : Test de l'application (La liste des produits connectés au film)
Conclusion
Tout au long de ce sprint, on a analysé, conçu et pu développer les fonctionnalités suivantes :
gestion des programmes et des produits et on a réussi à faire la relation entre eux.
Dans le prochain sprint, on fera l’étude du « Tagging » des produits sur les « frames » qui
composent un programme.
34
Chapitre III : Sprint 2 : Tagging des Produits sur les Frames des Programmes
CHAPITRE IIISPRINT 2 : TAGGING DES PRODUITS
SUR LES « FRAMES » DES PROGRAMMES
Introduction
Notre deuxième sprint englobe le fait d’associer des « frames » à des programmes et la
fonctionnalité d’affecter des produits à ces frames. Ces produits seront marqués sur le frame
par des « tags ».
Comme au premier sprint, on va décortiquer les « user stories » ainsi à une description des
scénarios de déroulement de chaque « user story », une conception globale du module, et on
achève par la programmation et test.
I. Spécification des besoins
1. Le Sprint Backlog
Le sprint Backlog est un outil qui facilite la répartition des tâches et fait la mise au point du
travail, en précisant les tâches que contient chaque user-story du Product Backlog.
Notre Backlog sprint se présente comme suit :
35
Chapitre III : Sprint 2 : Tagging des Produits sur les Frames des Programmes
Tableau 3: "Sprint Backlog" du sprint 2
ID « User Story » id Tache
1 En tant qu’agent de tagging, je
veux connecter un « frame » à un
programme.
1.1 Ajouter une classe
ProgramFrame dans le Web API
1.2 Configurer la table « ProgramFrame »,
grâce à l’Entity Framework, la classe
contexte
1.3 Ajouter la méthode de l’affectation aux
web services
1.4 Ajouter la fonctionnalité de l’affectation
des frames aux programmes au
contrôler de l’application client
1.5 Tester l’affectation des produits aux
frames
2 En tant qu’agent de tagging, je
veux retirer un Frame d’un
programme.
2.1 Ajouter la méthode de la suppression
dans le contrôleur de l’application client
2.2 Tester la suppression des produits
3 En tant qu’agent de tagging, je
veux activer l’utilisation des
« frames »
3.1 Tester l’activation
4 En tant qu’agent de tagging, je
veux désactiver l’utilisation de
« frames »
4.1 Tester la désactivation
5 En tant qu’agent de tagging je
veux Visualiser les frames
connectés à un programme.
5.1 Ajouter la méthode de la récupération
des frames connectés au programme
5.2 Tester la récupération.
6 En tant qu’agent de tagging, je
veux associer un produit à
6.1 Ajouter la classe ProgramFrameProduct
6.2 Configurer la table
« ProgramFrameProduct », grâce à
36
Chapitre III : Sprint 2 : Tagging des Produits sur les Frames des Programmes
un « frame » de programme. l’Entity Framework, la classe contexte
6.3 Ajouter la méthode de l’affectation des
produits aux frames des programmes
aux web services
6.4 Consommer le web services par
l’application du client
6.5 Tester l’affectation
6.6 Représenter cette affectation par un tag
sur le frame.
7 En tant qu’agent de tagging, je
veux retirer un produit
d’un « frame » de programme.
7.1 Ajouter la méthode de la suppression.
7.2 Tester la Suppression.
8 En tant qu’agent de tagging, je
veux visualiser les produits
connectés aux « frames » sous
forme de « tags »
8.1 Ajouter la méthode de la récupération
des « tags »
8.2 Tester la récupération
9 En tant qu’agent de tagging, je
veux déplacer ou repositionner
les tags
9.1 Ajouter la fonctionnalité du
déplacement des tags
9.2 Tester le déplacement
2. Prototypes d’interfaces
Avant de commencer la phase d’analyse, on enchaine par quelques prototypes d’interfaces
pour bien assimiler les fonctionnalités :
37
Chapitre III : Sprint 2 : Tagging des Produits sur les Frames des Programmes
Ajouter un nouveau frame à un programme bien déterminé
Figure 32 : Prototype d'interface 1
Visualiser les produits connectés à un programme et les frames :
Figure 33 : Prototype d'interface 2
38
Chapitre III : Sprint 2 : Tagging des Produits sur les Frames des Programmes
L’affectation d’un produit à un frame qui résultera à un tag
Figure 34 : Prototype d'interface 3
II. Analyse
Pour suivre une méthodologie basée sur le prototypage, on va traiter des fonctionnalités.
Donc, on va collecter plusieurs « users stories » en une fonctionnalité bien déterminée.
1. Diagramme de Cas d’utilisation des fonctionnalités
Diagramme de cas d’utilisation de la fonctionnalité : « Gestion des frames de
programmes »
Cette fonctionnalité a pour taches de gérer les « frames » de programmes : ce sont des images
que constituent les programmes.
39
Chapitre III : Sprint 2 : Tagging des Produits sur les Frames des Programmes
Figure 35 : Diagramme de cas d'utilisation de la fonctionnalité : Gestion des frames de programmes
Diagramme de cas d’utilisation de la fonctionnalité : « Gestion des produits connectés
aux frames des programmes »
L’agent pourra connecter un produit à un frame d’un programme bien déterminé.
Cela présentera un tag au sein du frame.
Figure 36 : Diagramme de cas d'utilisation de la fonctionnalité : Gestion des produits connectés aux frames des programmes
40
Chapitre III : Sprint 2 : Tagging des Produits sur les Frames des Programmes
2. Description des scénarios du déroulement des « users stories »
de cette fonctionnalité : Diagrammes de collaborations
Diagrammes de collaborations liés à la fonctionnalité : Gestion des frames de
programmes
Diagramme de collaboration du « user story » : Affecter un frame à un
programme
L’agent de tagging sélectionne le programme déterminé et demande l’affectation du frame. Le
système affiche un message de succès.
Figure 37 : Diagramme de collaboration d’affectation d’un "frame" à un programme
Diagramme de collaboration du « user story » : Consulter les frames
des programmes
L’agent de tagging demande la liste des Frames des programmes et le système affiche la
liste.
Figure 38 : Diagramme de collaboration de consultation des « frames » des programmes
41
Chapitre III : Sprint 2 : Tagging des Produits sur les Frames des Programmes
Diagramme de collaboration du « user story » : Supprimer un « frame »
d’un programme
L’agent sélectionne la liste des programmes et choisit l’un d’eux et le système affiche la liste.
L’acteur demande de supprimer le frame auparavant affecté.
En réponse, le système retire le frame de la liste des frames connectés à un programme et
affiche un message de succès.
Figure 39 : Diagramme de collaboration de suppression d’un frame d’un programme
Diagrammes de collaborations liés à la fonctionnalité : Gestion des produits connectés
aux frames de programmes
Diagramme de collaboration du « user story » : Consulter les produits
connectés aux frames de programmes
L’agent de tagging demande la liste des produits connectés aux frames des programmes et le
système affiche la liste.
Figure 40 : Diagramme de collaboration : Consultation des produits connectés aux frames de programmes
42
Chapitre III : Sprint 2 : Tagging des Produits sur les Frames des Programmes
Diagramme de collaboration du « user story » : Ajouter un produit à un frame
de programme
L’agent de tagging sélectionne le programme déterminé qui a un frame associé et demande
l’affectation d’un produit bien déterminé.
Le système affecte le produit et affiche un message de succès.
Figure 41 : Diagramme de collaboration : Affectation d’un produit à un frame de programme
Diagramme de collaboration du « user story » : Détacher le produit du frame
du programme
L’agent sélectionne la liste des programmes et choisit l’un d’eux qui a un frame associé
auparavant. L’acteur demande de supprimer un produit déjà connecté à ce frame.
En réponse, le système retire le produit du frame de la liste des produits connectés aux frames
connectés à un programme et affiche un message de succès.
Figure 42 : Diagramme de collaboration : Détachement d’un produit d'un frame du programme
43
Chapitre III : Sprint 2 : Tagging des Produits sur les Frames des Programmes
III. Conception
1. Diagramme de classes du deuxième sprint : Tagging des
produis sur les « frames » des programmes
Figure 43 : Diagramme de classes du sprint 2
44
Chapitre III : Sprint 2 : Tagging des Produits sur les Frames des Programmes
2. Schéma de la base de données
Product (Id_product, ProductName, ProductDescription, ProductCode, ProductImage)
Program (Id Program, ProgramTitle, ProgramDescription)
ProductProgram (Id_Product_Program, #IdProduct, #Id_program)
ProgramFrame (id_program_frame, URL, #id_program, Time, Visibility)
ProgramFrameProduct (id_program_frame_product, #id_program_frame,
#id_product_program, x, y)
IV. Implémentation
1. Diagramme de composants
Diagramme de composants de la fonctionnalité « Association frames
et programmes »
Figure 44 : Diagramme de composants : Gestions des "frames" de programmes
45
Chapitre III : Sprint 2 : Tagging des Produits sur les Frames des Programmes
Diagramme de composants de la fonctionnalité « Connexion des produits
aux frames des programmes »
Figure 45 : Diagramme de composants de la fonctionnalité Gestion des produits connectés aux frames des programmes
2. Test
Test des services web
Figure 46 : Test des services web (Les frames d'un programme)
46
Chapitre III : Sprint 2 : Tagging des Produits sur les Frames des Programmes
Test de l’application
On récupe les « frames » liés à ce programme et on les introduit dans une Timeline avec un échèle du temps de visibilité.
Figure 47 : Test de l'application (récupération des frames et l'insertion dans une Timeline)
Processus de tagging :
1) Déplacer le produit voulu marquer vers les frames 2) Viser le lieu du tag3) Glisser le produit et le tag sera crée
Figure 48 : Test de l'application (Déplacer le produit)
47
Chapitre III : Sprint 2 : Tagging des Produits sur les Frames des Programmes
Figure 49 : Test de l'application (Création du tag)
Conclusion
Au cours de ce sprint, on a analysé, conçu et pu développer les fonctionnalités suivantes :
la gestion des « frames » de programmes et la gestion des « tags » des produits
sur les « frames ».
Dans le prochain sprint, on fera l’étude du groupement des produits.
Chapitre IV : Sprint 3 : Groupement des Produits
CHAPITRE IVSPRINT 3 : GROUPEMENT DES
PRODUITSIntroduction
Le 3ème sprint va nous permettre de regrouper des produits en différents groupes,
selon plusieurs taxinomies. On aura un groupe par le biais de sélectionner les tags en les
introduisant dans des ensembles qui auront un lien logique (personnage, décor, …).
Il y aura deux types de groupes : soit un « set » (un décor ou un lieu, une mise en scène),
soit une célébrité (un ensemble des produits que porte un personnage).
I. Spécification des besoins
1. Sprint Backlog
Notre Backlog sprint se présente comme suit :
Tableau 4 : Sprint Backlog du sprint 3
ID « User Story » id Tache
1 En tant qu’agent de tagging, je
veux ajouter un ou plusieurs
groupes.
1.1 Ajouter une classe Group dans le Web
API
1.2 Configurer la table « Group », grâce à
l’Entity Framework, la classe contexte
1.3 Ajouter la méthode d’ajout dans le
contrôleur de l’application qui
consommera le web services
1.4 Tester l’ajout des groupes
2 En tant qu’agent de tagging, je
veux modifier un groupe
déterminé.
2.1 Ajouter la méthode de la modification
dans le contrôleur de l’application client
2.2 Tester la modification des groupes
3 En tant qu’agent de tagging, je 3.1 Ajouter la méthode de la suppression des
49
Chapitre IV : Sprint 3 : Groupement des Produits
veux supprimer un groupe
déterminé.
groupes dans le contrôleur de
l’application client
3.2 Tester la suppression des groupes
4 En tant qu’agent de tagging, je
veux afficher la liste des groupes.
4.1 Ajouter la méthode de la récupération de
la liste des groupes
4.2 Tester la récupération de l’ensemble des
groupes
5 En tant qu’agent, je veux
consulter un groupe bien
déterminé
5.1 Ajouter la méthode de la récupération
d’un groupe bien déterminé
5.2 Tester la récupération des détails d’un
groupe
6 En tant qu’agent, je veux
sélectionner le type d’un groupe
6.1 Ajouter une classe GroupType dans le
Web API
6.2 Configurer la table « GroupType », grâce
à l’Entity Framework, la classe contexte
6.3 Tester la sélection
7 En tant qu’agent de tagging, je
veux affecter un groupe à une
célébrité
7.1 Ajouter une classe « Celebrity » dans le
Web API
7.2 Configurer la table « Celebrity», grâce à
l’Entity Framework, la classe contexte
7.3 Tester l’affection à une célébrité
8 En tant qu’agent de tagging, je
veux ajouter une célébrité
8.1 Ajouter la méthode d’ajout dans le
contrôleur de l’application qui
consommera le web services
8.2 Tester l’ajout des célébrités
9 En tant qu’agent de tagging, je
veux modifier une célébrité
déterminée.
9.1 Ajouter la méthode de la modification
dans le contrôleur de l’application client
9.2 Tester la modification des célébrités
10 En tant qu’agent de tagging, je
veux supprimer une célébrité
10.1 Ajouter la méthode de la suppression des
célébrités dans le contrôleur de
50
Chapitre IV : Sprint 3 : Groupement des Produits
déterminée l’application client
10.2 Tester la suppression des célébrités
11 En tant qu’agent de tagging, je
veux afficher la liste des
célébrités.
11.1 Ajouter la méthode de la récupération de
la liste des célébrités
11.2 Tester la récupération de l’ensemble des
célébrités
12 En tant qu’agent, je veux
consulter une célébrité bien
déterminée
12.1 Ajouter la méthode de la récupération
d’une célébrité bien déterminée
12.2 Tester la récupération des détails d’une
célébrité
13 En tant qu’agent de tagging, je
veux connecter un ou plusieurs
produits connectés à un frame de
programme à un groupe
13.1 Ajouter une classe « ProductGroup »
dans le Web API
13.2 Configurer la table « ProductGroup»,
grâce à l’Entity Framework, la classe
contexte
13.3 Ajouter la méthode d’affectation d’un
produit à un programme
13.4 Tester l’ajout des produits
14 En tant qu’agent de tagging, je
veux retirer un ou plusieurs
produits connectés d’un frame de
programme à un groupe
14.1 Ajouter la méthode de la suppression
d’un produit d’un programme
14.2 Tester la suppression
Du groupe
15 En tant qu’agent de tagging, je
veux voir les composants de
chaque groupe
15.1 Ajouter la méthode de la récupération des
composants du groupe
15.2 Tester la récupération
16 En tant qu’agent de tagging, je
veux tagguer le groupe
16.1 Tester le tagging
2. Prototypes d’interfaces
51
Chapitre IV : Sprint 3 : Groupement des Produits
Pour bien assimiler ses « users stories », on va exposer quelques prototypes qui expliciteront
les différentes fonctionnalités.
Sélection des tags
Figure 50 : Prototype d'interface 1
Si le groupe existait, on récupère la liste des groupes sinon on le crée
Figure 51: Prototype d'interface 2
Sinon on ajoute un nouveau groupe
52
Chapitre IV : Sprint 3 : Groupement des Produits
Figure 52 : Prototype d'interface 3
II. Analyse
Pour suivre une méthodologie basée sur le prototypage, on va traiter des fonctionnalités.
Donc on va collecter plusieurs « users stories » en une fonctionnalité bien déterminée.
1. Diagramme de Cas d’utilisation des fonctionnalités
Diagramme de cas d’utilisation de la fonctionnalité : « Gestion des groupes»
L’agent aura le privilège de manipuler et de gérer les groupes. Il pourra soit ajouter, modifier,
supprimer ou consulter la liste des groupes, ensuite il pourra choisir le type d’un groupe :
il pourra être soit une mise en scène (un décor : un cabinet de docteur) soit une célébrité (les
produits portés), le taggueur pourra aussi affecter ce groupe à une célébrité.
53
Chapitre IV : Sprint 3 : Groupement des Produits
Figure 53 : Diagramme de cas d'utilisation de la fonctionnalité : Gestion des groupes
Diagramme de cas d’utilisation de la fonctionnalité : « Gestion des célébrités »
Figure 54 : Diagramme de cas d'utilisation de la fonctionnalité : Gestion des célébrités
54
Chapitre IV : Sprint 3 : Groupement des Produits
Diagramme de cas d’utilisation de la fonctionnalité : « Gestion des groupes de
produits»
L’agent de tagging pourra ajouter un ou plusieurs produits connectés à un programme dans
un groupe bien déterminé, de plus, il peut éditer les produits d’un groupe en le détachant.
Figure 55 : Diagramme de cas d'utilisation de gérer les groupes de produits
2. Description du déroulement des « users stories » de cette
fonctionnalité : Diagrammes de collaboration
Diagrammes de collaboration liés à la fonctionnalité : Gestion des groupes
Diagramme de collaboration du « user story » : Ajouter un groupe
Le taggueur demande le formulaire d’ajout de groupe, le système affiche le formulaire, après
le taggueur remplit les champs nécessaires et clique sur le bouton « Add ».
Le système interagit et vérifie les données saisies et enregistre le nouveau groupe et affiche
un message de succès.
55
Chapitre IV : Sprint 3 : Groupement des Produits
Figure 56 : Diagramme de collaboration : Ajouter un groupe
Diagramme de collaboration du « user story » : Modifier un groupe
L’agent de tagging sélectionne un groupe déterminé pour le modifier, le système récupère
les données et affiche le formulaire de modification, ainsi l’agent édite les données et clique
sur le bouton « Edit » et le système vérifie les données saisies et enregistre le groupe modifié
et affiche un message de succès.
Figure 57 : Diagramme de collaboration : Modifier un groupe
Diagramme de collaboration du « user story » : Consulter les groupes
L’agent de tagging demande la liste des groupes et le système affiche la liste.
Figure 58 : Diagramme de collaboration : Consulter les groupes
56
Chapitre IV : Sprint 3 : Groupement des Produits
Diagramme de collaboration du « user story » : Supprimer les groupes
L’agent de tagging choisit le groupe à supprimer, le système affiche un message
de confirmation, ainsi l’acteur confirme son choix et le système supprime le groupe et affiche
un message de succès.
Figure 59 : Diagramme de collaboration : Supprimer des groupes
Diagramme de collaboration du « user story » : Sélectionner le type du
groupe
L’agent de tagging sélectionne le type de groupe, soit une célébrité soit une mise en scène.
Figure 60 : Diagramme de collaboration : sélectionner le type du groupe
57
Chapitre IV : Sprint 3 : Groupement des Produits
Diagramme de collaboration : Affecter un groupe à une célébrité
Lors de la création du groupe, le taggueur pourra affecter le groupe à une célébrité.
Figure 61 : Diagramme de collaboration : Affecter un groupe à une célébrité
Diagramme de collaboration : Tagger un groupe
Le taggueur pourra marquer un groupe en entier dans un « frame », il choisira le groupe,
il le glissera vers le « frame » et ainsi le groupe sera marqué par tous les « tags » que constitue
ce dernier.
Figure 62 : Diagramme de collaboration : Tagger un groupe
58
Chapitre IV : Sprint 3 : Groupement des Produits
Diagrammes de collaboration liés à la fonctionnalité : Gestion des célébrités
Ces scénarios seront identiques à ceux de la gestion des produits, des programmes et des
groupes, c’est pour cela ce n’est pas nécessaire de les répéter.
Diagrammes de collaboration liés à la fonctionnalité : Gestion des groupes de
produits
Diagramme de collaboration du « user story » : Affecter un produit à un
groupe
L’agent de tagging sélectionne le tag et l’affecte à un groupe bien déterminé de tel façon
contiendra un ensemble de tags, le système affiche un message de succès pour confirmer
l’affectation.
Figure 63 : Diagramme de collaboration : Affecter un produit à un groupe
Diagramme de collaboration du « user story » : Consulter les groupes des
produits
59
Chapitre IV : Sprint 3 : Groupement des Produits
L’agent de tagging demande la liste des produits de chaque groupe et le système affiche la
liste.
Figure 64 : Diagramme de collaboration : Consulter les groupes des produits
Diagramme de collaboration du « user story » : Détacher le produit du
groupe
L’agent consulte le groupe et sélectionne le produit à détacher du groupe, le système retire
le produit et affiche un message de succès.
Figure 65 : Diagramme de collaboration : Supprimer un produit du groupe
60
Chapitre IV : Sprint 3 : Groupement des Produits
III. Conception
1. Diagramme de classes du troisième sprint : Groupement des produits
Figure 66 : Diagramme de classes du 3ème sprint : Groupement de produits
61
Chapitre IV : Sprint 3 : Groupement des Produits
2. Schéma de la base de données
En suivant les règles du passage du schéma conceptuel au schéma relationnel, on optera ça :
Product (IdProduct, ProductName, ProductDescription, ProductCode, ProductImage)
Program (IdProgram, ProgramTitle, ProgramDescription)
ProductProgram (IdProductProgram, #IdProduct, #IdProgram)
ProgramFrame (id_program_frame, URL, #id_program, Time, Visibility)
ProgramFrameProduct (id_program_frame_product, #id_program_frame,
#id_product_program, x, y)
Group (id_group, GroupName, Color, #IdCelebrity, #Id_group_type)
GroupType (id_group_type, Label)
ProductGroup (id_product_group, #id_program_frame_product, #id_group)
Celebrity (id_celetbrity, FirstName, LastName, Birthday, Description, PersonalLife, Career,
Image)
62
Chapitre IV : Sprint 3 : Groupement des Produits
IV. Implémentation
1. Diagrammes de composants
Diagramme de composants de la fonctionnalité : « Gestion des groupes »
Figure 67. Diagramme de composants de la fonctionnalité : Gestion des groupes
Diagramme de composants de la fonctionnalité : « Gestion des Groupes de
produits »
Figure 68 : Diagramme de composants de la fonctionnalité : Gestion des groupes de produits
63
Chapitre IV : Sprint 3 : Groupement des Produits
Diagramme de composants de la fonctionnalité : « Gestion des célébrités»
Figure 69 : Diagramme de composants de la fonctionnalité : Gestion des célébrités
2. Test
Test des services web
Figure 70 : Test web services (récupérer les produits de chaque groupe)
Test de l’application
64
Chapitre IV : Sprint 3 : Groupement des Produits
Figure 71 : Test de l'application (Récupérer les groupes)
Figure 72 : Processus de sélection des tags
Figure 73 : Test de l'application (Affectation des tags à un groupe déjà disponible)
65
Chapitre IV : Sprint 3 : Groupement des Produits
Figure 74: Test de l'application (Gestion des célébrités)
Conclusion
Lors de ce sprint, on a analysé, conçu et pu développer les fonctionnalités suivantes :
la gestion des groupes, la gestion des célébrités et la gestion des groupes de produits.
Dans le prochain sprint, on fera l’étude de la réalisation de notre application.
66
Chapitre V : Réalisation
CHAPITRE V :RÉALISATION
Introduction
Étant la dernière dans notre projet, la partie de la réalisation est consacrée à la présentation
des outils utilisés ainsi que l’environnement de développement.
On expliquera éventuellement les choix techniques relatifs aux langages de programmation
et des outils utilisés et un aperçu sur les étapes effectuées pour réaliser tout cela.
Enfin on exposera quelques aspects de gestion de projet.
I. Environnement de développement
1. Environnement matériel
Notre application a été développée sur une machine DELL possédant les caractéristiques suivantes :
- Système d'exploitation : Windows 8.1 Professional 64-bit
- Processeur : Intel(R) Core(TM) i7-3537U CPU @ 2.00GHz, 2.49GHz
- Mémoire RAM : 8 Go
- Disque dur : 1 To
- Écran : 15,6 ”
67
Chapitre V : Réalisation
2. Environnement logiciel
Visual Studio 2013
C’est un environnement de développement intégré (EDI) de Microsoft. Il est utilisé pour développer des programmes informatiques pour Windows (OS Microsoft), ainsi que des sites Web, des applications Web et des services Web.
VS 2013 est l’avant dernière mise à jour du logiciel rendu disponible le
26 Juin 2013.
On a utilisé ce logiciel pour développer toute la solution : les services web et l’application
MVC qui les consommera.
SQL Server
Est un système de gestion de base de données
relationnelle développé par Microsoft. En tant que
serveur de base de données, il est un produit
logiciel dont la fonction principale est de stocker et
de récupérer les données demandées par d'autres
applications logicielles, que ce soit ceux sur le
même ordinateur ou celles en cours d'exécution sur
un autre ordinateur dans un réseau (y compris l'Internet).
Office 2013
C’est une suite de produits mis au point par Microsoft
Corporation qui inclut Microsoft Word, Excel, Access,
Publisher, PowerPoint et Outlook.
68
Chapitre V : Réalisation
On a utilisé un logiciel de cette famille pour rédiger le rapport et les procès-verbaux des réunions.
Microsoft Word
C’est un logiciel de traitement de texte qui
permet aux utilisateurs de taper
un texte dans un document et ajouter des
images, des cliparts, des diagrammes avec des
différents choix de polices ou de conception.
Les principaux formats de fichiers sont .doc et .docx.
Microsoft Project
Est un logiciel de gestion de projet développé et
commercialisé par Microsoft, qui est conçu pour
aider un gestionnaire de projet à élaborer
un plan, l'affectation des ressources à des tâches,
suivi des progrès, la gestion du budget, et l'analyse
des charges de travail.
Microsoft Visio
C’est une application de traçage de diagrammes et
des graphiques vectoriels et fait partie de la famille
Microsoft Office. Le produit a été introduit en 1992,
fait par la société « Shapeware ».
Il a été acquis par Microsoft en 2000. On peut avec
Visio créer des diagrammes de Gantt, des
réseaux de PERT ou encore des diagrammes UML.
69
Chapitre V : Réalisation
Sublime Text2
Il s’agit d’un éditeur de texte sophistiqué pour le code et le balisage.
Postman
C’est un outil puissant de test des services web, devenu un outil
incontournable pour de nombreux développeurs.
Balsamiq Mockups
C’est un outil de prototypage pour réaliser les
maquettes de votre site en mode collaboratif. Il
s’agit de mettre en forme les idées de votre projet
de manière visuelle pour qu’un développeur puisse
comprendre vos besoins.
II. Architecture
Le processus de l’application qui admet une architecture orientée service se fait comme suit :
La communication entre l'application web API (Framework des web services) et la base de
données se fait grâce à l'ORM Entity Framework.
Les web services de type REST consistent à des méthodes de type GET, POST, PUT
ou bien DELTE.
L'échange de données entre la partie cliente (Application web sous le patron MVC4)
et le web API se fait grâce au protocole moderne HTTP. Les données sont sous format JSON
ou XML.
Enfin, l’utilisateur aura la possibilité d’utiliser l'application à travers un navigateur.
70
Chapitre V : Réalisation
Figure 75 : Architecture de l'application
III. Choix technologiques
1. ASP.Net
C’est une technologie .net qui fait partie de
la plateforme Micrsosoft.NET. Elle permet la programmation
des applications web dynamiques ou des web services.
On a utilisé cette technologie pour développer toute la solution :
le service web et la partie cliente.
71
Chapitre V : Réalisation
2. Web API : RESTful
Le service web est un programme informatique permettant la communication.
On a choisi d’utiliser un service web de type REST (Representational State Transfer). Il s’agit
d’un moyen d'accéder aux documents et à ressources distantes selon une architecture
logicielle simple, représentée par une API. On appelle "RESTful" les sites utilisant ce modèle
de communication. [9]
Ce style utilise des standards en particulier :
- URI : REST se base sur les URI (Uniform Resource Identifier) afin d’identifier une
ressource. Ce qu’il permet d’avoir un système universel d'identification des éléments
de l'application.
- HTTP : (HyperText Transfer Protocol) : fournit toutes les opérations nécessaires
(GET, POST, PUT et DELETE) pour communiquer avec les systèmes distribués.
Get = afficher,
Post = créer,
Put = mettre à jour,
DELETE = supprimer
RESTful utilise multiples formats pour l’échange de données (XML, JSON, HTML…).
Dans ce projet on a utilisé comme format d’échange JSON (JavaScript Object Notation).
C’est un format léger d’échange de données, il est moins verbal et facile à lire ou à écrire pour
des humains. JSON est format textuelle indépendant de tous langages de programmation.
Donc ces propriétés font JSON un langage d’échange de données idéal.
3. Client : sous patron MVC
La partie cliente a été développée en asp.net aussi sous le patron de conception MVC (Model
View Controller)
Modèle : Il s’agit des données et de l’état de votre application web. En général, ces
données sont représentées par un ensemble de classes qui permettent d’accéder à une
base de données, mais les données pourraient tout aussi bien être stockées dans des
fichiers ou utiliser des services.
72
Chapitre V : Réalisation
Vue : C’est l’interface qui affichera les données, Il s’agira globalement de code
HTML et de CSS. Le but de la vue est de présenter les données issues du modèle mais
sans les modifier, sans en interpréter le contenu.
Contrôleur : il fait le lien entre la vue et le modèle. Le contrôleur gère les interactions
avec l’utilisateur et détermine quels traitements doivent être effectués pour une action
donnée.
Figure 76 : Architecture du patron MVC [10]
4. ORM
Pour faciliter les liaisons entre la base de données et les classes des objets, une nouvelle
technique c’est l’ORM. Il s’agit d’un mapping objet-relationnel (en anglais object-relational
mapping ou ORM) qui représente une technique de programmation informatique qui permet
la création d’une illusion d'une base de données orientée objet à partir d'une base de données
relationnelle tout en définissant des correspondances entre cette base de données et les objets
du langage utilisé. [11]
73
Chapitre V : Réalisation
5. Entity Framework
Entity Framework (EF) est un ORM qui permet aux développeurs .NET de travailler avec
des données relationnelles en utilisant des objets spécifiques.
Il élimine le fait d’écrire la plupart du code d'accès aux données
Ce schéma évoque les différentes méthodes de cet ORM.
Figure 77 : Les méthodes de l'ORM Entity Framework [12]
Code first : c’est le fait de générer la base de données à partir des classes,
cette méthode a un impact positif lors des mises à jour.
Comme on a déjà mentionné, la partie cliente développé en asp.net donc on utilisera les
langages de bases de la programmation web
6. Les langages de programmation
HTML 5 CSS3 :
HTML5 désigne la dernière version du langage de
développement web HTML. Il est généralement appris en
parallèle du CSS et plus précisément dans notre cas avec
le CSS3, ce dernier permet en effet d’animer des éléments
HTML tout en effectuant des rotations, des transitions ou
des changements.
C# :
74
Chapitre V : Réalisation
C’est un langage de programmation orienté objet développé
par Microsoft pour sa plateforme .NET.
JavaScript :
JavaScript est un langage de programmation de scripts
principalement utilisé dans les pages web interactives.
Ce langage permet une interaction avec l'utilisateur en fonction de
ses actions.
JQuery
C’est une bibliothèque JavaScript qui permet aux développeurs web
d'ajouter des fonctionnalités supplémentaires à leurs sites Web,
elle est très pratique et compatible avec tous les navigateurs
courants. Elle est créée pour faciliter l'écriture de scripts côté client
dans le code HTML des pages web.
Ajax
« Asynchronous Javascript And Xml » permet de construire
des applications Web et des sites web dynamiques interactifs sur le
poste client en se servant de différentes technologies, elle est une
méthode de construction d'applications interactives pour le Web
traitant les demandes des utilisateurs immédiatement.
Comme son nom l’indique Ajax combine plusieurs outils
de programmation, y compris JavaScript, HTML dynamique,
XML….
Bootstrap
75
Chapitre V : Réalisation
C’est une collection d'outils de création de sites et d'applications web.
Il contient HTML et modèles de conception à base de CSS pour
la typographie, des formes, des boutons, la navigation et d'autres
composants de l'interface, ainsi que des extensions optionnelles
JavaScript.
IV. Gestion de Projet
1. Tableau des taches effectuées
Cette figure montre les taches effectuées, la durée de travail et les dates de début et de fin
Figure 78 : Tableau des taches
2. Diagramme de Gantt
76
Chapitre V : Réalisation
Conclusion
Dans ce chapitre, on a présenté l'environnement matériel et logiciel du projet.
On a par la suite élaboré quelques artéfacts de la gestion d’un projet.
En effet, ce chapitre de la phase finale engendre la fin du cycle de vie du développement
de l'application. Tout de bon, on obtient le fruit du travail exécutable et prêt à utiliser.
77
CONCLUSION GÉNÉRALE
Ce rapport représente un fruit de travail réalisé au sein de la Startup Disrupt CK dans le cadre
d'un projet de fin d'études pour l'obtention du Licence Fondamentale en Informatique de
Gestion à l'Institut Supérieur de Gestion Tunis.
Durant cette période de stage, on a pu mettre en pratique les connaissances théoriques
acquises durant trois années d’études à l’ISG bien également nous on était confronté à
plusieurs difficultés concernant le monde de développement ainsi que la gestion d’un projet.
On a utilisé les méthodes agiles pour assurer le suivi et la gestion du projet et on a opté pour
la méthode Scrum qui est basée sur des sprints, dans le cas de ce rapport, on a effectué le
travail demandé en 3 sprints.
On a réparti nos sprints suivant cette subdivision : on a commencé à spécifier les users
Stories, ensuite on a exposé les diagrammes de cas d’utilisation liés aux fonctionnalités, puis
on a enchainé avec une description du déroulement des scénarios, à la suite on a évoqué la
conception et on a terminé par l’implémentation bouclée par des tests.
L’objet de ce projet de fin d’études était de concevoir et réaliser un module dans le projet
développé par Disrupt CK, l’application qui te permet de se synchroniser avec un film ou une
série, découvrir et obtenir les produits que vous aimez de la vidéo.
Le module traité dans ce rapport était le fait de regrouper des produits bien déterminés ayant
un lien (soit une célébrité, soit une mise en scène), et pour achever cette partie, on a fait
plusieurs taches telles que la gestion des programmes et l’association des produits grâce aux
tagging.
Cette application a été développée en ASP.NET adoptant une architecture orientée service.
Malgré les différents obstacles tels que les nouveaux langages non manipulés durant notre
cursus universitaire, on a pu apprendre à gérer les nouveaux outils en bâtissant des nouvelles
connaissances en matière de méthodologie de travail, programmation web et l’utilisation des
services WEB.
On a vécu certaines difficultés au début du stage vu que c’était la première expérience avec
SCRUM, on a consacré beaucoup de temps pour apprendre et maitriser cette méthodologie.
78
Ce modeste possède les critères demandés au début du stage, mais à mon avis manque une
touche pour améliorer l’expérience utilisateur (UX) car l’utilisateur nécessite une
manipulation plus facile et compréhensible.
On espère ainsi qu’on pourrait continuer ce travail et améliorer les résultats obtenus, on peut
améliorer le module effectué par les fonctionnalités suivantes :
Editer un logiciel ou une plateforme pour préparer les « frames » des vidéos
Lier des services e-commerces au projet
Réduire le temps d’attente et le temps de réponse en minimisant la complexité
algorithmique de la solution
Faire des suggestions des groupements de produits (aide décisionnelle)
Maintenant pour le projet en entier : on peut améliorer l’application en s’intéressant à certains
points :
Synchroniser avec le film en utilisant les reconnaissances faciales,
Ajouter un coin de ventes en enchères des produits des célébrités
Travailler avec les nouvelles technologies pour développer une application
multiplateformes (Xamarin)
Grace à cette expérience passée chez une nouvelle startup, l’esprit entrepreneurial est bien
éveillé après ce stage, on a aussi appris beaucoup de choses sur toutes les phases.
Ce projet est donc une source d’enrichissement technique, culturel, personnel et humain.
79
ANNEXES
ANNEXE 1 : Etude approfondie sur les méthodes agiles et la
méthode « Scrum »
Les méthodes agiles se reconnaissent toutes dans les valeurs suivantes :
Individus et interactions plutôt que processus et outils
Développement logiciel plutôt que documentation exhaustive
Collaboration avec le client plutôt que négociation contractuelle
Ouverture au changement plutôt que suivi d’un plan rigide
1. Les bases de la méthode Scrum
Planification du sprint : Elle s’appuie sur la planification de la « release » réalisée
en amont. La première réunion du sprint ne se limite pas à planifier, on y trouve les
activités suivantes (valider les « stories » du Backlog pris en compte dans le sprint,
concevoir les solutions, identifier et estimer les tâches, prendre des tâches par chacun
des membres de l’équipe …)
Revue du sprint : Elle permet de montrer les résultats du développement effectués au
cours du sprint, seule une version opérationnelle est montrée.
Rétrospective : Elle est faite en interne en équipe (avec la présence du Scrum Master),
l’objectif est de comprendre ce qui n’a pas bien marché dans le sprint, les erreurs
commises et de prendre des décisions pour s’améliorer.
Scrum quotidien : il s’agit d’une réunion de synchronisation de l’équipe
de développement qui se fait debout en 15 minutes maximum au cours de laquelle
chacun répond principalement à 3 questions :
1) Qu’est-ce que j’ai fait hier ?
2) Qu’est-ce que je ferai aujourd’hui ?
3) Quels obstacles me retardent ? [13]
80
2. Pourquoi Scrum ?
Scrum place l’humain au centre de la méthodologie. Le client intervient tout au long
du processus de création et l’équipe travaille en collaboration, et aussi parce que cette
méthode est idéale pour le cas d’une petite équipe et le fait d’avoir un grand projet réparti
entre cette équipe.
L’application de Scrum m’a permis de raccourcir les délais de production et d’avoir
un produit final qui correspond au plus près aux besoins du client.
81
ANNEXE 2 : Les règles de passage d’un modèle objet à un modèle
relationnel
L’utilisation d’un SGBDR impose un changement de représentation entre la structure
des classes et la structure des données relationnelles. [14]
Règle 1 : Une classe définit une structure de données à laquelle souscrivent des
instances ; elle correspond donc à une table du modèle relationnel.
Règle 2 : Chaque attribut donne lieu à une colonne.
Règle 3 : Chaque instance stocke ses données dans une ligne (T-uplet) et son OID sert
de clé primaire.
Règle 4 : Chaque association « un à plusieurs » est représentée par une clé étrangère
dans la table fille.
Règle 5 : Chaque association « plusieurs à plusieurs » entre deux classes est
représentée par une nouvelle table qui prend pour clé primaire la concaténation des
clés primaires des deux classes.
Règle 6 : Chaque association « un à un » est représentée par l’intégration d’une clé
étrangère dans la table la moins récente.
Règle 7 : Une classe association entre deux classes est représentée par une table qui
prend pour clé primaire la concaténation des clés primaires des deux classes.
82
RÉFÉRENCES
[1] Studyrama, 11 mai 2015.
[2] Z. Jallouli, Interviewee, étude de marché. [Interview]. 19 Mars 2015.
[3] «TunisiaIT,» [En ligne]. Available: http://www.tunisiait.com/article.php?article=14496. [Accès le février 15 2015].
[4] «Booblee,» [En ligne]. Available: www.booblee.com. [Accès le 2 Février 2015].
[5] C. Aubry, Le guide pratique de la méthode agile la plus populaire.
[6] «Affinity Software,» [En ligne]. Available: http://www.affinity-software.fr/v1/formations/les-methodes-agiles. [Accès le 15 Février 2015].
[7] «mountaingoatsoftware,» [En ligne]. Available: http://www.mountaingoatsoftware.com/agile/scrum/images. [Accès le 26 février 2015].
[8] P. Roques, UML 2 en action.
[9] «Openclassrooms,» [En ligne]. Available: http://openclassrooms.com/courses/les-services-web. [Accès le 15 mars 2015].
[10] «Architecture logicels,» [En ligne]. Available: www.3LFIG.e-monsite.com. [Accès le 17 Mars 2015].
[11] «inforapid,» [En ligne]. Available: http://fr.inforapid.org/index.php?search=Mapping%20objet-relationnel. [Accès le 2 Mars 2015].
[12] P. Praharaj. [En ligne]. Available: http://pallavipraharaj.blogspot.com/. [Accès le 2 Mars 2015].
[13] «Ineumann,» [En ligne]. Available: http://ineumann.developpez.com/tutoriels/alm/agile_scrum/. [Accès le 22 Février 2015].
[14] T. corporation, Conception des système d'information.
Top Related