Rapport de projet

ExtractTweets

Etudiants :Stephen BAROANFlorian MASIPSuzy NZINGOULAAbdoul SY

Encadrants :Jérôme AZÉ

Pascal PONCELETJulien RABATEL

Master 1 Informatique (AIGLE – IMAGINA)

28 Janvier 2015 — 25 Mai 2015

Remerciements

Nous avons eu la chance, dans le cadre de notre formation en master informatique, d’être engagés dansla réalisation d’un projet enrichissant et instructif.

Nous tenons à remercier toutes les personnes impliquées dans la mise en place de ce projet. En particu-lier, nous souhaitons témoigner notre reconnaissance à nos encadrants : Jérôme Azé, Pascal Poncelet etJulien Rabatel pour la confiance qu’ils nous ont accordée pour la réalisation de ce projet. Nous voudrionségalement les remercier pour leur aide, leur écoute, ainsi que leur soutien devant toutes les difficultésauxquelles nous avons pu être confrontés tout au long de ce projet.

Nous souhaitons également remercier Mr Bourreau qui, lors de ses enseignements sur la gestion deprojet nous a inspiré sur l’organisation à mettre en place au sein de notre groupe et avec nos encadrants.

Table des matières

Remerciements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51 Cahier des charges . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

1.1 Contexte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71.2 Généralités . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71.3 Les principaux éléments en jeu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8

1.3.1 Scénario d’utilisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91.3.2 La base de données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91.3.3 L’interface utilisateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91.3.4 Le système de récupération et de stockage des tweets . . . . . . . . . . . 10

1.4 Les interactions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101.5 Les contraintes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10

2 Rapport technique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112.1 Analyse du projet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

2.1.1 Analyse des besoins, analyse du domaine et analyse applicative . . . . . . 112.1.2 Diagramme de cas d’utilisation . . . . . . . . . . . . . . . . . . . . . . . . 112.1.3 Diagramme UML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12

2.2 Technologies utilisées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132.3 Conception base de données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142.4 Conception interface . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152.5 Mécanisme global du site . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18

2.5.1 Structure du site . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 192.5.2 Génération des vues . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 202.5.3 Traitement des requêtes d’un utilisateur . . . . . . . . . . . . . . . . . . . 212.5.4 Traitement des requêtes utilisateurs avec AJAX . . . . . . . . . . . . . . 222.5.5 Communication entre l’interface Web et l’application Java . . . . . . . . 22

2.6 Conception application Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 232.6.1 UML Application Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . 242.6.2 Modalités d’accès à Twitter . . . . . . . . . . . . . . . . . . . . . . . . . . 242.6.3 Connexion à l’API Twitter avec twitter4j . . . . . . . . . . . . . . . . . . 252.6.4 Récupération des tweets . . . . . . . . . . . . . . . . . . . . . . . . . . . . 252.6.5 Connexion et insertion dans la base de données . . . . . . . . . . . . . . . 28

2.7 Analyse/Statistiques des tweets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 292.7.1 Nuages de mots . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 292.7.2 Évolution du nombre de tweets en fonction du temps . . . . . . . . . . . 31

2.8 Idées abandonnées et améliorations envisagées . . . . . . . . . . . . . . . . . . . . 333 Rapport d’activité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34

3.1 Méthode de gestion de projet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 343.1.1 Présentation de la méthode . . . . . . . . . . . . . . . . . . . . . . . . . . 343.1.2 Bilan d’utilisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34

3.2 Planification . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 353.2.1 Planning prévu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 353.2.2 Planning réel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35

Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36Bibliographie/Sitographie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37

3

Table des figures

1 Exemple de Tweet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62 Vue générale des composants du projet ExtractTweets . . . . . . . . . . . . . . . . . . . . 83 Diagramme de cas d’utilisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124 Diagramme UML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135 Page de lancement d’une recherche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 156 Page affichage des resultats . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 167 Interface web lancement d’une recherche . . . . . . . . . . . . . . . . . . . . . . . . . . . . 178 Interface Web ajout d’une bounding box . . . . . . . . . . . . . . . . . . . . . . . . . . . . 179 Interface Web partie resultats . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1810 Architecture MVC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1911 UML application java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2412 Parser un fichier Json en un objet java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2613 Récupération tweets géolocalisés avec l’API REST . . . . . . . . . . . . . . . . . . . . . . 2614 Récupération des codes d’accès Twitter Developers à partir de la base de données . . . . . 2715 Authentification au service twitter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2716 Connexion à la base de données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2817 Apercu d’un nuage de mots . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3018 Apercu des graphes de l’évolution du nombre de tweets en fonction du temps . . . . . . . 32

Table des Annexes

Annexe A - La classe vue (PHP) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38Annexe B - Mécanisme de routage de l’action demandée par l’utilisateur (PHP) . . . . . . . . . . . 39Annexe C - Récupération des données du formulaire de recherche (Javascript) . . . . . . . . . . . . 40Annexe D - Envoi des données avec AJAX . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41Annexe E - Fonction de validation d’une recherche (PHP) . . . . . . . . . . . . . . . . . . . . . . . 42Annexe F - Fonction d’exécution de l’application Java (PHP) . . . . . . . . . . . . . . . . . . . . . 43Annexe G - Une insertion dans la table des tweets (Java) . . . . . . . . . . . . . . . . . . . . . . . 44Annexe H - Planning prévisionnel - Liste des tâches . . . . . . . . . . . . . . . . . . . . . . . . . . 45Annexe I - Planning prévisionnel - Attribution des tâches dans le temps . . . . . . . . . . . . . . . 46Annexe J - Planning réel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47Annexe K - Manuel d’utilisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48

4

Introduction

De nos jours, les réseaux sociaux tiennent une place majeure dans la diffusion de l’actualité. Ils sontd’ailleurs parfois acteurs de cette actualité de par la mobilisation qu’ils peuvent amener. Notre utilisationdes réseaux sociaux a beaucoup changé ces dix dernières années. Ils sont en effet devenus omniprésentsau fil du temps et contribuent au développement d’une nouvelle forme d’expression. Expression quis’accompagne souvent de comportements décomplexés face à l’écran. Ces interfaces sociales sont devenuesun moyen d’expression plus libre et plus accessible pour beaucoup de personnes. L’étude de ces réseauxpeut donc apporter de nombreuses informations à la fois sur la mise en place d’une pensée collective maiségalement sur des messages plus singuliers et ponctuels.

L’application de ces études peut se retrouver dans divers domaines, notamment dans la détection dessuicides ou des situations de harcèlement.

Une autre application de l’étude des flux de statuts sur les réseaux sociaux est l’étude de la propagationou l’étendue des épidémies comme la grippe.

Ce genre d’outils peut également servir à suivre les tendances politiques selon les régions par exemple.

Tous ces exemples montrent bien l’utilité du développement d’outils accessibles pour l’étude et le suivi desstatuts sur les réseaux sociaux. Ils peuvent être d’une grande utilité dans les recherches comportementalesdes sociétés.

Twitter 1, de l’anglais « gazouiller », « jaser » est l’un des réseaux les plus en vogue depuis ces cinqdernières années. Fondé en 2006 par Jack Dorsey, Evan Williams, Biz Stone et Noah Glass, Twitter peutêtre vu comme le mélange d’un blog, d’un tchat public, d’un réseau social et d’une plateforme d’échangede SMS. Le principe est de poster de manière publique (par défaut) et asymétrique, des statuts d’unetaille maximum de 140 caractères appelés des tweets (voir un exemple figure 1). Chaque utilisateur a lapossibilité de s’abonner aux personnes qu’il souhaite suivre, il verra donc sur son mur d’actualités tousles postes de ces personnes.

1. https ://twitter.com/

5

Figure 1 – Exemple de Tweet

Twitter est une application très facile à utiliser, il est pris en main même par les plus jeunes. Parce biais, il est possible d’acceder à la publication de nombreuses données mises à disposition du publicpar défaut. De ce fait, Twitter est une véritable source d’informations qui peut apporter de nouvellesconnaissances sur la société dans différents domaines d’études.

Une API a été mise en place par Twitter, permettant d’interroger sa base de données, de récupérer desinformations concernant les tweets et de poster des tweets. Deux méthodes principales sont utilisées dansce cadre, on parlera de l’API REST qui permet de faire des requêtes sur les tweets déjà présents dansla base de données, et de l’API STREAMING qui permet d’accéder au flux de tweets en temps réel demanière continue.

Notre projet a pour but le développement d’un outil assistant l’étude du flux de statuts circulantsur Twitter. Plus précisément, notre but est la réalisation d’une plateforme d’extraction de tweets, quipermettra ensuite l’analyse de ces derniers.

Pour présenter ce projet, nous détaillerons dans un premier temps les différents objectifs ainsi queles contraintes liées à la diversité des outils utilisés. Dans un second temps, nous détaillerons l’aspecttechnique de chaque partie de la conception. Puis dans un troisième temps, nous nous pencherons surl’organisation mise en place autour du projet.

6

1 Cahier des charges

1.1 Contexte

