Chapitre III : Sprint 2 : Tagging des Produits sur les Frames des

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


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



1. Diagramme de composants......................................................................................44

2. Test...........................................................................................................................45

CONCLUSION...................................................................................................................47

CHAPITRE IV...........................................................................................................................48

SPRINT 3 : GROUPEMENT DES PRODUITS........................................................................48

INTRODUCTION................................................................................................................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



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 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 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 51: Prototype d'interface 2.............................................................................................51


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


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


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


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


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


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


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


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


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é


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


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


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


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



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


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


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


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


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


supprimer un produit déterminé.

3.1 Ajouter la méthode de la suppression dans

le contrôleur du web services


le contrôleur de l’application client

3.3 Tester la suppression des produits


modifier un produit déterminé.

4.1 Ajouter la méthode de la modification

dans le contrôleur du web services


dans le contrôleur de l’application client



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



ajouter un ou plusieurs

programmes.

6.1 Ajouter une classe programme dans le

Web API

6.2 Configurer la table « program », grâce à


6.3 Ajouter la méthode d’ajout dans

l’application client qui consommera le

web service

6.4 Tester l’ajout des programmes


afficher la liste des programmes.


la liste des programmes


programmes


supprimer un programme

déterminé.


le contrôleur de l’application client

8.2 Tester la suppression des programmes


modifier un programme déterminé



9.2 Tester la modification des programmes


consulter un programme bien

déterminé

10.1 Ajouter la méthode de la récupération d’un

programme bien déterminé


programme


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


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


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.


la liste des produits connectés à un

programme


produits connectés à un programme

2. Prototypes d’interface

20


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 :


Récupérer un programme bien déterminé :

21



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


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


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


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


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


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


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


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


27


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


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


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


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


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


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


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.


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.


35


Tableau 3: "Sprint Backlog" du sprint 2



veux connecter un « frame » à un

programme.

1.1 Ajouter une classe

ProgramFrame dans le Web API

1.2 Configurer la table « ProgramFrame »,


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


veux retirer un Frame d’un

programme.

2.1 Ajouter la méthode de la suppression




veux activer l’utilisation des

« frames »

3.1 Tester l’activation


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.


veux associer un produit à

6.1 Ajouter la classe ProgramFrameProduct

6.2 Configurer la table

« ProgramFrameProduct », grâce à

36


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.


veux retirer un produit

d’un « frame » de programme.

7.1 Ajouter la méthode de la suppression.

7.2 Tester la Suppression.


veux visualiser les produits

connectés aux « frames » sous

forme de « tags »


des « tags »

8.2 Tester la récupération


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


Ajouter un nouveau frame à un programme bien déterminé


Visualiser les produits connectés à un programme et les frames :


38


L’affectation d’un produit à un frame qui résultera à un tag


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


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


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


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


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


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



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


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


Figure 46 : Test des services web (Les frames d'un programme)

46



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


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).


1. Sprint Backlog


Tableau 4 : Sprint Backlog du sprint 3



veux ajouter un ou plusieurs

groupes.

1.1 Ajouter une classe Group dans le Web

API

1.2 Configurer la table « Group », grâce à


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


veux modifier un groupe

déterminé.



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


veux supprimer un groupe

déterminé.

groupes dans le contrôleur de

l’application client

3.2 Tester la suppression des groupes


veux afficher la liste des groupes.


la liste des groupes


groupes

5 En tant qu’agent, je veux

consulter un groupe bien

déterminé


d’un groupe bien déterminé


groupe


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


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 à


7.3 Tester l’affection à une célébrité


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


veux modifier une célébrité

déterminée.



9.2 Tester la modification des célébrités


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


déterminée l’application client

10.2 Tester la suppression des célébrités


veux afficher la liste des

célébrités.


la liste des célébrités


célébrités


consulter une célébrité bien

déterminée


d’une célébrité bien déterminée

12.2 Tester la récupération des détails d’une

célébrité


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»,


contexte

13.3 Ajouter la méthode d’affectation d’un

produit à un programme

13.4 Tester l’ajout des produits


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


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


veux tagguer le groupe

16.1 Tester le tagging

2. Prototypes d’interfaces

51


Pour bien assimiler ses « users stories », on va exposer quelques prototypes qui expliciteront

les différentes fonctionnalités.

Sélection des tags


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



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


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


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


55


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é


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


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


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


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


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


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


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



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


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


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


Figure 70 : Test web services (récupérer les produits de chaque groupe)


64


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


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


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


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


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


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


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


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


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


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

http://www.futura-sciences.com/magazines/high-tech/infos/dico/d/internet-xml-3997/

http://dico.developpez.com/html/693-Economie-Microsoft.php

http://fr.wikipedia.org/wiki/Programmation_orient%C3%A9e_objet

http://fr.wikipedia.org/wiki/Langage_de_programmation

75


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


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.

Documents

Chapitre III : Sprint 2 : Tagging des Produits sur les Frames des