Le LIRMM (Laboratoire d’Informatique, de Robotique et de Microélectronique de Montpellier) futcréé en 1992, et résulte d’un projet commun entre le CNRS et l’Université de Montpellier. A dominanceinformatique, le laboratoire se divise en plusieurs équipes opérant dans divers domaines tels que l’optimi-sation des calculs, des algorithmes, ou encore le génie logiciel. L’une des équipes du LIRMM, ADVANSE(ADVanced Analytics for data SciencE) s’intéresse en particulier à la fouille de données et à l’extractionde connaissances, en axant ses recherches autour de la santé et l’environnement. Quelques-uns des projetsde l’équipe concernent notamment les réseaux sociaux, par exemple les projets Web Report portant surla détection des catastrophes naturelles dans les tweets et Polop qui s’intéresse aux échanges de tweetssur les différents partis politiques. Autre exemple, la réalisation d’un démonstrateur de suivi du virus dela grippe. Tous ces projets impliquent la récupération, le suivi et l’analyse de données massives.

C’est dans ce contexte que s’intègre notre projet permettant l’extraction d’une grande quantité de donnéesainsi que leur analyse afin de pouvoir les présenter de façon exploitable. Notre support, le réseau socialTwitter, est un choix stratégique car il est très populaire et réactif.

L’utilisation massive de Twitter en fait un véritable outil d’études sur les sociétés dans divers domaines.En effet, Twitter permet de se tenir informé en temps réel de ce qui se passe, le service est très utilisépar les journalistes car chacun peut y raconter ce dont il est témoin, ces journalistes y répercutent lesinformations vérifiées plus rapidement que sur les médias traditionnels. Bien entendu, la prudence et lavérification des sources s’imposent car il y a aussi des cas de propagations de rumeurs.

Twitter permet de suivre un sujet ou un centre d’intérêt précis, d’être tenu informé des dernières nou-veautés, des derniers articles parus, des projets en cours. . . On peut ainsi réaliser une veille ciblée, sur lesproblématiques diverses, en participant à une analyse collective faite par des personnes intéressées par lesujet.

Notre projet consiste donc à fournir un outil permettant la récupération et l’analyse de tweets selondifférents critères. Il pourra servir par exemple, à l’analyse des émotions grâce à des outils développés auLIRMM. Nous allons explorer les généralités concernant le cœur du projet ExtractTweet.

1.2 Généralités

Le but de ce projet est de mettre au point une application indépendante par laquelle il sera possibled’entrer des critères de recherche (exemples : mots-clés, géolocalisation etc..) parmi le flux de tweetsdiffusés en temps réel, et de visualiser de façon claire et pertinente, les résultats de cette recherche. Cetteapplication devra permettre de créer un compte pour chaque utilisateur avec une base de données et desrecherches propres à chacun.

Ce projet peut être découpé en deux grandes parties. Une première partie concernant la récupération detweets à partir de critères choisis par l’utilisateur, et une seconde partie consistant à présenter les tweetsrécupérés pour en tirer des informations pertinentes et les présenter de la façon la plus utile possible.

La première étape consistera donc à mettre au point une interface permettant à l’utilisateur d’entrer lescritères de recherche qu’il souhaite.

7

La récupération des tweets nécessite une communication avec l’API Twitter, ce dialogue sera géré parune application mise en place à cet effet et codée en Java. Une fois les tweets récupérés, il est importantde pouvoir les stocker.

Comme nous le verrons plus loin, la base de données tient un rôle central car elle coordonne à la fois lescritères de recherche, les informations à récupérer et les résultats à renvoyer.

Figure 2 – Vue générale des composants du projet ExtractTweets

La figure 2 décrit les différents modules mis en place dans ce projet. Nous allons voir que ces modulessont tous inter-connectés et interagissent à plusieurs niveaux.

1.3 Les principaux éléments en jeu

Afin de mieux comprendre le but et l’utilité de l’application développée, nous avons établi un cas d’uti-lisation concret. Nous reviendrons ensuite sur le rôle joué par chacun des modules présentés sur la figure2.

8

1.3.1 Scénario d’utilisation

Un utilisateur souhaite connaître l’opinion publique à propos de Nicolas Sarkozy en France et faire lacomparaison avec les USA. Il décide donc de se servir de l’application que nous avons développée. Lapremière étape est de s’enregistrer sur le site Twitter Developpers afin d’acquérir les codes d’accès requispour l’interrogation de la base données de Twitter.

Une fois les codes d’accès acquis, l’utilisateur peut maintenant se créer un compte sur notre applicationen fournissant un login et un mot de passe. Une fois enregistré dans notre base de données, l’utilisateurpeut lancer une recherche en choisissant l’API REST avec par exemple pour mot-clé Sarkozy et pourgéolocalisation la France. Pour la géolocalisation, l’utilisateur crée une “Bounding Box” (zone définissantles régions du monde) qui sera enregistrée sur l’interface et pourra être réutilisée ultérieurement. Il peutensuite lancer une deuxième recherche en changeant uniquement la géolocalisation qui sera cette fois auxUSA.

Par la suite, l’utilisateur se rend sur l’onglet résultats pour observer les recherches lancées. L’observationdu nuage de mots le renseigne sur la tendance des avis, il peut ainsi comparer les termes les plus utilisésconcernant Nicolas Sarkozy et se faire une idée de sa popularité au sein des Tweeteurs. L’observation desgraphiques peut également le renseigner sur l’évolution du nombre de tweets en fonction du temps surce sujet. Il pourra ainsi se rendre compte de l’intérêt de la population en France comme aux USA, pourNicolas Sarkozy.

Voyons maintenant le rôle de chaque module.

1.3.2 La base de données

La base de données est le pivot central permettant de coordonner les autres éléments. En effet, lorsqueles tweets sont récupérés depuis l’application Twitter, ils sont ensuite insérés dans la base de données.Dans un second temps lorsque l’on souhaite consulter les résultats d’une recherche, ces résultats sontextraits de la base de données.

La base de données doit être pensée de façon à pouvoir répondre aux exigences suivantes :— elle doit permettre de réaliser suffisamment de recherches possibles pour couvrir les besoins d’uti-

lisateurs différents. En effet, l’application sera utilisée par différentes équipes et donc différentsdomaines d’études. Certains travailleront sur les aspects géolocalisation, d’autres plutôt sur l’évo-lution de l’utilisation de mots-clés/hashtags, d’autres encore sur les liens following/followed entreutilisateurs de Twitter, etc

— elle doit permettre le stockage d’un maximum d’informations car on ne peut pas faire beaucoupd’hypothèses a priori sur ce qui sera important pour l’utilisateur

1.3.3 L’interface utilisateur

Il s’agit d’une interface Web chargée de récupérer les choix de l’utilisateur parmi les paramètres derecherche à remplir. L’interface doit avoir un graphisme simple et clair permettant une prise en main ra-pide. Pour la partie résultats elle doit permettre d’accéder rapidement à différents types d’informations,de classements. Ces informations seront exploitées à des fins diverses, il faut donc pouvoir s’adapter àchaque type de requêtes. L’interface permettra également à l’utilisateur de créer son propre compte et degérer les recherches associées à celui-ci.

9

1.3.4 Le système de récupération et de stockage des tweets

L’objectif ici est de trouver une solution permettant de récupérer toutes les données pouvant êtreextraites des tweets et les insérer dans la base de données.Pour combler ce besoin, nous avons réalisé une application Java utilisant la librairie twitter4j que nousdécrirons plus loin. Cette librairie nous permet, grâce aux codes d’accès délivrés par Twitter, d’accéderau flux continu de tweets diffusés sur la toile. Le système doit donc se charger de filtrer ses résultats etd’en tirer les informations à stocker dans la base de données.

1.4 Les interactions

Comme le montre la figure n°2 les interactions se font à différents niveaux, que l’on peut voir de manièrechronologique dans le cas général :

— Interface utilisateur (côté critères) - Base de données— Interface utilisateur (côté critères) - Système de récupération des tweets— Système de récupération (application Java) - Twitter)— Système de récupération (application Java) - Base de données— Base de données - Interface utilisateur (côté résultats)

L’interface utilisateur est la première vue en jeu lors de l’utilisation de l’application. Cette dernière doittransmettre les critères sélectionnés au système de récupération des tweets. Cette transmission se fait àl’aide d’un fichier écrit dans un format particulier et contenant l’ensemble des paramètres de recherchechoisis par l’utilisateur.

Le système de récupération de tweets doit quant à lui communiquer avec Twitter afin de pouvoir récupérerles informations demandées dans le fichier transmit par l’interface utilisateur. Le système de récupérations’occupe ensuite du stockage des informations dans la base de données.

Enfin, lorsque l’utilisateur veut voir les résultats de sa recherche, l’interface les récupère depuis la basede données pour ensuite les présenter de la façon la plus ergonomique et utile possible.

1.5 Les contraintes

Les contraintes de ce projet résident essentiellement dans la multitude des outils utilisés ce qui aboutitbien souvent à des problèmes de compatibilité parfois difficiles à gérer. En effet, chacun des modulesprésentés sur la figure n°2 nécessite l’utilisation de langages et d’outils différents. Cependant chacun desmodules est interconnecté avec les autres, il a donc fallu à plusieurs niveaux gérer ces interactions.

10

2 Rapport technique

Le rapport technique qui suit vous permettra d’avoir davantage de détails quant à la conception del’application. Vous trouver, en complément de cette section, un manuel d’utilisation de l’application enannexe K.

2.1 Analyse du projet

2.1.1 Analyse des besoins, analyse du domaine et analyse applicative

Étant la première étape de réalisation du projet, l’analyse des besoins a été déterminante pour la bonnecompréhension des enjeux du projet, pour notre organisation, et surtout pour la conception du projet.En effet, cette phase nous a permis de poser les bases de notre projet.

Le projet consistait à mettre en place une plate-forme d’extraction de tweets servant à extraire des tweetsfourni par Twitter et effectuer des statistiques sur les données récupérées. À l’issue de cette analyse, nousavons effectué le diagramme de cas d’utilisation et le diagramme de classes UML (qui servira à mettreen place la base de données).

2.1.2 Diagramme de cas d’utilisation

Après avoir bien compris le sujet du projet, nous avons entamé sa conception par la mise en place denotre diagramme de cas d’utilisation. Celui-ci est représenté par la figure ci-dessous :

Comme vous pouvez le constater sur ce diagramme, l’acteur principal pour notre application est l’uti-lisateur. En effet, il peut :

— S’inscrire— Se connecter— Ajouter un compte “Twitter Developers” en précisant les codes d’accès qui serviront pour effectuer

les différentes recherches— Ajouter un compte “Twitter Developers” en précisant les codes d’accès qui serviront pour effectuer

les différentes recherches— Effectuer des recherches étant connecté en précisant les mots clés, hashtag et/ou autres critères,

l’API de recherche ; c’est-à-dire l’API Twitter qui servira à la recherche (REST ou STREAMING),le compte « Twitter Developers » et éventuellement préciser le nombre maximum de tweets et/oula plage horaire des tweets pour la recherche

— Consulter les résultats des recherches qu’il a effectuées et s’il le souhaite, afficher la positiongéographique des tweets qui sont géolocalisés.

Les différents types de recherches sont : la recherche de tweets géolocalisés et la recherche de tweetsd’un utilisateur (éventuellement des tweets d’un utilisateur répondant à un autre).

11

Figure 3 – Diagramme de cas d’utilisation

2.1.3 Diagramme UML

À la suite de quelques réunions entre les membres du groupe et les encadrants, nous avons établi undiagramme de classe UML qui a évolué au cours du développement du projet. Le diagramme final seprésente comme suit :

Ce diagramme contient :— Une classe UserApp qui contient les informations sur l’utilisateur— Une classe InfoUserApp qui contient les informations sur les comptes “Twitter Developers” que

l’utilisateur a ajouté— Une classe SearchParameters qui contient les critères de recherche— Les classes Keyword et Hashtag qui sont liées à la classe SearchParameters car ce sont des

critères de recherche et qui contiennent respectivement les mots clés et les “hashtags”. Ces classesont été mises en place afin d’éviter les duplications. En effet plusieurs recherches peuvent êtrelancées avec un même mot clé/hashtag (qui sera donc lié à chacune des ces recherches à traversson id)

— Une classe BoundingBox qui contient les informations nécessaires à la recherche de tweets géo-localisés

— Une classe Tweet qui contient les informations nécessaires d’un tweet— Une classe UserTweet qui est liée à la classe Tweet car elle contient les informations sur l’utili-

sateur ayant posté le tweet— Une classe Place qui est aussi liée à la classe Tweet. Elle contient les informations de géolocalisation

du tweet

12

Figure 4 – Diagramme UML

2.2 Technologies utilisées

Pour la réalisation du projet, nous avons décidé avec les conseils de nos encadrants d’utiliser les différentsoutils suivants :

Interface Web

— HTML5 : Le HTML5 est le langage utilisé pour la représentation des pages Web. Le HTML5comprend de nouvelles balises et de nouveaux attributs pour les pages Web et ouvre de nouvellespossibilités de développement pour les sites mobiles.

— CSS3 : Le CSS3 est utilisé pour la mise en forme des pages HTML.— Bootstrap : Pour la réalisation de l’interface utilisateur, nous avons utilisé ce framework CSS

permettant l’utilisation de classes prédéfinies, utilisant nativement JQuery pour créer par exempledes menus animés. Cet outil nous a été d’une grande aide pour une mise en forme propre et rapideà réaliser.

— PHP : Du côté de l’interface, pour gérer la connexion et l’envoi des requêtes SQL à la base dedonnées, nous avons utilisé l’extension Pg (PostgreSql) de PHP.

— JavaScript/JQuery : Pour adapter notre interface dynamiquement selon les choix de l’utilisateurnous avons utilisé la bibliothèque JQuery, nous permettant d’accéder à tous les objets du DOM dela page et nous permettant de les manipuler (utilisation autorisée ou non, adaptation du contenu).

— AJAX : Afin de rester dans notre optique d’une interface dynamique, nous avons utilisé la méthodeAjax de Javascript (à partir de JQuery) qui permet une communication de manière asynchroneentre le serveur et la page sans avoir à la recharger.

— Xampp : Ce logiciel d’assistance au développement de site Web nous permet de tester notre siteWeb contenant du code PHP sans utiliser un serveur distant.

Base de données

— PgAdmin : C’est la plateforme d’administration et de développement libre la plus populaire etla plus riche pour PostgreSQL. Elle nous permet de gérer notre base de données.

13

Application Récupération de tweets

— Java : Pour gérer la récupération des tweets et les différentes insertions dans la base de données.

2.3 Conception base de données

Nous avions décidé d’utiliser MySQL comme système de gestion de base de données mais suite àquelques contraintes, nous nous sommes redirigés vers PostgreSQL qui est un système de gestion de basede données relationnelle et objet (SGBDRO).

Pour la création de la base de données, nous nous sommes basés sur le diagramme de classes UML. Cequi donne un modèle relationnel qui se présente comme suit :

— UserApp(id_ut, first_name, last_name, login, password, date_of_registration,language)— InfoUserApp(id_iua, consumer_key, consumer_secret, access_token, acces_token_secret, ac-

count_name)— SearchParameters(id_sp, search_title, hour_min, hour_max, search_date, nb_retweet_min,

nb_retweet_max, nb_tweet,user_list, in_reply_to, all_info)— Keyword(id_kw, language, word)— Hashtag(id_ht, hashtag)— BoundingBox(id_bb, title, longitude1, latitude1, longitude2, latitude2, radius, unit, center_longitude,

center_latitude)— Tweet(id_tweet, date_tweet,current_user_retweeted_id, favorite_count, longitude, latitude,

in_reply_to_status_id, in_reply_to_user_id, language, retweeted_count, text,is_retweet, is_retweeted,is_retweeted_by_me, is_truncated, all_info, scope, id_place,user_id)

— Place(id_place, bounding_box_coordinates, geometry_coordinates, bounding_box_type, geo-metry_type, country, fullname, country_code, name, place_type, street_adress, url)

— UserTweet(id_user, created_at,description, favorites_count, followers_count, friend_count, lis-ted_count, location, name, screen_name, is_geo_enabled, is_veridied)

— Location(sp_id, bb_id)— Contain(sp_id, kw_id) : cette relation associe les mots clés aux recherches— Contain1(sp_id, ht_id) : cette relation associe les hashtags aux recherches. Elle ressemble à la

relation précédente (d’où le nom Contain1).— Search(tweet_id, sp_id)— Search1(iua_id, ut_id, sp_id,process) : cette relation permet de spécifier qu’un utilisateur ef-

fectue une recherche avec son compte et le compte «Twitter Developers » (d’où le nom Search1).L’attribut “process” contient le pid du processus de l’application java associé à une recherche.

Ce modèle relationnel a permis de créer les différentes tables de la base de données qui serviront au bonfonctionnement des différentes branches du projet.

14

2.4 Conception interface

Pour débuter la conception de l’interface nous avons d’abord réalisé des maquettes de chaque page àl’aide du logiciel de modélisation balsamiq 2. Plusieurs maquettes ont été proposées, après négociationsavec nos encadrant nous avons décidé de conserver les modèles présentés ci-dessous.

Les principales pages de l’application Web sont :

— la page de lancement d’une recherche (cf. figure 5)

Figure 5 – Page de lancement d’une recherche

2. https ://balsamiq.com/

15

Cette page permettra à l’utilisateur de rentrer les critères de son choix, une fois la sélection faite, envalidant, une recherche est lancée et ainsi enregistrée dans la base de données.

— la page de consultation des résultats (cf. figure 6)

Figure 6 – Page affichage des resultats

Cette page doit comprendre l’affichage de toutes les recherches lancées par l’utilisateur ainsi qu’unevisualisation des résultats (tweets) et des outils permettant d’analyser les informations liées à leur contenupar exemple.

L’objectif principal pour chaque page était de centraliser toutes les informations pour avoir un aperçuglobal et pour pouvoir par exemple, pour la page résultats, analyser les différentes données et les comparerentre elles.

Avec l’utilisation du framework Bootstrap croisée avec JQuery, il a été possible d’intégrer de nombreusesfonctionnalités aussi pratiques qu’esthétiques. Pour ce qui est de la page de lancement d’une recherche,de nombreuses modifications ont été effectuées au fur et à mesure de l’avancement du projet. En effetcette partie de l’interface est étroitement liée avec la base de données et l’application Java, plusieurschangements ont donc eu lieu en parallèle de l’évolution de ces différents acteurs.

16

Voici la version finale de la partie lancement de recherche :

Figure 7 – Interface web lancement d’une recherche

Parmi ces fonctionnalités, l’utilisation de zones prédéfinies (Bounding Box) pour la géolocalisation anécessité une attention particulière. En effet, nous avons, pour cet outil, fait appel à la librairie, dévelop-pée par Google, utilisant GoogleMap qui permet de pouvoir sélectionner une zone géographique de formerectangulaire ou circulaire sur le globe.

Cette zone est définie par ses coordonnées latitudinales et longitudinales, voir figure ci-dessous :

Figure 8 – Interface Web ajout d’une bounding box

17

Pour ce qui est de la partie résultats, comme le montre la figure 9, l’interface s’est complexifiée du faitde la quantité d’éléments à afficher et de l’exploitation des données en sortie. En effet, le but ici est d’avoirun maximum d’informations avec un minimum de manipulations. Le but étant que les informations soientpresque toutes visibles du premier coup d’œil, et pour celles qui ne le sont pas qu’elles soient accessiblestrès facilement.

Figure 9 – Interface Web partie resultats

Pour cette partie de l’interface, la plus grande difficulté fut la gestion de l’espace. Pour cela nous avonsusé de plusieurs astuces. Par exemple, le panneau latéral est rétractable et permet de lister l’ensemble desrecherches lancées et leur état (en cours ou terminées). De même, la partie centrale contient les tweetsrécupérés qui sont classés par page que l’on peut faire défiler à notre convenance. Autre exemple, lamise en place d’un nuage de mots permettant de mettre en évidence les thèmes les plus abordés liés à larecherche sélectionnée. Le graphique quant à lui donne une information pertinente sur la répartition destweets dans le temps.

2.5 Mécanisme global du site

Nous avons décidé d’utiliser le pattern MVC (Model View Controller) pour avoir un code clair et bienstructuré. En effet le MVC a pour rôle principal de séparer la logique du code en 3 parties distinctes :

— Le modèle, cette partie gère les données. Son rôle est d’aller récupérer les informations « brutes» dans la base de données, de les organiser et de les assembler pour qu’elles puissent ensuite êtretraitées par le contrôleur. On y trouve donc les requêtes SQL.

— La vue, cette partie se concentre sur l’affichage. Elle ne fait presque aucun calcul et se contentede récupérer des variables pour savoir ce qu’elle doit afficher. On y trouve essentiellement du codeHTML mais aussi quelques boucles et conditions PHP très simples, pour afficher par exemple laliste des recherches d’un utilisateur.

18

— Le contrôleur , cette partie gère la logique du code qui prend des décisions. C’est en quelquessortes l’intermédiaire entre le modèle et la vue : le contrôleur va demander au modèle les données,les analyser, prendre des décisions et renvoyer le texte à afficher à la vue. Le contrôleur contientexclusivement du PHP. C’est notamment lui qui détermine si le visiteur a le droit de voir la pageou non (gestion des droits d’accès).

Figure 10 – Architecture MVC

Comme l’illustre ce schéma (figure 10), l’utilisateur s’adresse au contrôleur du site. Le contrôleur vainterroger le modèle qui se chargera de lui renvoyer les informations adéquates. Le contrôleur retourneensuite à la vue les informations demandées par l’utilisateur.

Nous avons également décidé d’utiliser la programmation orientée objet en PHP pour tirer parti desavantages qu’elle nous offre tels que l’encapsulation, l’héritage . . . Cela permettra lors d’une évolutionfuture de notre site une meilleure gestion du code. En effet, si des fonctionnalités doivent être ajoutées,il suffira de créer de nouvelles classes qui s’appuieront sur les services communs de classes déjà présentes.

Nous avons donc combiné Architecture MVC et Programmation Objet lors de ce projet.

2.5.1 Structure du site

Le dossier racine du site sera composé de plusieurs dossiers :— Un dossier Models qui comportera tous les fichiers PHP du ou des modèle(s) :

— Model.php, qui est une classe abstraite, elle possède l’ensemble des méthodes permettant laconnexion à la base de données, les méthodes permettant de préparer et d’exécuter des requêtes.

— Search.php extends Model.php possède l’ensemble des requêtes utiles pour récupérer, afficher,modifier et insérer des recherches.

— BoundingBox.php extends Models.php possède l’ensemble des requêtes utiles pour récupérer,afficher, modifier et insérer des Bounding Box.

— Tweet.php extends Models.php possède l’ensemble des requêtes utiles pour recuperer les in-formations sur un tweet.

19

— InfoUserApp.php possède l’ensemble des requêtes utiles pour récupérer, afficher, modifier etinsérer des informations sur les comptes «Twitter Developers» des utilisateurs.

— UserApp.php possède l’ensemble des requêtes utiles pour récupérer, afficher, modifier et in-sérer des comptes utilisateur pour l’interface Web.

— Un dossier Controlers pour les fichiers PHP destinés aux contrôleurs :

— Controler.php qui est une classe abstraite, elle permettra de démarrer une session php(session_start()), elle possède un attribut qui sera la vue, ainsi qu’une méthode permettant lagénération d’erreur.

— ControlerUser.php, extends Controler.php, possède l’ensemble des méthodes utiles pourl’inscription, la connexion et déconnexion d’un utilisateur, également pour créer, afficher etrécupérer des recherches désirées par un utilisateur. Ces méthodes interagissent avec le Modelpour récupérer les données voulues et ensuite les envoyer à la vue de l’utilisateur.

— Un dossier Views pour l’ensemble des vues du site :

— gabarit.php : Regroupe l’ensemble des éléments commun à toutes les pages— Vue.php : La classe vue— VueHeader.php : l’entête du site.— VueResults.php : la vue qui affiche les résultats des recherches.— VueRecherche : la vue permettant de créer des recherches.— VueInscription.php : la vue pour l’inscription d’un utilisateur.

— Un dossier Public contenant les fichiers tels que les feuilles de style CSS, les scripts JavaScripts,les bibliothèques.

— Un dossier SSAFJavaAppli qui contiendra le fichier exécutable (jar) de l’application Java.

— Un dossier Admin2015 qui contiendra les logs de l’application Java.

— Un fichier config.PHP qui contiendra toutes nos variables globales.

2.5.2 Génération des vues

La génération des vues se fait grâce à une factorisation du contenu global des pages. Nous avons ungabarit qui centralise les éléments d’affichage communs aux différentes pages, et des variables PHP pourinsérer des éléments spécifiques tel que le titre de la page par exemple.

Le constructeur de Vue reçoit comme paramètre le fichier Vue à utiliser. La méthode genererFichier()encapsule l’utilisation de require et permet en outre de vérifier l’existence du fichier vue à afficher. Cetteméthode utilise la fonction extract afin que la vue puisse accéder aux variables PHP requises, ces variablessont rassemblées dans le tableau associatif $donnees (cf. annexe A).

20

La méthode generer() a pour rôle principal de générer la partie spécifique de la vue afin de définir parexemple son titre (attribut $titre) , son contenu ($contenu). Ce mécanisme permet donc d’initialiser legabarit en fonction de l’action demandée par l’utilisateur.

2.5.3 Traitement des requêtes d’un utilisateur

Toute personne entrant pour la première fois sur notre site passe par l’index PHP qui se situe à la racinede notre site. Notre index PHP redirige l’utilisateur vers l’accueil grâce à l’appel d’une méthode du Contro-leurUser « afficherAccueil () » header(’location : Controlers/ControleurUser.php ?action=afficherAccueil’) ;

Comment ce contrôleur se charge-t-il de récupérer l’action demandée par l’utilisateur présent sur le site ?

L’action est envoyée dans l’URL par la méthode GET, le tableau $_GET est analysé dans notre contrô-leur (user). Si $_GET[‘action’] est bien défini, le contrôleur est instancié. Il reste maintenant à vérifierque l’action demandée existe dans les méthodes du contrôleur, si elle existe, elle est alors appelée vianotre instance de contrôleur.

Il arrive d’avoir besoin en plus de l’action, d’un identifiant pouvant représenter une recherche ou unutilisateur. Il était donc préférable de récupérer cette donnée via la méthode GET et de lancer l’action(la méthode) dans notre contrôleur avec, comme paramètre, la donnée envoyée par GET, comme le montrele fragment de code suivant (cf. annexe B).

21

2.5.4 Traitement des requêtes utilisateurs avec AJAX

Pour gérer la communication avec la base de données en AJAX nous avons créé dans notre contrôleur,les méthodes permettant de récupérer les informations nécessaires aux différentes pages. Ces méthodessont ensuite appelées avec des méthodes javascripts associées.

Pour récupérer les différents critères de recherche et les envoyer à la méthode PHP qui s’occupe du trai-tement, nous avons développé deux fonctions javascript :

— une fonction permettant de récupérer les valeurs entrées dans le formulaire (cf. annexe C)

Les valeurs de chaque champ sont récupérées en y accédant grâce au constructeur d’objet JQuery$(id html de l’objet). Une fois l’objet récupéré on applique dessus la fonction permettant de récu-pérer le contenu $(id html de l’objet).val().

— une fonction utilisant AJAX pour la communication au serveur PHP (cf. annexe D)

Cette fonction utilise la première pour récupérer les valeurs et communique le tableau résultantainsi que le titre de la recherche à la méthode PHP traitant les données.

La réponse retournée par la méthode PHP est ensuite récupérée pour vérifier si la recherche a bien étécréé ou non.

2.5.5 Communication entre l’interface Web et l’application Java

Nous avons dû trouver une solution pour transmettre les paramètres de recherche à l’application Java,nous avons donc décidé que la communication entre l’interface Web et l’application java se fera grâce àun fichier JSON qui stockera les paramètres d’une recherche d’un utilisateur.

Le choix d’un fichier JSON a été le plus judicieux car il sert à faire communiquer des applications dans unenvironnement hétérogène. Il est fréquemment utilisé comme langage de transport de données par AJAXet les services Web. Il permet de représenter de l’information structurée.

L’ensemble des critères de recherches étant préalablement traités et formatés par le javascript , il estensuite réceptionné par le controlerUser qui se charge d’écrire ces données dans un fichier JSON (cf.annexe E), le fichier a pour nom le titre de la recherche préfixé par le pseudo de l’utilisateur et suffixé del’extension .JSON. exemple “ login_search1.json”.

Une fois le fichier créé, l’application Java est lancée via une fonction qui prend en paramètre la ligne decommande de lancement de l’application Java suivie du nom du fichier (cf. annexe F).

Il est important de préciser qu’il nous a fallu lancer l’application en mode non bloquant, c’est-à-dire nepas attendre la fin de l’application pour pouvoir continuer l’exécution du code PHP et Javascript. Eneffet lors d’une recherche Streaming, la recherche peut s’étendre sur plusieurs jours, il est donc importantde lancer l’application sans attendre la fin de son exécution.

Le fichier JSON sert donc de relais entre l’interface et l’application Java. Pour l’étape suivante c’estdonc l’application Java qui se charge de faire le lien avec Twitter.

22

2.6 Conception application Java

L’application Java a pour but de récupérer à la fois les tweets mais également les informations concer-nant les tweeteurs (personnes qui postent les tweets), la géolocalisation etc. Cependant lorsque les tweetssont récupérés, ils doivent être “disséqués” afin de pouvoir en tirer les informations attendues. En effet,nous avons vu plus haut que la table tweet de la base de données contient de nombreux attributs que nousdevons extraire des tweets. Par exemple, la date du tweet, sa langue, ou encore le nombre de retweets.

23

2.6.1 UML Application Java

La figure suivante présente la structure globale de l’application que nous avons implémentée :

Figure 11 – UML application java

2.6.2 Modalités d’accès à Twitter

L’application Java que nous avons mise en place a pour but de récupérer des tweets selon des critèresdonnés et d’insérer ces tweets dans une base de données afin de pouvoir les réutiliser. Pour avoir accèsaux données de Twitter, il faut impérativement avoir un compte Twitter et enregistrer une applicationsur le site https ://apps.twitter.com/.

24

Une fois l’application enregistrée, quatre codes d’accès sont fournis :

— Consumer Key— Consumer Secret— Access Token— Access Token Secret

Ces codes d’accès permettent de pouvoir envoyer des requêtes sur le flux de tweets circulant via uneapplication Twitter et d’avoir des résultats conformes à la requête demandée.

Il faut maintenant trouver un moyen de mettre en place ces requêtes et les envoyer vers notre application.Pour cela, nous avons utilisé la librairie twitter4j.

2.6.3 Connexion à l’API Twitter avec twitter4j

Différentes API sont fournies et permettent de réaliser des projets, des applications ainsi que des sitesWeb interagissant avec le site Twitter.

Dans le cadre de notre projet, nous avons utilisé :— L’API REST : qui fournit des résultats pertinents aux requêtes des utilisateurs à partir d’un cor-

pus restreint de tweets récents. Les résultats d’une requête sont fournis instantanément et peuventcontenir des tweets dont la date de publication peut être antérieure (jusqu’à une semaine) à ladate du lancement de la recherche.

— L’API STREAMING : qui permet de récupérer les tweets correspondant à une requête entemps réel (au moment où ils sont publiés), de suivre les tweets d’un utilisateur etc. Les résultatsd’une requête ne contiennent que des tweets publiés à partir du lancement de cette requête et tantque la requête n’est pas stoppée, des tweets sont fournis.

Il existe pour la plupart des langages de programmation, des librairies telles que twitter4j en Java (quenous avons utilisée) ou twitcurl en C++, permettant d’utiliser ces différentes API.

Twitter4j est une bibliothèque Java qui permet facilement d’intégrer le service Twitter à une applicationJava.

2.6.4 Récupération des tweets

La récupération des tweets a été gérée en deux parties distinctes :— La première partie consiste à récupérer les différents critères de recherche à travers un fichier au

format JSON crée à partir de l’interface. En effet ce fichier est parcouru grâce à la librairie Json-simple disponible sur le site https ://code.google.com/p/json-simple/. Le code suivant (cf. figure12) permet de transformer le fichier JSON en un objet Java de type “JSONObject” qui facilite larécupération des différentes valeurs.

25

Figure 12 – Parser un fichier Json en un objet java

Les différents critères que nous avons pu gérer avec l’application sont :— La recherche de tweets avec mots clés et/ou Hashtags : Ces mots clés et hashtags sont récupérés

via le fichier JSON

— Recherche des tweets de différent(s) utilisateur(s) contenant (ou pas) des mots clés et/ou ha-shtags, répondant à un(des) utilisateur(s) : la librairie twitter4j permet de récupérer les tweetsd’un utilisateur soit avec l’API REST (qui fournit au maximum 200 tweets récents d’un uti-lisateur), soit avec l’API STREAMING (qui permet de suivre les tweets d’un utilisateur encontinu).

— Recherche de tweets avec géolocalisation contenant des mots clés et/ou hashtags : Twitter4Jpermet d’effectuer des requêtes qui fournissent des tweets géolocalisés mais elle ne permet pasde récupérer des tweets qui sont géolocalisés et qui contiennent des mots clés spécifiés parl’utilisateur. Nous avons donc dû appliquer un traitement supplémentaire aux résultats obte-nus après géolocalisation. Pour être sûr de récupérer des tweets geolocalisés qui contiennentles mots clés et hashtags définis, nous récupérons les tweets géolocalisés et nous effectuons unfiltrage sur les différents mots-clés ou hashtags.

— En ce qui concerne le filtrage, nous avons mis en place différentes méthodes qui permettent detester si un tweet contient un mot clé, un hashtag ou si le tweet répond à un utilisateur.

— Pour une recherche avec l’API REST, il faut définir un cercle avec un centre (longitude etlatitude du centre) et un rayon (cf. figure 13). Tandis que, pour une recherche avec l’APISTREAMING, il faut définir un rectangle avec la longitude et la latitude des deux coins op-posés.

Figure 13 – Récupération tweets géolocalisés avec l’API REST

Les requêtes sont différentes d’une API à une autre, il a donc fallu faire une classe pour chacuned’elles ainsi qu’une classe principale déterminant l’appel à l’une ou l’autre. Chacune des deux APIa donc sa propre classe, ainsi que ses propres méthodes différentes pour chacun des critères. Deplus, certains critères sont accessibles pour une des API (REST le plus souvent) mais pas pourl’autre. Ce qui rend la tâche difficile pour la mise en place de l’interface Web, il fallait que le menuchange en fonction de l’API sélectionnée par l’utilisateur.

26

— La seconde partie concerne l’authentification, c’est-à-dire l’enregistrement du compte « TwitterDevelopers » avec lequel les requêtes seront effectuées. Pour utiliser notre application, l’utilisateurdevra posséder un compte sur « Twitter Developers », ce qui lui permettra d’avoir les codesd’accès nécessaires au lancement des requêtes. Ces codes d’accès seront ensuite enregistrés dansnotre base de données. L’application Java se chargera de récupérer ces codes d’accès afin d’effectuerl’authentification pour l’accès au site Twitter.

La figure 14 nous montre comment les codes d’accès sont récupérés depuis la base de données.

Figure 14 – Récupération des codes d’accès Twitter Developers à partir de la base de données

Voyons maintenant l’authentification du côté Twitter, cf figure 15.

Figure 15 – Authentification au service twitter

Un objet ConfigurationBuilder est créé et nous permet l’accès aux données de Twitter via les codesd’accès. Une fois cette authentification réalisée, il est possible de lancer des requêtes.

27

2.6.5 Connexion et insertion dans la base de données

La connexion à la base de données du côté de l’application Java est gérée par le driver PostgreSQLJDBC qui est disponible sur le site https ://jdbc.postgresql.org/download.html .

Cette connexion est réalisée de la façon suivante (figure 16) :

Figure 16 – Connexion à la base de données

La fonction getConnection (String url, String user, String password) établi une connexion avec la basede données. Elle prend en paramètres l’url, l’utilisateur (propriétaire), et le mot de passe de la base dedonnées. Nous avons mis en place un fichier “config.properties” qui contient les informations nécessaires(le numéro de port, l’hôte. . .) pour la connexion à la base de données. La ligne de code SetAutoCommit(false) permet de ne pas valider les transactions automatiquement. Ceci est important car cela permet dene pas insérer dans la base de données dans le cas où une erreur se produit. Pour valider une transaction,la méthode Commit() doit être appelée sur l’instance de la connexion.

Une fois la connexion établie, les insertions et les requêtes sont gérées par la classe Java java.sql.Statementque l’application emploie pour transmettre des instructions à la base, elle représente une requête SQL.Cette classe contient les méthodes suivantes :

— public abstract boolean execute() throws SQLException : qui permet d’exécuter une re-quête et renvoie true si l’exécution renvoie un ResultSet (classe qui symbolise un ensemble derésultats dans la base de données et autorise l’accès aux résultats d’une requête rangée par ran-gée).

— public abstract ResultSet executeQuery() throws SQLException : qui permet aussi d’exé-cuter une requête et renvoie un ResultSet.

— public abstract int executeUpdate() throws SQLException : qui permet d’exécuter unemise à jour et renvoie le nombre d’attributs concernées.

La figure située en annexe G montre une requête sur la table “Tweet” et une insertion dans cette mêmetable.

Les insertions sont gérées en fonction des dépendances entre les tables. Par exemple, lors de la récupé-ration d’un tweet, l’insertion dans la table “UserTweet” s’effectue avant l’insertion dans la table “Tweet”parce que la table “Tweet” contient une clé étrangère qui possède une référence vers l’id de la table“UserTweet”.

Une fois les tweets récupérés et insérer correctement dans la base de données, il faut maintenant qu’ilssoient exploitables d’une manière pratique par l’utilisateur, nous allons voir de quelle manière cet aspecta été mis en place.

28

2.7 Analyse/Statistiques des tweets

Nous nous situons ici dans la partie résultats de l’interface utilisateur. Dans cette partie, la page Webse distingue en trois modules :

— une colonne à gauche pour l’affichage et la gestion des recherches en cours— un module central pour la visualisation de l’ensemble des tweets recueillis— un module droit comprenant des données statistiques

La section du rapport qui suit se consacre au troisième module de la page de résultats et se décline endeux types d’éléments, les nuages de mots et les graphiques.

2.7.1 Nuages de mots

Le premier module mis en place pour étudier le contenu des tweets est un nuage de mots mettant enévidence les mots les plus utilisés dans le contenu récupéré.

Le nuage doit être modulable, pour :— afficher les mots des tweets ayant été postés pendant une période choisie (intervalle de dates)— afficher un nombre limité de mots dans le cas où le nombre de tweets et donc le nombre de mots

serait élevé— afficher seulement les mots ayant une fréquence comprise dans un intervalle prédéfini

Plusieurs nuages indépendants peuvent être ajoutés pour permettre de comparer différentes configura-tions entre elles.

Pour ce qui est des fonctions utilisées nous avons dans un premier temps une fonction PHP qui récu-père tous les tweets associés à une recherche et qui filtre et décompose leur contenu textuel pour créerun tableau à deux dimensions [mot, fréquence]. Cette fonction est appelée par une fonction javascriptutilisant AJAX qui récupère le tableau de mots et s’occupe de l’afficher dans le bloc de contenu du module.

Pour l’affichage, nous avons utilisé la librairie tagcloud.js qui, en l’appliquant sur un élément HTMLpossédant un attribut numérique donné (rel="valeur"), redimensionne automatiquement l’élément HTMLen fonction de cette valeur. Ici la valeur est donc la fréquence du mot et l’élément HTML le bloc contenantle mot <span rel="fréquence">mot</span>.

29

Figure 17 – Apercu d’un nuage de mots

30

2.7.2 Évolution du nombre de tweets en fonction du temps

Le second module développé est un graphique représentant la répartition des tweets postés dans letemps. On retrouve dans le module le choix d’un intervalle de date pour analyser une période préciseainsi que le choix de l’unité de temps. Ainsi, il est possible de voir le nombre de tweets postés chaqueheure ou chaque jour dans l’intervalle choisi. Il est aussi possible d’en ajouter plusieurs sur la page afinde les comparer.

Pour réaliser ce module nous avons utilisé la librairie Chart.js permettant de configurer différents typesde graphique en javascript.

Nous avons en parallèle développé une fonction PHP qui selon l’unité de temps fournie, calcule avec lecontenu de notre base de données le nombre de tweets postés à chaque intervalle et retourne un tableau àdeux dimensions contenant les paires de valeurs [abscisses, ordonnées]. Ce tableau est récupéré avec unefonction javascript utilisant AJAX qui le transforme pour configurer le graphique créé avec Chart.js.

31

Figure 18 – Apercu des graphes de l’évolution du nombre de tweets en fonction du temps

32

2.8 Idées abandonnées et améliorations envisagées

L’un des avantages que nous avons pour ce projet est qu’il n’est pas figé, et nous permet de resterautonomes et entreprenants sur certains aspects.

Pour l’application Java par exemple, après l’étude de toutes les informations que Twitter permet de récu-pérer grâce à ces deux API (REST et STREAMING) nous avons sélectionné les critères nous paraissantpertinents. Nous gardons donc la possibilité d’ajouter des critères, comme la recherche de tweets par dated’inscription des utilisateurs.

L’interface utilisateur reste le module pour lequel nous avions le plus de libertés, tout d’abord sur l’outilde conception. L’utilisation de Bootstrap nous a permis de façonner cette interface de manière pratiqueet plutôt esthétique. De même que pour les critères de recherche il a fallu choisir quelles informationsprésenter. Guidés par nos encadrants nous avons donc sélectionné les informations les plus pertinentes.Cependant nous avions des choix à faire sur la manière de présenter ces résultats, et de nombreusesaméliorations sont possibles à ce niveau. Pour le nuage de mots par exemple, il pourrait s’accompagnerd’une liste regroupant les mots qu’on ne voudrait pas voir apparaître. Les mots de ce nuage pourraientégalement être cliquables et permettre leurs visualisations sur le site de Twitter ou encore de lancerautomatiquement une nouvelle recherche basée sur ces mots.

Après avoir vu en détails l’aspect technique du projet, nous allons explorer le côté organisationnel misen place.

33

3 Rapport d’activité

Dans cette partie nous abordons différents points autour de l’organisation mise en place pour le projet.Nous parlerons dans un premier temps de la méthode de gestion de projet générale utilisée. Puis, dansun second temps, nous nous attarderons sur la planification prévue et réalisée.

3.1 Méthode de gestion de projet

3.1.1 Présentation de la méthode

La méthode mise en place pour notre projet s’est construite selon un procédé qui peut être assimiléaux méthodes Agiles et plus particulièrement à la méthode SCRUM. Nous nous sommes en effet servisdes préceptes de bases de ces méthodes sans pour autant en appliquer chaque principe à la lettre.

Nous avons avant tout essayé de privilégier certaines valeurs telles que :— Les individus et leurs interactions— La collaboration entre développeurs et commanditaires— L’adaptation au changement

Nous voyons maintenant comment ces concepts ont pu être appliqués à notre projet.

3.1.2 Bilan d’utilisation

Les méthodes Agiles se basent également sur un principe de développement itératif, dont nous noussommes inspirés, ce qui a permis au groupe de mener le projet de manière assez dynamique et réactive.

Pour ce qui est de la communication entre le groupe et les commanditaires, nous avons privilégié leséchanges en face à face qui facilitent amplement la compréhension et l’échange de différents points devue. Nous avons donc mis en place un rendez-vous hebdomadaire à la demande de nos encadrants. Lesréunions se tenaient tous les mercredis et un compte rendu était fait lors de chacune des réunions afin degarder une trace des modifications à faire et des problèmes rencontrés.

Ces entretiens permettaient à l’équipe de mettre en avant les travaux réalisés et de les présenter aux com-manditaires qui par la suite faisaient leurs retours. C’est ainsi, que de nouveaux objectifs s’installaientdans le groupe pour les réunions suivantes. Cette façon de procéder permettait aux enacdrants d’avoirune meilleure visibilité sur l’avancement des travaux, de tester les fonctionnalités du logiciel au fil de sacréation, de détecter les risques au plus tôt et d’en faire part.

En plus de ces réunions avec nos tuteurs, le groupe se réunissait quelques fois durant la semaine pours’entraider sur les problèmes et difficultés rencontrés.

La gestion s’est faite au fur et à mesure de l’avancée du projet. Bien qu’un planning prévisionnel ait étéréalisé, il y a eu tout au long du projet des changements auxquels nous avons dû nous conformer pouravancer plus rapidement dans le programme et pouvoir tenir les échéances plus facilement.

34

3.2 Planification

La planification est essentielle dans la gestion d’un projet. Cette planification commence bien souventpar la mise en place d’un planning dit prévisionnel servant à donner une idée des délais à suivre pourles différentes tâches. En général ce planning fait l’objet de changements au cours du développement duprojet. Voilà pourquoi nous allons également présenter le planning réel du projet. Ces plannings ont étéréalisés à l’aide du logiciel OpenProj.

3.2.1 Planning prévu

La figure située en annexe H nous permet de voir au mieux l’ensemble des tâches prévues au début duprojet.

La figure située en annexe I nous permet de visualiser la répartition des tâches au sein du groupedurant toute la durée du projet.

Dans un souci d’anticipation, le planning indiquait que le développement devait être terminé débutmai afin de pouvoir prendre en compte les éventuels retours et les dernières modifications et ajouts.

3.2.2 Planning réel

La figure située en annexe J nous montre le planning réel, les changements subis sont de naturesdiverses, néanmoins on peut voir que dans l’ensemble les délais établis ont été respectés. Cependant, lesdifficultés rencontrées notamment au niveau de la connexion PHP – Java, ont pu engendrer un retard surla mise en place de la partie résultats de l’interface Web.

35

Conclusion

Grâce à la réalisation du projet ExtractTweet, nous avons appris à aller au bout d’un projet, en respec-tant les objectifs fixés, dans un temps limité. Cela nous a énormément apporté tant au niveau techniquequ’au niveau du travail d’équipe. Ce projet nous a permis de mettre en pratique les connaissances acquiseslors des enseignements de ces dernières années. Il est très intéressant pour nous de voir dans quels cadrespeuvent s’intégrer les notions enseignées.

De plus, l’originalité du sujet nous a tout de suite plu car le support utilisé (Twitter), est très populaire.Ce projet nous a permis de connaître une autre utilisation d’un site que nous connaissons déjà assez bien.

Concernant l’aspect technique, ce projet a été particulièrement enrichissant pour chacun d’entre nousde part la diversité des outils utilisés. En effet pour chacun des modules présentés nous avons mis enapplication certains outils déjà connus, mais nous avons surtout appris à nous familiariser avec de nouvellestechnologies. C’est un point important et très appréciable pour nous car il nous sera très souvent demandédurant notre future carrière d’être capable de nous adapter à différents supports, outils et technologies.La polyvalence est une des compétences largement attendue en sortant d’une telle formation. Ainsi, ceprojet nous a amené à faire preuve d’adaptation notamment par la prise en main rapide des différentsoutils.

Nous avons pu remplir les objectifs fixés en début de projet, cependant à l’issue de ce dernier nousavons pour motivation de continuer à améliorer la plateforme, notamment la partie Web avec l’ajout decertaines fonctionnalités .

36

Bibliographie/Sitographie

— Wikipédia : http ://fr.wikipedia.org/wiki/Twitter— http ://lewebpedagogique.com/devanssay/files/2014/07/twitexpose.pdf— openClassRooms : http ://openclassrooms.com/— Stackoverflow : http ://stackoverflow.com/— developpez.com : http ://www.developpez.com/

37

Annexe A - La classe vue (PHP)

<?phpclass Vue{

protected $fichier ; // nom fichier de la vueprotected $titre ; // le titre de la page ;protected $headinfos ; // le bouton inscription dans le cas de qquns non connecter / le ←↩

pseudo dans le cas d ' une personne connectépublic f u n c t i o n __construct ( $action ){

// nom du fichier a partir de l ' action$this−>fichier = ROOT . "/ Views / Vue " . $action . " . php " ;

}

// Génère un fichier vue et renvoie le résultat produitf u n c t i o n g e n e r e r F i c h i e r ( $fichier , $donnees ){

i f ( file_exists ( $fichier ) ){

// Rend les éléments du tableau $donnees accessibles dans la vueextract ( $donnees ) ;// Démarrage de la t e m p o r i s a t i o n de sortieob_start ( ) ;// Inclut le fichier vue// Son résultat est placé dans le tampon de sortierequire $fichier ;// Arrêt de la t e m p o r i s a t i o n et renvoi du tampon de sortier e t u r n ob _ge t_c lea n ( ) ;

}e l s e{

throw new Exception ( " Fichier ' $ f i c h i e r ' introuvable " ) ;}

}

// Génère et affiche la vuepublic f u n c t i o n generer ( $donnees ){// Génération de la partie spécifique de la vue

$contenu = $this−>g e n e r e r F i c h i e r ( $this−>fichier , $donnees ) ; // generation du contenu// Génération du gabarit commun utilisant la partie spécifique

$vue = $this−>g e n e r e r F i c h i e r ( ROOT . ' / Views / gabarit . php ' ,array ( ' t i t r e ' => $this−>titre , ' contenu ' => $contenu ) ) ;

// Renvoi de la vue au navigateurecho $vue ;

}

}

?>

38

Annexe B - Mécanisme de routage de l’action demandée par l’uti-lisateur (PHP)

<?php

i f ( isset ( $_GET [ " action " ] ) ) // si action est pas vide{

$instance = new C o n t r o l e u r U s e r ( ) ;// on verifie que l ' action / la methode existe

i f ( m e t h o d _ e x i s t s ( $instance , $_GET [ " action " ] ) ){

i f ( isset ( $_GET [ " donnee " ] ) ){

i f ( isset ( $_GET [ " donnee2 " ] ) ){

i f ( isset ( $_GET [ " donnee3 " ] ) ) {$instance−>$_GET [ " action " ] ( $_GET [ " donnee " ] , $_GET [ " donnee2 " ] ,

$_GET [ " donnee3 " ] ) ;}e l s e{

instance−>$_GET [ " action " ] ( $_GET [ " donnee " ] , $_GET [ " donnee2 " ] ) ;}

}e l s e{

$instance−>$_GET [ " action " ] ( $_GET [ " donnee " ] ) ;}

}e l s e{

$instance−>$_GET [ " action " ] ( ) ;}

}e l s e{

$instance−>erreur ( " Cette page n ' existe pas " ) ;exit ( ) ;

}

}?>

39

Annexe C - Récupération des données du formulaire de recherche(Javascript)

f u n c t i o n g e t _ f o r m _ v a l u e s ( ){var date = new Date ( ) ;var timestamp = new Date ( Date . UTC ( date . getFullYear ( ) , date . getMonth ( ) , date . getDate ( ) , date .←↩

getHours ( ) , date . getMinutes ( ) , date . getSeconds ( ) , date . g e t M i l l i s e c o n d s ( ) ) ) ;

var name = $ ( '#search_name ' ) . val ( ) ;var api ;var nb_results ;var dt ;var hft ;

i f ( $("# use_rest " ) . is ( ' : checked ' ) ) {api = $("# use_rest " ) . val ( ) ;

i f ( $ ( '#date ' ) . val ( ) ! = " " ) { dt = $ ( '#date ' ) . val ( ) }hft = $ ( '#h o u r s _ s l i d e r ' ) . g e t S l i d e r V a l u e s ( ) ;}

e l s e{ // si ce n ' est pas l ' un , c ' est l ' autreapi = $("# u s e _ s t r e a m i n g " ) . val ( ) ;}

i f ( $ ( '#r e s u l t s _ l i m i t ' ) . val ( ) ! = " " ){nb_results = $ ( '#r e s u l t s _ l i m i t ' ) . val ( ) ;}

var lang ;i f ( $ ( '#language ' ) . val ( ) !=" default " ) { lang = $ ( '#language ' ) . val ( ) }var rts ;i f ( $ ( '#r e t w e e t s ' ) . val ( ) !=" default " ){

var tmp = $ ( '#r e t w e e t s ' ) . val ( ) . split ( '− ' ) ;rts = [ ]rts [0 ]= parseInt ( tmp [ 0 ] ) ;rts [1 ]= parseInt ( tmp [ 1 ] ) ;

}

var values ;i f ( name ! = " " ) {values = {

search_name : name ,s e a r c h _ t i m e s t a m p : timestamp ,

API : api ,re sul t_l imi t : nb_results ,compte_API : $ ( '#api_account ' ) . val ( ) ,keywords : lists [ ' keyword_l ist ' ] ,language : lang ,

r e t w e e t s _ f r o m _ t o : rts ,date : dt ,ho ur_ fro m_t o : hft ,answer_to : lists [ ' answer_to_l ist ' ] ,users : lists [ ' u s e r _ l i s t ' ] ,bo und ing _bo x : lists [ ' bounding_box_list ' ]}

}

var json_values = JSON . stringify ( values ) ;r e t u r n json_values ;

}

40

Annexe D - Envoi des données avec AJAX

f u n c t i o n c r e a t e _ s e a r c h ( ){var new_search = g e t _ f o r m _ v a l u e s ( ) ;var titreRe = $("# search_name " ) . val ( ) ;

i f ( new_search != n u l l ){

$ . ajax ({type : " POST " ,url : " . . / Controlers / C o n t r o l e u r U s e r . php ? action=v a l i d e r R e c h e r c h e " ,data : {search : new_search ,titreR : titreRe} ,e r r o r : f u n c t i o n ( ) { alert ( " erreur ! " ) ; } ,

success : f u n c t i o n ( retour ) {console . l o g ( retour ) ;alert ( retour ) ;location . reload ( ) ;

}}) ;

}e l s e {console . l o g ( " erreur " ) ;}

}

41

Annexe E - Fonction de validation d’une recherche (PHP)

// Fonction de recherche , cree un fichier avec les paramatres de recherchespublic f u n c t i o n v a l i d e r R e c h e r c h e ( ){

i f ( isset ( $_POST [ ' s ea r c h ' ] ) ) {

$fp = fopen ( ' recherche_ ' . $_POST [ ' t i t r e R ' ] . ' . json ' , 'w ' ) ;f w r i t e ( $fp , $_POST [ ' s ea r ch ' ] ) ;f c l o s e ( $fp ) ;

}$file = ' recherche_ ' . $_POST [ ' t i t r e R ' ] . ' . json ' ;$this−>e x e c I n B a c k g r o u n d ( " java −jar . . / S S A F J a v a A p p l i / JavaApp . jar " . $file ) ;sleep ( 1 ) ;

$ r e s u l t L a u n c h S e a r c h = $this−>search−>e x i s t _ s e a r c h _ t i t l e ( " " . $_POST [ ' t i t r e R ' ] ) ;i f ( $ r e s u l t L a u n c h S e a r c h == true ){

echo " Recherche envoyée " ;}e l s e

echo " Erreur Recherche non envoyée , veuillez consulter le fichier l o g pour plus d '←↩in for mat io ns " ;

}}

42

Annexe F - Fonction d’exécution de l’application Java (PHP)

public f u n c t i o n e x e c I n B a c k g r o u n d ( $cmd ) {i f ( substr ( php_uname ( ) , 0 , 7) == " Windows " ) {pclose ( popen ( " start /B " . $cmd , " r " ) ) ;}e l s e {$hr=popen ( $cmd . " > / dev / n u l l &" ," r " ) ;}}

43

Annexe G - Une insertion dans la table des tweets (Java)

sql2 = " SELECT ∗ FROM \" tweet \" WHERE id_tweet = ' "+ S t r i n g . valueOf ( s . g e t I d ( ) )+" ' " ;rs = stmt . ex ecu teQ uer y ( sql2 ) ;i f ( ! rs . next ( ) ){sql =" INSERT INTO \" tweet \ " ( id_tweet , date_tweet , current_user_retweet_id , favorite_count ,←↩

longitude , latitude "+ " , in_reply_to_screen_name , in_reply_to_status_id , in_reply_to_user_id ,←↩user_id , lang , retweet_count , text , is_retweet , is_retweeted , i s _ r e t w e e t e d _ b y _ m e "+ " ,←↩is_truncated , scopes , all_info , place_id , i d _ t w e e t _ r e t w e e t e d ) VALUES←↩( ? , ? , ? , ? , ? , ? , ? , ? , ? , ? , ? , ? , ? , ? , ? , ? , ? , ? , ? , ? , ? ) " ;

smt = connexion . p r e p a r e S t a t e m e n t ( sql ) ;smt . setString ( 1 , String . valueOf ( s . getId ( ) ) ) ;smt . se tTi mes tam p ( 2 , new java . sql . Timestamp ( s . ge tCr eat edA t ( ) . getTime ( ) ) ) ;smt . setLong ( 3 , s . g e t C u r r e n t U s e r R e t w e e t I d ( ) ) ;smt . setInt ( 4 , s . g e t F a v o r i t e C o u n t ( ) ) ;i f ( s . g e t G e o L o c a t i o n ( ) != n u l l ){smt . setDouble ( 5 , s . g e t G e o L o c a t i o n ( ) . ge tLo ngi tud e ( ) ) ;smt . setDouble ( 6 , s . g e t G e o L o c a t i o n ( ) . getLatitude ( ) ) ;}e l s e{smt . setDouble ( 5 , 0) ;smt . setDouble ( 6 , 0) ;}smt . setString ( 7 , s . g e t I n R e p l y T o S c r e e n N a m e ( ) ) ;smt . setString ( 8 , String . valueOf ( s . g e t I n R e p l y T o S t a t u s I d ( ) ) ) ;smt . setLong ( 9 , s . g e t I n R e p l y T o U s e r I d ( ) ) ;smt . setLong (10 , s . getUser ( ) . getId ( ) ) ;smt . setString (11 , s . getLang ( ) ) ;smt . setInt (12 , s . g e t R e t w e e t C o u n t ( ) ) ;smt . setString (13 , s . getText ( ) ) ;smt . setBoolean (14 , s . isRetweet ( ) ) ;smt . setBoolean (15 , s . isRetweeted ( ) ) ;smt . setBoolean (16 , s . i s R e t w e e t e d B y M e ( ) ) ;smt . setBoolean (17 , s . isTruncated ( ) ) ;i f ( s . getScopes ( ) != n u l l )smt . setString (18 , Arrays . toString ( s . getScopes ( ) . getPlaceIds ( ) ) ) ;e l s esmt . setString (18 , n u l l ) ;smt . setString (19 , T w i t t e r O b j e c t F a c t o r y . getRawJSON ( s ) ) ;i f ( s . getPlace ( ) != n u l l )smt . setString (20 , s . getPlace ( ) . getId ( ) ) ;e l s esmt . setString (20 , n u l l ) ;i f ( s . isRetweet ( ) )smt . setString (21 , String . valueOf ( s . g e t R e t w e e t e d S t a t u s ( ) . getId ( ) ) ) ;e l s e {smt . setString (21 , n u l l ) ;}smt . e x e c u t e U p d a t e ( ) ;}

44

Annexe H - Planning prévisionnel - Liste des tâches

45

Annexe I - Planning prévisionnel - Attribution des tâches dansle temps

46

Annexe J - Planning réel

47

Annexe K - Manuel d’utilisation

1 - Ouverture d’un compte utilisateur

Pour se servir de l’application, l’utilisateur doit créer un compte. S’il n’est pas déjà connecté il y estautomatiquement invité. Tous les champs sont obligatoires avec des contraintes sur certains d’entre eux.

— l’adresse mail doit être correctement formatée— le mot de passe doit être de six caractères minimum

Une fois inscrit, le formulaire de connexion accessible grâce au bouton du menu principal permet d’ac-céder à l’application.

2 - Enregistrement Compte Twitter Developers

Une fois connecté, vous arrivez sur la page de lancement de recherche. Ajoutez un compte TwitterDevelopers avec vos codes d’accès. Pour cela cliquez sur “Ajouter un compte”. Un menu “en accordéon”apparaît dans lequel vous pourrez donner un nom à votre compte et insérer vos codes d’accès.

48

Pour avoir un compte “Twitter Developers” cliquez sur ce lien https ://apps.twitter.com/ et enregistrezune application.

3 - Création d’une recherche

Pour créer/lancer une recherche avec des critères, vous devez :

— Choisir l’API de recherche (REST pour une recherche de tweets déjà présents dans la base dedonnées de Twitter ou STREAMING pour une recherche de tweets en temps réel) et un compte(sachant qu’il est impossible d’avoir deux recherches en cours utilisant le même compte)

— Remplir le champ “Titre de la recherche”— Ajouter un ou plusieurs mots clés et hashtags(mot commençant par #) en saisissant le mot et

en cliquant sur le bouton “+”. Ceci n’est pas obligatoire au cas ou vous recherchez des tweetsgéolocalisés ou les tweets d’un utilisateur Twitter

— Éventuellement choisir la langue des tweets résultants de la recherche ; choisir l’intervalle du nombrede retweets

— Éventuellement choisir (pour une recherche avec l’API REST) la plage horaire et la date minimumdes tweets

49

— Éventuellement choisir des auteurs, des pseudo auxquels ces auteurs répondent

— Ajouter des Bounding Box (zone définissant les régions du monde) si vous recherchez des tweetsgéolocalisés en sélectionnant le nom et en cliquant sur “+”

— Vous pouvez définir vos propres Bounding Box. Il suffit de cliquer sur le bouton “Ajouter une boun-ding box”, puis de donner un nom à votre Bounding Box et ensuite de sélectionner le type (cerclepour les recherches avec l’API REST et rectangle pour les recherches avec l’API STREAMING) etenfin, de cliquer sur la map. Un rectangle ou un cercle que vous pouvez délimiter apparaît. Cliquersur “ajouter” pour effectuer l’ajout. La figure suivante vous montre un aperçu

50

— Enfin cliquer sur le bouton “Valider recherche”Un popup apparaît avec “recherche envoyée” si l’envoi de la recherche a été effectué avec succès.

4 - Visualisation des résultats

Cliquer sur le menu “Résultats” en haut à droite pour accéder à la page de résultats.Sur la gauche de la page de résultats se trouve la liste des recherches lancées.

51

Le premier menu contient une liste de filtres permettant de n’afficher que les recherche ayant des critèresprécis, ainsi qu’une option de tri (Par date de lancement et/ou par nombres de résultats).Un indicateur montre l’état de chaque recherche (terminée ou en cours) [ 1 ].Le bouton “+” à droite permet d’afficher les détails d’une recherche [ 2 ].

Sur la gauche du menu, se trouvent les boutons permettant :— d’exporter les tweets associés à une recherche [ 3 ]— de stopper ou supprimer une recherche [ 4 ]

Une fois la recherche sélectionnée, différents modules se mettent en place.

Premier module - visualisation des tweets

La partie gauche du contenu de la page affiche les tweets triés par pages. Il est possible de les affichertous ou de choisir d’afficher seulement les tweets géolocalisés [ 1 ].Un lien vers le tweet est disponible [ 2 ].Pour afficher la position du tweet sur le module Google Map, cocher la checkbox [ 3 ].Les boutons associés au module Google permettent de sélectionner tous les tweets récupérés dans larecherche ou seulement les tweets contenus dans la page actuellement affichée [ 4 ].

52

Deuxième module - nuage de mots

Ce module permet d’afficher les mots clés utilisés dans les tweets.Les filtres comprennent :

— deux sélecteurs de dates pour considérer les tweets postés au cours d’une période précise [ 1 ]— la sélection d’une plage de fréquences [ 2 ] et une limite d’affichage [ 3 ] pour afficher seulement

une partie des mots

Pour valider les filtres, utiliser le bouton ↓ .Un lien permet d’afficher le nuage de mots complet sur une nouvelle page [ 4 ]. Il est possible d’ajouterplusieurs nuages de mots sur la page à l’aide du bouton “+” situé sous le module.

53

Troisième module - granularité temporelle

Ce module permet d’afficher une courbe représentant la répartition des tweets dans le temps.Les filtres comprennent :

— deux sélecteurs de dates représentant la borne inférieure et supérieure de l’axe des abscisses [ 1 ]— la sélection d’une unité d’intervalle pour cet axe [ 2 ]

Pour valider les filtres, utiliser le bouton ↓ .Le survol de la courbe avec la souris permet d’afficher la date et le nombre de tweets postés entre ce pointet l’intervalle précédent. L’ajout de plusieurs graphiques est possible à l’aide du bouton “+” situé sous lemodule.

54