Projet M1 Sujet 21 : Développement d'un logiciel simplifié de

type Business Object Professeur Tuteur : Thierry Spriet

1 Introduction....................................................................................................................4 1.1 Cadre du projet .......................................................................................................4 1.2 Objectif...................................................................................................................4 1.3 Système existant .....................................................................................................4 1.4 Utilisateurs..............................................................................................................4 1.5 Organisation ...........................................................................................................4 1.6 Rappel sur les solutions envisagées .........................................................................5

2 La plate-forme SPAGOBI...............................................................................................5 2.1 Présentation ............................................................................................................5 2.2 Fonctionnement du Projet avec SpagoBI.................................................................5 2.3 Installation..............................................................................................................6

2.3.1 Installation de Tomcat avec eXo-Portal ...........................................................6 2.3.2 Installation de SPAGOBI ................................................................................6

2.4 Démarrage ..............................................................................................................7 3 Extraction des données : Talend Open Studio..................................................................7

3.1 Pourquoi Talend Open Studio? ...............................................................................7 3.2 Présentation de Talend Open Studio........................................................................8 3.3 Intégration avec SpagoBI......................................................................................12

4 BIRT ............................................................................................................................13 4.1 Présentation ..........................................................................................................13 4.2 Installation............................................................................................................13 4.3 Utilisation et Intégration avec SPAGOBI..............................................................14 4.4 Création de rapports pré générés ...........................................................................14

4.4.1 Introduction...................................................................................................14 4.4.2 Créer une source et un jeu de données. ..........................................................15

4.4.2.1 Définition de la source de données ............................................................15 4.4.2.2 Extraction à partir d'une base de données...................................................15 4.4.2.3 Manipulation d'un jeu de données (data set)..............................................17

4.4.3 Conception d'un rapport ................................................................................18 4.5 Créer une librairie .................................................................................................18 4.6 Créer un template de rapports................................................................................19 4.7 Ajouter un rapport à SpagoBI................................................................................20

4.7.1 Introduction...................................................................................................20 4.7.2 Créer un dossier ............................................................................................20 4.7.3 Ajouter les rapports.......................................................................................21 4.7.4 Tester et valider les rapports..........................................................................22 4.7.5 Exécution......................................................................................................23

5 Hibernate......................................................................................................................24 5.1 Introduction ..........................................................................................................24 5.2 Présentation d’Hibernate.......................................................................................24 5.3 Utilisation d’ Hibernate.........................................................................................25

6 QBE .............................................................................................................................27 6.1 Présentation ..........................................................................................................27 6.2 Paramètrage ..........................................................................................................27 6.3 Fonctionnement ....................................................................................................31

7 Problèmes rencontrés :..................................................................................................34 7.1 Difficultés et problèmes rencontrés .......................................................................34 7.2 Forums .................................................................................................................35

8 Organisation du travail .................................................................................................36 9 Conclusions ..................................................................................................................38

10 Annexes :..................................................................................................................39 10.1 Notice d’installation SPAGOBI ............................................................................39 10.2 Versions et liens des fichiers utiles........................................................................39

10.2.1 Documentation :............................................................................................39 10.2.2 Fichiers nécessaires au fonctionnement de SpagoBI : ....................................39

1 Introduction

1.1 Cadre du projet Ce projet est développé pour une utilisation au sein de l’université d’Avignon. Plusieurs bases de données sont utilisées au sein de l’université d’Avignon. Elles regroupent des données relatives à la comptabilité, la gestion du personnel (Oracle), la scolarité et les diplômes et maquettes (PostgreSQL). Le besoin se fait ressentir pour un non informaticien d’obtenir des informations en provenance de plusieurs tables simultanément.

1.2 Objectif Nous devons mettre en place une solution pour permettre à un non informaticien de faire des requêtes (si possible graphiquement) sur ces bases de données. Le choix qui a été fait au 1er semestre est de mettre en œuvre une solution basée sur des composants Open Source relatifs au domaine de la Business Intelligence.

1.3 Système existant IL y a 2 bases de données répertoriées :Une pour la gestion du personnel (Oracle) et l’autre pour la scolarité et les diplômes et maquettes (PostgreSQL), nommée freebo. C’est cette dernière que nous allons utiliser. Un serveur linux a été mis à notre disposition à l’IUP. Nous travaillons chez nous sur un système d’exploitation Windows XP et un système MAC.

1.4 Utilisateurs Nous devons trouver une solution pour un utilisateur novice en langage SQL. Nous pouvons toutefois compter sur la présence de contrôleur de gestion, maîtrisant le langage SQL.

1.5 Organisation Un serveur Unix nous a été dédié au sein de l'IUP. Pour s'y connecter, nous disposions d'un compte et nous y accédions par le protocole ssh. Le récupération/dépôt de fichiers s'est faite par sftp grâce à un tunnel ssh. C'est sur ce serveur que la base de données freebo a été installée. Afin de tester SpagoBI sur cette base, il nous a fallu faire un « dump » de la base dont voici les principales commandes sous postgreSQL :

a) Dumper une base : pg_dump -D {nom_de_la_base} > {nom_du_fichier.dump}

b) Recréer une base à partir d’un dump :

psql -e {nom_de_la_base} < {nom_du_fichier.dump} Un fichier de 800Mo a été crée à la suite de cette étape. Pour ré-injecter la base sur notre propre machine de tests, il nous a fallu téléchargé ce fichier sur le serveur puis exécuter le fichier dump dans notre SGBD.

1.6 Rappel sur les solutions envisagées Au cours du 1er semestre nous nous sommes intéressé aux logiciels libres de Business Intelligence de logiciel type Business Object (le plus connu) mais en open source : Nous avons retenu SpagoBI et Pentaho. Ce sont des plates-formes de Business Intelligence possédant un profil relativement similaire en terme de fonctionnalisées. Le fait que SpagoBI ne nécessitant aucun ajout payant pour faire fonctionner sa plate-forme nous a fait opté pour cette solution. 2 La plate-forme SPAGOBI

2.1 Présentation SpagoBI est une solution OpenSource pour le développement de projets de type Business Intelligence, proposé par la société italienne Engineering Ingegneria Informatica. Il n'y a donc pas de fonctionnalités volontairement absentes et réservées pour une version commerciale comme c'est le cas pour Pentaho. Cette solution offre donc une couche logicielle complète comprenant toutes les étapes de l’intelligence décisionnelle (voir rapport 1er semestre) comme les fonctions de Reporting, OLAP, de data mining, dashboards, QBE, collecte des données (ETL)… SpagoBI permet un développement très flexible permettant de « mixer » l’open source avec des solutions propriétaires. Son grand avantage est donc sa capacité d’intégration, ce qui permet de travailler indépendamment par briques séparées et une meilleure répartition du travail. Son inconvénient principal est que c’est une solution jeune dans un secteur en pleine évolution, il faut donc se tenir régulièrement au courant quant à l’ajout de nouveaux composants et de fonctionnalités. Site Web : http://spagobi.eng.it

2.2 Fonctionnement du Projet avec SpagoBI Rappel : l’objectif est de permettre à l’utilisateur final de faire des requêtes graphiques sur une base de données.

Pour cela nous découperons les phases principales du projet conformément aux étapes d’un projet de Business Intelligence.

• La collecte de données se fera par Talend Open Studio qui est un outil d'ETL en cours d’intégration avec la plate-forme SpagoBI.

• La préparation de la partie Reporting sera réalisée par BIRT. • La partie modélisation par Hibernate. • La partie requête graphique de l’utilisateur final par le SpagoBIQbeEngine

SpagoBI propose en téléchargement une version démo, celle ci propose au développeur des « portlets », des applications qui, placées dans un portail web, servent alors de conteneurs. Ces portlets prédéfinis qui permettent d’accéder aux fonctionnalités (reporting, QBE, etc…) de SpagoBI. Suivant les conseils de l’équipe technique d’ IEE nous sommes donc parties de la version démo qui offre aux nouveaux utilisateurs de SpagoBI un socle complet pour débuter avec le produit.

2.3 Installation SpagoBI peut fonctionner sur les plates-formes Windows et Unix (linux, MacOS X,...). Pour fonctionner, SpagoBI requiert essentiellement trois éléments : − Installation d'un serveur d’application sur lequel reposera la plate-forme de Business

Intelligence. Trois types de serveurs d'applications, écrits en Java sont proposés : Tomcat, Jboss et Jonas. Pour sa stabilité et sa simplicité d'installation, nous avons opté pour Tomcat. Le serveur doit être installé au préalable avec « exo-portal ». Produit par une startup française « EXO Plateform », il s'agit d'un portail permettant d'inclure des portlets.

− Installation d'une JDK. − Installation d'OpenOffice. Les différentes versions des fichiers concernant le serveur d'application et SpagoBI sont téléchargeables sur le site http://forge.objectweb.org/ respectivement dans les projets eXo et SpagoBI. Note : Pour les noms et versions exactes des fichiers, cf 10.1 Notice d'installation de SpagoBI.

2.3.1 Installation de Tomcat avec eXo-Portal L'installation de Tomcat avec eXo-Tomcat est simpliste. Il suffit de télécharger l'archive et de la décompresser dans le répertoire où SpagoBI sera installé.

2.3.2 Installation de SPAGOBI Avant le 06 avril 2007, aucun installeur graphique de SpagoBI n'existait. La démarche à suivre en consistait en l'installation, en plus des trois éléments (Java, OpenOffice, Tomcat avec eXo-Portal), de la « metabase de données » (Oracle, PostgreSQL, mySQL, HSQLDB) utilisée par SpagoBI, de ses drivers, la configuration d'un JNDI (pour la connexion de SpagoBI à sa source de données (la metabase), l'installation d'un « cms repository » (System de management de contenu), l'installation de la plateforme SpagoBI avec des configurations légères et enfin l'installation des moteurs souhaités (Birt, QBE,...).

Cette solution nous a posé de nombreux problèmes (de très nombreuses erreurs bloquantes suites aux nombreuses étapes dans l'installation), c'est pourquoi nous avons opté pour l'installateur graphique où l'on suit les étapes interactives à l'écran. A un stade de l'installation, une liste de moteurs est proposée, nous prendrons alors soin, entre autres, de sélectionner SpagoBirtReportEngine (cf 4. Birt) et SpagoBIQBEEngine (cf 6. QBE).

2.4 Démarrage Une fois SpagoBI correctement installée, la plate-forme peut être démarrée. Pour ce faire, il est nécessaire d'exécuter le script /Spago/exo-portal/StartSpagoBI.sh ( StartSpagoBI.bat sous Windows) qui se charge de lancer la metabase de donnée et surtout le serveur d'application. Pour stopper l'application, il faut exécuter le script StopSpagoBI.sh. Note : La ligne de commande détail le démarrage de l'application (ex : démarrage de chacun des moteurs SpagoBI) et l'on peut voir une erreur qui apparaît plusieurs fois : [ERROR] PersistentManagerBase - No Store configured, persistence disabled Cette erreur est connue car de nombreux utilisateurs la voient mais sur le forum officiel, l'équipe technique de SpagoBI nous a informé qu'elle était non bloquante et qu'il ne fallait pas s'en soucier. Une fois démarrée, SpagoBI est accessible par le biais d'un navigateur Internet à l'adresse : http://serveur:8080/sbiportal La première page détaille les profils sous lesquels l'utilisateur peut se connecter pour accéder aux fonctionnalités qui lui correspondent. Il y a 4 types d’utilisateurs de SpagoBI: 1.Administrator: gère la configuration et les aspects de sécurité. Sous ce profil nous allons créer un répertoire pour entreposer les documents (rapports) et définir les droits d’accès. 2.Developer: Pour créer ou modifier les documents. En important les rapports pré générés de BIRT dans le répertoire adéquat. 3.Tester: Pour tester les documents (rapports en l’occurrence) que nous rajoutons via la partie administrateur et développeur. Ensuite il a la possibilité de valider ou non le document. 4.User: Peut utiliser tout les documents dont la mise en exploitation a été validé par les précédents, l’usage, l’accès et les droits des documents sont limités par les paramètres définis précédemment. C’est donc pour un user que nous allons concevoir les étapes suivantes afin d’aboutir sur la partie QBE. 3 Extraction des données : Talend Open Studio

3.1 Pourquoi Talend Open Studio? L'université d'Avignon utilise des données provenant de plusieurs bases de données (ex : Diplômes, Scolarité), qui ne sont pas forcément implémentées au sein du même système de

gestion de base de données (ex : postgreSQL, Oracle) et des utilisateurs appartenant à l'administration de l'université éprouvent le besoin de faire des requêtes à partir de ces différentes bases. Cette étape de la Business Intelligence, appelée fonction d'ETL, est présente dans notre projet car elle permet de collecter des données provenant de plusieurs bases de données, ce qui ne peut se faire par le simple biais de requêtes SQL. Il s'agit bien sûr d'un travail que seul un informaticien pourra faire car il est indispensable de connaître le langage SQL. Il pourra ainsi au préalable créer de nouvelles bases de données répondant aux besoins précis des utilisateurs finaux. Talend Open Studio (ou TOS) est un outil d'ETL open source, capable d’extraire des données de différentes bases de données. Cet outil propose une solution « clés en main », offrant un logiciel téléchargeable et exécutable de façon autonome sur un système d'exploitation. En outre, Talend peut s'intégrer à la plateforme SPAGOBI qui, jusqu’il y a peu, était dépourvu de solution d'outil d'intégration de données. Etant donné nos problèmes rencontrés lors de l'installation de SpagoBI avant la sortie de l'installeur graphique, nous avons découvert et pris en main Talend Open Studio dans sa version clé en main.

3.2 Présentation de Talend Open Studio Le logiciel est téléchargeable sous forme d'une archive sur le site officiel (http://www.talend.com/download.php), qu'il suffit de décompresser pour installer l'application. L'outil d'ETL est, depuis quelques mois disponible dans un version écrite en Java (qui fait suite à une version écrite en Perl), ce qui donne la possibilité au programmeur d'ouvrir un projet TOS au sein du logiciel Eclipse. C'est cette version que nous avons choisit d'utiliser. Après avoir décidé de l'ouverture ou de la création d'un nouveau projet, l'application, nous offre une apparence de style « TreeView » familière à Eclipse. On peut y voir les vues suivantes : le référentiel (Repository), l’espace de travail (WorkSpace), les sorties/erreurs/logs. Et l’aperçu Schéma/code.

figure 1 : Interface de Talend Open Studio

Le Repository donne accès à deux types essentiels de projet : les « Business Models » et les « Job Design ». Le premier type permet de modéliser des processus métiers alors que celui qui nous intéresse, le Job Design, permet lui d’associer les composants qui nous permettront de manipuler les flux de données provenant de différentes bases. Des liens vers ces bases doivent être configurés avant toute chose. C’est ainsi qu’il est nécessaire d’ajouter des « connections » à l’élément « metadata/DB Connections » du repository (clique-droit, new connection). Une connexion par base de données est nécessaire. Les paramètres à fournir sont les suivants : type de la base : mySQL/PostgreSQL/Oracle … url de la connexion : sous la forme « jdbc:typeDeBase://adresse:port/baseDeDonnées login/password : pour la connexion à la base de données adresse du serveur du serveur de base de données numero de port du serveur de base de données nom de la base de données

figure 2 : Paramètres de connexion à une base de données

Nous avons décidés de tester TOS au travers d’un exemple auquel on peut être confronté dans le cadre de notre projet, mysql sera le SGBD. Voici trois bases de données, datab1 : table student : id_student (numeric), name_student (varchar) table speciality : id_speciality (numeric), name_speciality (varchar) table match1 : id_speciality (numeric), id_student (numeric) datab2 table course : id_ course (numeric), name_ course (varchar) table speciality : id_speciality (numeric), name_speciality (varchar) table match2 : id_speciality (numeric), id_course (numeric) datab3 table student : id_ student (numeric), name_ student (varchar) table course : id_ course (numeric), name_ course (varchar) table match3 : id_ student (numeric), id_course (numeric) La base datab1 permet de savoir que tel étudiant (student) appartient à telle filiere (speciality), grâce à la table match1. Cette base est actuellement remplit. La base datab2 permet de savoir que tel étudiant (student) suit tel cours (course), grâce à la table match2. Cette base est actuellement remplit. La base datab3 permet de savoir que tel cours (course) appartient à telle filiere (speciality), grâce à la table match3. Cette base est actuellement vide, et c’est celle-ci que nous voudrions remplir à partir des 2 premières afin qu’elle nous fournisse les informations demandées.

Ce problème fait appel à des composants de la catégorie « database » qui vont nous permettre d’extraire, d’assembler et d’injecter des données dans des bases suivant ces 3 étapes :

a) Extraction des données des 2 bases datab1 et datab2 Utilisation de 4 composants « tMySQLInput» pour : - extraire la liste des étudiants à partir de datab1 (tMySQLInputDB1_student) - extraire la liste des correspondances entre les étudiants et leur filière à partir de

datab1 (tMySQLInputDB1_match1) - extraire la liste des cours à partir de datab2 (tMySQLInputDB2_course) - extraire la liste des correspondances entre les cours et les étudiants à partir de

datab2 (tMySQLInputDB2_ match2)

figure 3 : Paramètres du composant tMySQLInputDB1_student

b) Multiplexage des données Utilisation du composant central « tmap » qui permet de sélectionner les données entrantes, les conditions et leur destination.

Paramétrage du composant tMap

Comme peut le voir sur la figure 3, le paramétrage du tMap nous propose une vue à gauche des 4 entrées de données, correspondant au 4 tMySQLInput. Le « join » entre

les divers champs sont à définir en reliant simplement les champs concernés, d’où la présence de traits violets sur la gauche de la fenêtre. Ensuite, nous relions les données à extraire (id_Student et id_course) au composant newOutput1, dont nous verrons le rôle juste après, à droite de la fenêtre de paramétrage du tMap.

c) Injection des données dans la base vide Il est enfin nécessaire d’injecter ces données pertinentes (id_Student et id_course) dans la 3ème base, datab3. Ceci est fait en partie grâce au composant newOutput1 du tMap qui est lié au composant tMysqlOutput_2 présent sur le job. Ce dernier est paramétré pour interagir avec datab3, la base à remplir.

figure 4 : Vue complète du job

Il reste alors à démarrer le job grâce à l’icône de la flèche verte, qui doit s’exécuter avec succès. On peut ensuite constater dans notre base de données datab3, que les champs (id_Student et id_course) sont tous là et qu’ils correspondent. Cette base remplit donc à présent son rôle : nous savons que tel étudiant suit tel cours. Note : TOS bénéficie de plus d’une communauté très dynamique. De nombreuses mise à jour sont régulièrement publiées et le forum est très actif, ce qui nous a permis de surmonter quelques difficultés dans la prise en main du logiciel ou des bugs d’un version antécédentes (cf 7.1 Difficultés et problèmes rencontrés).

3.3 Intégration avec SpagoBI Il est à noter que nous avons seulement utilisé une infime partie des possibilités de TOS, en limitant notre production à des tests pour générer une base de données à partir de plusieurs. Une étude approfondie des bases de données « cibles » et des besoins devrait permettre une utilisation optimisée de cette étape.

4 BIRT 4.1 Présentation Le projet BIRT, Business Intelligence and Reporting Tools est un plug-in Eclipse open-source qui propose un système de création de rapports ( ou états ) pour les applications Web. Il se compose d’un outil de conception de rapports basé sur Eclipse et d’un moteur d'exécution installable dans un serveur d'applications J2EE. L'utilisation de BIRT peut se résumer de la façon suivante :

figure 5 : Schéma de l’utilisation de BIRT

En ce qui concerne l’affichage des données. BIRT propose une vue 'Explorateur de données' qui permet la définition d'une ou plusieurs 'sources de données' (par exemple une base de données relationnelles) et d'un ou plusieurs 'jeux de données' extraits de la source de données (par exemple les champs renvoyés par une requête SQL). Les 'jeux de données' constituent les données à afficher. L'édition du rapport se fait en mode graphique en insérant les différents composants graphiques proposés (Texte, image, tableau, liste, graphique, ...). Les valeurs affichées par ces composants peuvent être soit statiques, soit extraites des 'jeux de données', soit calculées en utilisant des formules prédéfinies et des scripts écrits en JavaScript. A tout moment, le concepteur du rapport peut demander son exécution directement à partir du viewer de BIRT. Il y a plusieurs choix possible pour le format de la prévisualisation :HTML ou PDF. La mise en exploitation se fait en déployant le rapport sur un serveur d'applications J2EE dans lequel le moteur d'exécution BIRT a été installé.

4.2 Installation Le projet BIRT propose plusieurs téléchargements mais seul Birt version 2.0.1 fonctionne avec le SpagoBIBirtEngine. http://download.eclipse.org/birt/downloads/build.php?build=R-R1-2_0_1-200602221204 Il faudra donc veiller à prendre la version full comprenant la partie outil de conception (Report Designer) et la partie moteur d'exécution (Report Engine et donc le SpagoBIBirtEngine).

4.3 Utilisation et Intégration avec SPAGOBI La partie BIRT est essentiellement axée pour le développeur. Sachant que le but d'un rapport est d'afficher des données, dans notre projet nous allons utiliser BIRT pour 2 objectifs :

• Créer quelques rapports pré générés que nous chargerons par la suite dans SpagoBI. Ces rapports finis seront directement exécutables pour l’utilisateur dans SpagoBI.

• Dans un second temps, nous avons explorer les fonctionnalités de Birt pour faciliter la préparation de rapport :

Nous avons la possibilité de créer un template qui est un modèle de présentation au niveau design et/ou niveau contenu pour construire des rapports. Nous pouvons aussi personnaliser la librairie comprenant l’ensembles des composants et des données nécessaire pour la préparation des rapports sous Birt.

Pour ce faire nous avons d’abord suivi le tutorial pour créer un rapport afin de maîtriser l’outil BIRT. Puis une fois cette étape de conception maîtrisée nous avons développé les différentes étapes qui vont constituer la création de rapports personnalisées avec la base freebo.

4.4 Création de rapports pré générés

4.4.1 Introduction On commence par la création d’un projet Eclipse (même si BIRT ne nécessite pas la création d'un projet Eclipse d'un type particulier un type de projet nommé 'projet d'état' est tout de même proposé).

figure 6 : Créer un nouvel état

Puis on crée un nouveau rapport : Nous avons ici la possibilité de sélectionner un modèle prédéfini (template) de rapport parmi une liste.( Liste simple, groupées, rapport vierge, graphique etc…) Nous verrons plus tard comment pour concevoir notre propre template. Une fois crée le rapport est disponible dans la zone d'édition.

4.4.2 Créer une source et un jeu de données. Nous allons devoir paramétré une source de données (data source) et un jeu de données (data set) correspondant d’une part à la base de données sur laquelle nous travaillons et d’autre part sur le contenu. Une data source est une connexion à une base de données telle qu’une connexion JDBC. Une data set est une description des données sur lesquelles on va travailler. Les requêtes SQL seront le plus souvent utilisées.

4.4.2.1 Définition de la source de données Chaque rapport est associé à un ou plusieurs jeux de données qui seront manipulés pour définir la structure des données du rapport. En ce qui nous concerne, nous allons par la suite utiliser des bases de données relationnelles accessibles par JDBC découlant de TOS pour définir notre source de données.

figure 7 : Sélection du type de la nouvelle source

4.4.2.2 Extraction à partir d'une base de données Si BIRT prend en charge la connexion à la base de données et l'extraction des données, il faut néanmoins préciser d'une part les informations de connexion (le driver notamment): et d'autre

part la requête SQL à utiliser. Pour ce faire dans l'assistant de création il faut indiquer les paramètres suivants : le driver JDBC, la chaîne de connexion JDBC (sous la forme « jdbc:typeDeBase://adresse:port/baseDeDonnées), le nom d'utilisateur et le mot de passe (optionnel).

Figure 8 : Ajout nouvelle source de données

Nous pouvons ajouter le driver correspondant à la base dans la partie « Gérer les pilotes ». Ainsi nous avons ajouté le driver postgreSQL que nous avons récupéré : jdbc.postgresql.org/download.html En ce qui concerne la base oracle on utilisera le driver : « ojdbc14.jar drive » et pour la base mysql : « mysql-connector-java-3.1.14-bin.jar »

figure 8 : Ajout du driver

L'étape suivante consiste à créer un ou plusieurs 'jeu de données' qui seront associés à la source de données.

4.4.2.3 Manipulation d'un jeu de données (data set)

figure 9 : Nouveau jeu de données

Une fois défini, le jeu de données apparaît dans la vue 'Exploration des données'. L'assistant de création d'un jeu de données permet la visualisation de la structure des tables et l'édition de la requête SQL. Les propriétés du jeu de données sont éditables, il est notamment possible de rajouter des champs calculés : On va indiquer la requête SQL à utiliser. Exemple d’un jeu de données qui est utile pour notre projet :

figure 10 : Jeu de données

Nous pourrons aussi regrouper des données provenant de différentes différents type de DataSources (de 2 bases de données mysql et oracle par exemple) en utilisant « Join Data Set » et créer autant de jeux de données que nécessaire. Nous avons ainsi un ensemble de jeux de données prêt à utiliser.

figure 11 : Explorateur de données

4.4.3 Conception d'un rapport Pour ce qui est du contenu nous pouvons maintenant utiliser l’éditeur proposé par Birt pour : • Choisir le composant que nous désirons insérer dans le rapport parmi les différents types proposés par Birt : les composants permettant d'afficher les données sous forme textuelle (Texte, tableau, liste), ou sous forme de graphiques • Sélection des données à afficher. Ces données peuvent provenir directement du jeu de données ou être calculées par des fonctions javascript prédéfinies. • La dernière étape consiste à la présentation du rapport en personnalisant l’entête par exemple( en ajoutant le nom d’utilisateur, Titre, date et le logo de l’université, police, couleurs). Nous avons maintenant conçu un rapport.

4.5 Créer une librairie Nous avons la possibilité de créer une librairie qui pourra être importé dans n’importe quel rapport et template BIRT afin de réduire significativement le temps de conception. Par exemple, si des composants d’une libraire tel que le logo ou des requêtes sur la base à travers un tableau ou une diagramme, sont utilisés de nombreuses fois au cours de la conception de nouveaux rapports alors la librairie contiendra ces éléments et permettra une réutilisation plus facile.

Les composants qui peuvent être ajoutés à la librairie incluent les data sources et sets, les paramètres des rapports, les tableaux, graphes, thèmes et images… La nouvelle librairie à une extension '.rptlibrary'. Une fois la librairie crée et sauvegardée le développeur pourra importer la librairie pour l’utiliser dans la conception de rapports. Il pourra facilement inclure les composants aux rapports grâce à un simple drag-and-drop. De même un simple import de la librairie suffira pour l’adapter au rapport utilisé. Explications : http://www.theserverside.com/tt/articles/article.tss?l=EclipseBRT

4.6 Créer un template de rapports Nous allons vu que lors de la création d’un rapport nous avons le choix entre plusieurs modèles, Birt donne la possibilité de créer nos propres modèles (template )de rapports adaptés à nos besoins. Ce modèle proposera une structure et un design prédéfini qui facilitera le développement ultérieur de nouveaux rapports.

figure 12 : Création d’un template

Une fois le template crée on le publie. Il sera maintenant disponible dans la liste de templates proposés dans Birt lors de l’ajout d’un nouveau rapport. En particulier nous avons vu comment proposer un template avec une entête adaptée (logo de l’université). La création de template pourra être particulièrement utile dans le cas ou nous souhaiterions personnaliser la présentation des rapports générés par QBE dans SpagoBI. Cette fonctionnalité étant en cours de développement nous n’avons pas pu la tester.

figure 13 : Exemple de rapport BIRT sur la base freebo

4.7 Ajouter un rapport à SpagoBI

4.7.1 Introduction L’ajout de rapports pré générés dans Birt à SpagoBI peut être particulièrement utile pour l’utilisateur final dans le cas ou celui ci peut disposer d’un développeur/gestionnaire de la base pouvant lui proposer une liste de rapports adaptés à ces besoins. Les étapes principales pour exécuter un rapport pré-généré de Birt dans SpagoBI sont : 1. Créer un répertoire pour mettre les rapports 2. Importer les rapports crées dans Birt dans ce répertoire. 3. Tester le Document valider le document (passer l’état de test à release) se logger en bidev ou bitest. Sinon dans l’étape suivante 4. Exécuter le Document en se loggant en user staff_gen par exemple (nous avons également ici la possibilité de valider le document) A noter qu’une modification sur la base de données entraîne une modification de l’affiche du rapport pré-généré dans SpagoBI.

4.7.2 Créer un dossier Afin de pouvoir insérer les rapports et les rendre accessible il faudra créer au préalable un répertoire dans l’arborescence de SpagoBi pour les entreposer. Pour cela nous allons suivre les indications du paragraphe 6.2.1.FUNCTIONALITIES MANAGEMENT du document quickstart. De fait il conviendra de s’identifier en biadmin/biadmin pour pouvoir créer un répertoire. Ensuite il faudra aller dans l’onglet « Document and tree management ».

figure 14 : Document and tree management

Puis sélectionner « functionnalies tree » pour apercevoir l’arbre complet.

figure 15 : Functionnalities management

Ensuite il suffira de cliquer sur une racine et de sélectionner insert pour insérer un nouveau répertoire.

4.7.3 Ajouter les rapports L ‘étape suivante ne nécessite pas nécessairement de changer d’identifiant mais il est conseillé de le faire à partir du profil développeur : bidev/bidev. Il faudra aller dans l’onglet « development Environnment » et changer la vue en arbre en cliquant sur l’image du milieu

Puis conformément aux indications du quickstart(6.3.4.DOCUMENT CONFIGURATION), pour importer les rapports crées dans Birt dans le répertoire de notre choix il faudra cliquer sur l’icône « insert ».

figure 16 : Document configuration

De la on remplira les champs label/name/Engine (BirtEngine) Puis on ira chercher le « report » ou il se trouve, et enfin on cochera dans quel répertoire on veut le mettre.

figure 17 : Ajout du fichier de report dans SpagoBI

4.7.4 Tester et valider les rapports Maintenant afin de vérifier si le rapport est bien exécutable, on se peut se connecter, soit on reste connecté en biadmin, soit en bidev/bidev soit en « tester » (qui est le profil spécifique aux tests et aux validations).

Pour tester si l’exécution marche bien et changer ensuite l’état de « development » à « released » . Il suffit ensuite de cliquer sur le rapport et de sélectionner « execute » pour lancer l’exécution du rapport (à noter que selon les droits on peut changer l’état du rapport)

4.7.5 Exécution

Voilà le rapport est correctement installé sur la plate-forme SpagoBI, il ne reste plus qu’à s’identifier en tant utilisateur (staff_gen par exemple) Puis aller l’onglet navigation, ou l’on verra apparaître l’arbre des répertoires avec les documents présents.

figure 18 : Navigation

On exécute le rapport sur un simple clic gauche.

figure 19 : Exemple de rapport dans SpagoBI

Sources : Présentation et Fonctionnement de BIRT : http://www.eclipsetotale.com/articles/BIRT.html Par ailleurs présence de nombreux tutoriaux sur le site officiel: http://www.eclipse.org/birt/phoenix/tutorial/ 5 Hibernate

5.1 Introduction Pour faire fonctionner QBE à partir de notre propre source de base de données il est nécessaire définir au préalable un nouveau modèle de la base de données. Ce modèle doit être réalisé à l’aide de Hibernate et consiste en la création d’un fichier (jar). Ce fichier est en fait un « datamart », sorte d’entrepôt de données qui décrit la « structure » de la base de données sur laquelle on souhaite appliquer du QBE depuis SpagoBI.

5.2 Présentation d’Hibernate Hibernate est un plugin Eclipse qui nous permet de manipuler les données d'une base de données relationnelle sous forme d'objet (ie un framework de mapping objet/relationnel. Ou de persistance objet des données.). Le fait de manipuler directement les données d'une base sous forme d'objet est beaucoup plus pratique, cela nous permet de nous défaire de toute la couche SQL.

figure 20 : Une architecture en couche (Source : hibernate.org)

De plus, cela permet de définir clairement la limite entre la persistance et la couche métier, ce qui se révèle très utile dans le cas d'une application trois-tiers. Nous allons, cependant, nous intéresser à une couche plus basse d'une architecture applicative, la couche d'accès aux données. Celle-ci permet d'interfacer le code métier avec une source de données. L'intérêt est de pouvoir changer de base de données en n'ayant besoin de ne modifier que la couche d'accès. L'utilisation de Hibernate permettra d'utiliser n'importe quelle BDD, tout en gardant le code Java identique. Pour l'exemple ici, cela dit, nous allons nous servir de MYSQL. Pour télécharger la dernière version d'Hibernate (3.2.0), il suffit d'aller le chercher sur sourceforge http://sourceforge.net/project/showfiles.php?group_id=40712&package_id=12778

5.3 Utilisation d’ Hibernate Pour créer notre fichier datamart.jar, nous devons suivre une procédure précise. Dans Eclipse (où Hibernate est installé), on crée tout d’abord un nouveau « projet Java ». A ce projet, on ajoute (new) un nouveau fichier de configuration Hibernate, « hibernate.cfg.xml ». C’est ce fichier qui prend en paramètres les données utiles pour la connexion avec la base de données souhaitée :

figure 21 : Ajouter un fichier de configuration Hibernate

figure 22 : Configurer le fichier cfg

Type de la base : mySQL/PostgreSQL/,… Driver de la base : exemple pour postgreSQL : org.postgreSQL.Driver url de la connexion : sous la forme « jdbc:typeDeBase://adresse:port/baseDeDonnées login : login pour la connexion à la base de données password : mot de passe pour la connexion à la base de données On prend soin de placer se fichier dans le répertoire qui contient les sources du projet. Nous configurons la « console hibernate » associée au fichier précédent, puis nous devons générer le code Hibernate. Cette étape permet de générer des classes (.java) pour toutes les tables de la base de données et les fichiers de mapping xml associés que nous pouvons apercevoir dans l’arborescence du projet au sein d’Eclipse. Il nous reste alors à exporter le projet sous la forme d’une archive jar : datamart.jar.

figure 23 : Exporter le fichier

Le fichier est maintenant prêt à être importé dans SpagoBI. 6 QBE

6.1 Présentation Query By Example est l’outil intégré à la plateforme SPAGOBI pour créer des requêtes à partir d’une interface graphique. Cette fonctionnalité est importante dans notre projet car elle va permettre à l’utilisateur final, non informaticien, d’interroger une base de données sans connaître le langage SQL et afficher des résultats pertinents.

6.2 Paramètrage QBE permet, au sein de SpagoBI, d’interroger une base de données au travers d’un « datamart ». Pour ce faire, il est tout d’abord nécessaire de modifier des fichiers de configuration de la plateforme de Business Intelligence pour renseigner la présence d’une nouvelle connexion à un base de donnée au travers de QBE. Il faut ainsi modifier les 5 fichier xml suivants (« exo-home » signifie le répertoire désignant le serveur Tomcat avec exo-portal).

a) Dans exo-home/conf/server.xml, on indique les paramètres de définition d’une nouvelle source de données comme une ressource d’application d’un serveur JNDI. Il convient de rajouter ces lignes à l’intérieur de la balise <GlobalNamingResources> :

<Resource name="jdbc/sbifoodmart2" auth="Container" type="javax.sql.DataSource"/> <ResourceParams name="jdbc/sbifoodmart2"> <parameter> <name>factory</name>

<value>org.apache.commons.dbcp.BasicDataSourceFactory</value> </parameter> <parameter> <name>driverClassName</name> <value>org.postgresql.Driver</value> </parameter> <parameter> <name>url</name> <value>jdbc:postgresql://localhost:5432/freebo</value> </parameter> <parameter> <name>username</name> <value>freebo</value> </parameter> <parameter> <name>password</name> <value>freebopass</value> </parameter> <parameter> <name>maxActive</name> <value>20</value> </parameter> <parameter>

<name>maxIdle</name> <value>10</value> </parameter> <parameter> <name>maxWait</name> <value>-1</value> </parameter> </ResourceParams> où jdbc/sbifoodmart2 est le nom de la ressource JNDI (le choix de ce nom vient du fait que la ressource JNDI de démonstration était nommée jdbc/sbifoodmart).. b) Dans exo-home/conf/catalina/localhost/SpagoBIQbeEngine.xml, on indique au moteur

QBE l’existence d’une nouvelle source de données en remplaçant la ligne désignant l’ancienne par celle désignant la nouvelle :

<ResourceLink name="jdbc/sbifoodmart2" type="javax.sql.DataSource" global="jdbc/sbifoodmart2"/> à l’intérieur de la balise contexte. c) On ajoute cette même ligne dans le fichier exo-home/conf/catalina/localhost/spagoBI.xml d) Dans

exo-home/webapps/SpagoBIQbeEngine/WEB-INF/conf/data_access.xml, on associe le nom de la source de donnée (« jdbc/sbifoodmart2 ») à un nom que l’on a choisi : « Foodmart2 » (le choix de ce nom vient du fait que la source de donnée de démonstration était nommée Foodmart).

e) Enfin, dans le fichier exo-home/webapps/SpagoBIQbeEngine/WEB-INF/web.xml, on ajoute ces 4 ligne dans la balise <Webapp> :

<resource-ref> <description>Foodmart2 db</description> <res-ref-name>jdbc/sbifoodmart2</res-ref-name> <res-type>javax.sql.DataSource</res-type> <res-auth>Container</res-auth> </resource-ref>

Les fichiers de configuration modifiés, il faut maintenant importer et déployer le datamart au sein de la plateforme de Business Intelligence. Pour ce faire, il est nécessaire de démarrer SpagoBI et d’aller sur la page du moteur de QBE par le navigateur à l’adresse http://localhost:8080/SpagoBIQbeEngine/ .

figure 24 : Page d’accueil du moteur QBE de SpagoBI

Après avoir cliqué sur le logo, il est nécessaire de se logger en tant qu’administrateur de SpagoQBEEngine. Ces administrateurs et leur mot de passe sont définis dans le fichier exo-home/webapps/SpagoBIQbeEngine/WEB-INF/conf/autorization.xml Il est à noter que les mots de passes sont cryptés dans ce fichier. Pour les générer, Engineering Ingegneria Informatica a prévu un utilitaire (QbeEnginePasswordGenerator.sh sous Unix, QbeEnginePasswordGenerator.bat sous Windows) à télécharger à cette adresse : http://forge.objectweb.org/project/download.php?group_id=204&file_id=7921 Voici son interface, très simple :

figure 25 : Interface du générateur de SpagoBIQbeEngine

Il est à noté que le script .bat ne fonctionne pas sous Windows mais uniquement sous unix avec une erreur non bloquante lors de son lancement. Maintenant loggé en administrateur, nous pouvons charger notre datamart, en lui donnant un nom logique qui correspond à celui de l’argument « name » de la balise « connection » ajoutée dans le fichier exo-home/webapps/SpagoBIQbeEngine/WEB-INF/conf/data_access.xml. et en allant le chercher sur le disque à l’aide du bouton parcourir :

figure 26 : Chargement du datamart dans SpagoBIQbeEngine

Une fois cette étape effectuée, le datamart « Foodmart2 » apparaît en haut de l’écran :

figure 27 : Ajout du datamart dans SpagoBIQbeEngine

Le datamart peut donc être lancé depuis cette page. Pour cela, il convient de cliquer sur son icône correspondante représentant un loupe (la crois sert à supprimer le datamart). Il nous est alors demandé le « dialect » de la source de donnée (mySQL, postgreSQL, Oracle,…)

figure 28 : Sélection du dialect du nouveau datamart

Un clique sur la disquette et l’on peut faire des requêtes graphiques sur notre base de données.

6.3 Fonctionnement L’interface QBE se présente ainsi :

figure 29 : Interface du moteur de QBE

On aperçoit toutes les tables (qui rentrent dans la fenêtre) de notre base de données « freebo », qui laissent apparaître leurs champs lorsqu’elles sont cliquées. Cette première étape est appelée « Field Selection » comme l’indique l’onglet (haut de la page » sélectionné. On trouve ensuite des étapes facultatives dans l’interrogation de la base : - conditions : conditions sur les champs de données sélectionnés. - Ordering : pour classer ses résultats - Grouping : pour les grouper - View Query : pour voir la requête SQL générée par le moteur - Save Query : pour la sauvegarder Ensuite, l’étape obligatoire : Execute Query pour générer les résultats associés à la requête de l’utilisateur. Ceux-ci s’affichent alors à l’écran :

figure 30 : Affichage des résultats d’une requête QBE Ici on affiche toutes les filières de la base dont le type est « iut ». Comme on peut le voir, il est possible de les exporter sous plusieurs formats « connus » tels que pdf, xls, xml,… La démonstration que nous venons de voir s’effectue depuis la page du moteur QBE de SpagoBI et sous le login d’un administrateur QBE. Ce paraît évident, c’est qu’un utilisateur lambda puisse effectuer une telle opération depuis l’interface principale de SpagoBI et sous son login ou du moins un appartenant au type « utilisateur » (« Users »). Pour ce faire, il est nécessaire de définir un document de « type datamart » au sein de SpagoBI. Une fois connecté sur SPAGOBI en biadmin / biadmin (profil « technicien»), il faut aller sur l’onglet « document and tree management », sélectionner les documents de type « QBE », montrer les templates en cliquant sur « Show document templates ». Les différents templates s’affiche, il convient alors de télécharger celui à modifier. C’est dans ce fichier xml que l’on remplacera les lignes existantes par celle-ci : <QBE> <DATASOURCE name="Foodmart2" dialect="org.hibernate.dialect.PostgreSQLDialect" /> <DATAMART name="Foodmart2"/> </QBE> en rapport avec le nouveau datamart à « exploiter ». Il faut à présent charger ce fichier modifié grâce au bouton « parcourir », puis sauvegarder.

figure 31 : Interface de modification des templates QBE

Ainsi, un utilisateur (et non un technicien), loggé sous staff_gen/staff_gen peut accéder aux fonctionnalité du moteur QBE depuis l’interface principale de SpagoBI.

figure 32 : Aperçu de l’Interface Utilisateur du moteur QBE dans SpagoBI

7 Problèmes rencontrés :

7.1 Difficultés et problèmes rencontrés

- L’installation « manuelle » de SpagoBI en ligne de commandes nous a posé des problèmes sur les différents systèmes sur lesquels nous avons essayé : Windows XP, Linux et Mac OS souvent avec des erreurs différentes. Heureusement, en avril 2007, Engineering Ingegneria Informatica proposait un installeur graphique de la plate-forme Open Source. - Nous avons parlé de nos difficultés à faire des requêtes graphiques au sein de SpagoBI (QBE) sur la base de données que M. Spriet a installé sur notre serveur à l'IUP. La taille de la base de données à manipuler étant conséquente (800 Mo), cela a entraîné une portabilité délicate et des temps de chargement assez long pendant la manipulation. L’encodage des caractères du fichier de Dump de la base a également du être modifié. Nous avons du procéder sur des bases d ‘exemples de nos crues pour toutes les phases de tests et d’apprentissages.

- Pour installer la base de donnée sur une machine Windows, il est nécessaire que le disque soit partitionné en NTFS, ce qui exclu les autres modes.

- Talend Open Studio a posé un problème bloquant sur un composant (tmap), ce que nous avons signalé sur le forum officiel. Il s’agissait d’un bug reconnu par l’équipe de développement, il nous a fallu changé de version de logiciel (lien sur le forum : http://www.talendforge.org/forum/viewtopic.php?id=476) pour passer de la M3 à la RC1.

- Trouver les bonnes versions des solutions intégrées à SpagoBI, par exemple SpagoBIBirtEngine ne tourne qu’avec Birt version 2.0.1. et cela n’est pas indiqué implicitement.

- La solution étant jeune et en pleine évolution, les points manquants et défaillants sont encore nombreux et en cours de résolutions.

- De plus la communauté Internet étant peu développée et très peu active, les cas de blocage furent nombreux et mirent du temps à se résoudre.

- Difficulté évidente à « s’auto former ».

- La réalisation de ce fichier pour la base de donnée du projet freebo, nous a engendré 8 erreurs pour huit classes distinctes. Il a donc fallu supprimer ces classes (ainsi que les fichiers de mapping xml associés) du projet pour pouvoir créer le .jar. Dans le cas contraire, le .jar que l’on importe dans SpagoBI génère une erreur bloquante qui affiche les deux caractères ‘]>’ au sein de la page web en lieu et place des tables et champs de la base de données.

7.2 Forums Voici les sujets que nous avons crée où dont nous avons participé dans différents forums: - Forum officiel de SpagoBI (http://forge.objectweb.org/forum/?group_id=204) : Sujet : « Problem with the jndi server definition » http://forge.objectweb.org/forum/forum.php?thread_id=3448&forum_id=862 Sujet : « how to change the QBE datasource » http://forge.objectweb.org/forum/forum.php?thread_id=3402&forum_id=862 Note : ce sujet est resté sans réponse. Sujet : « Errors when launching spagoBI » http://forge.objectweb.org/forum/forum.php?thread_id=3354&forum_id=862 - Forum officiel de Talend Open Studio (http://www.talendforge.org/forum/) : Sujet : « How to connect 2 databases » http://www.talendforge.org/forum/viewtopic.php?id=406 Sujet : « DBConnection problem » http://www.talendforge.org/forum/viewtopic.php?id=429 Sujet : « tmap editor error » http://www.talendforge.org/forum/viewtopic.php?id=476 Sujet : « A beginning error with DBConnections » http://www.talendforge.org/forum/viewtopic.php?id=475 - Forum de Hardware.fr (http://forum.hardware.fr/) Sujet : « Problème d'encodage de caractères » http://forum.hardware.fr/hfr/OSAlternatifs/Codes-scripts/probleme-encodage-caractere-sujet_63206_1.htm Note : ce sujet fait suite au problème d’encodage du fichier dump de la base freebo. - Forum de Developpez.com (http://www.developpez.net/forums/) Sujet : « Comment installer birt sous MacOs X » http://www.developpez.net/forums/showthread.php?p=2067015#post2067015 Sujet : « Hibernate et le QBE » http://www.developpez.net/forums/showthread.php?p=1953381#post1953381 Sujet : « [SpagoBI] Recherche de documentation » http://www.developpez.net/forums/showthread.php?p=1953122#post1953122

Sujet : « Si qqun connait spagoBI » http://www.developpez.net/forums/showthread.php?p=1952741#post1952741 Sujet : « Recherche ETL pour SPAGOBI » http://www.developpez.net/forums/showthread.php?t=283818 8 Organisation du travail

• Semaines du 21 janvier au 5 février o Analyse comparative technique des solutions SpagoBI et Pentaho

• 7 février : o Choix de la solution avec monsieur Spriet

• Semaine du 12 au 18 o Proposition de planning o Prévision pilotage o Développement de la Page Web du projet.

• Semaine du 19 au 25 février o Installation Tomcat et java JDK à nos domiciles. o Recherche d’informations pour le choix de l’ETL, l’outil d’extraction de bases

de données (la partie principale de notre projet) o Entre Kettle (le plus répandu) et Talend Open Studio (en voie d’intégration

avec la plate-forme SpagoBI) nous avions d’abord pensé utiliser Kettle, puisque Kettle marche avec du java et Talend Open Studio avec du Perl.

o Mais le 28 février, nous avons appris que Talend Open Studio venait de sortir une version qui supporte java. Donc le choix de l’ETL s’est porté sur Talend Open Studio.

• Semaine du 25 au 4 Mars

o Installation Tomcat et SpagoBI à nos domiciles

• Semaines du 4 Mars au 6 Avril o Tentatives d'installation d'eXo-Tomcat pour SpagoBI sur le serveur de l'IUP. o Prise en main de Talend Open Studio (outil d'ETL) et de Birt (générateur de

rapport).

• Semaines du 10 Avril au 11 mai o Prise en main de Birt pour la création de « reports » sur des données

implémentées au sein d'un SGBD (postgreSQL dans notre cas) d’exemples personnalisés.

o Tests pour le fonctionnement de la partie « qbe » (Query by example) de SpagoBI pour pouvoir faire des requêtes graphiques en ligne sur une base postgreSQL.

o Installation et prise en main d'Hibernate (plugin Eclipse de framework de mapping objet/relationnel)

o Conception d’un datamart nécessaire pour le fonctionnement de SPAGOBI sur notre base de données.

• Semaines du 12 Mai au 28 Mai

o Essais pour faire fonctionner le « qbe » sur la base de données de M Spriet se trouvant sur Harry (nécessité de faire un « dump » de la base).

o Développement final du site Web du projet. o Essais pour pouvoir présenter au sein de SpagoBI des rapports concernant la

base de données de M Spriet. o Création de templates et de « reports » avec BIRT sur des données

implémentées au sein de la base de données fournie (postgreSQL dans notre cas).

o Ajout de ces « reports » dans SPAGOBI (test sous XP et MacOS X). o Facultatif : installation de SpagoBI sur le serveur de l'IUP avec Talend Open

Studio et BIRT (nécessité de l'installation d'un serveur X sur le serveur).

9 Conclusions Le domaine de la Business Intelligence regroupe des fonctionnalités très demandées dans le domaine de l’informatique. Les outils de ce type sont complexes, lourd à mettre en place et le plus souvent payants. Mais depuis quelques temps, certains logiciels, à l’image de SpagoBI, proposent des solutions open source et gratuites. Ces produits sont encore jeunes mais tout à fait utilisables et évoluent à grands pas. La découverte, l’installation et l’utilisation de SpagoBI nous a permis de voir qu’il était possible de remplir l’objectif de notre projet à travers cette solution. Une fois installée et configurée, cette plate-forme de Business Intelligence nous a prouvé qu’à travers celle-ci, nous pouvions créer des groupes d’utilisateurs, interroger n’importe quelle base de données graphiquement et dresser des rapports prédéfinis sur les données qui évoluent au sein de la base. Ainsi, les utilisateurs non-informaticiens peuvent accéder en ligne comme ils l’entendent aux données dispersées dans le système d’informations et les mettre en forme pour les exploiter. Ce rapport présentes toutes les marches à suivre pour

- installer et paramétrer SpagoBI - extraire des informations à partir de plusieurs bases de données (ETL) - définir de nouvelles connexions vers dans nouvelles bases de données pour pouvoir les

interroger graphiquement en ligne au sein de SpagoBI (Hibernate, QBE) - définir des rapports prédéfinis, intégrés dans SpagoBI qui évoluent avec les données

physiquement implémentées (BIRT) Nous avons du faire face à la complexité et la taille de la solution à développer. Malgré le fait que nous nous intéressions seulement à la partie création graphique de rapports, nous avons conclu qu’il était indispensable d’aborder les différentes étapes d’un projet de Business Intelligence pour pouvoir exécuter le QBE. Cela a entraîné des contraintes de temps d’apprentissage conséquent qui ont fait qu’au niveau de l'organisation et de la gestion du projet nous avons du passer par une longue phase d’apprentissage en parallèle pour comprendre les concepts fondamentaux de la solution. Par ailleurs, parmi les orientations qui peuvent être envisagées : SpagoBI donne la possibilité d’utiliser le scheduler intégré à TOS afin d’automatiser l’accès aux bases de données. Une étude des besoins de l’utilisateur devrait permettre l’optimisation de l’exploitation de la base de données pour explorer les possibilités qu’offrent TOS et pour spécifier son intégration. De même pour construire une librairie Birt et des templates (que nous avons mentionné précédemment). Concernant la définition des utilisateurs, nous avons la possibilité de créer de façon complète et détaillée des groupes d’utilisateurs afin d’adapter clairement les accès aux besoins des utilisateurs. Et ainsi fournir un schéma complet des utilisateurs. Une plate-forme libre de Business Intelligence peut difficilement se réduire à du QBE et du reporting et l’on peut très bien imaginer à terme remplacer une solution propriétaire. Ce qui s’avère fortement intéressant et mérite d’être étudié plus largement.

10 Annexes :

10.1 Notice d’installation SPAGOBI Il est recommandé d’installer d’abord Tomcat avec exo-Portal, puis l’installation graphique de SpagoBI. Ensuite les installations de Birt, Hibernate ( plug-ins Eclipse ) et Talend Open Studio. Toutes les sources et les notices se trouvent dans les liens suivants.

10.2 Versions et liens des fichiers utiles

10.2.1 Documentation : Installation Graphique : HowToUseSpagoBIInstaller--1.9.2.pdf http://forge.objectweb.org/project/download.php?group_id=204&file_id=7927 Installation manuelle : SpagoBI_eXoTomcat_Installation_Manual_1.4.3.pdf.zip http://forge.objectweb.org/project/download.php?group_id=204&file_id=7704 Configurer SpagoBI : SpagoBI_How_To-1.6.pdf http://forge.objectweb.org/project/download.php?group_id=204&file_id=7661 Pour débuter avec SpagoBI : QuickStart-0.9.2.pdf.zip http://forge.objectweb.org/project/download.php?group_id=204&file_id=7660 Petite aide visuelle pour SpagoBI : petite_aide_visuelle_spagobi.pdf http://www.altic.org/actualite/98.shtml Livret blanc de Talend Open Studio (Installation et prise main): Documentation sur BIRT (site officiel) : http://www.eclipse.org/birt/phoenix/ Documentation BIRT (site référence français) : http://www.eclipsetotale.com/articles/BIRT.html

10.2.2 Fichiers nécessaires au fonctionnement de SpagoBI : - exo-portal-1.1.4-tomcat.zip http://forge.objectweb.org/project/download.php?group_id=151&file_id=8171 - Espace de téléchargement de SpagoBI et de ses moteurs : http://forge.objectweb.org/project/showfiles.php?group_id=204

- SpagoBIInstaller-1.9.2-04062007.zip http://forge.objectweb.org/project/download.php?group_id=204&file_id=7970 - SpagoBIQbeEngine-bin-1.9.2-03302007.zip http://forge.objectweb.org/project/download.php?group_id=204&file_id=7921 - OpenOffice : http://download.openoffice.org/index.html - JDK : http://developers.sun.com/downloads/ - Birt 2.0.1 http://download.eclipse.org/birt/downloads/build.php?build=R-R1-2_0_1-200602221204 Note : Nous vous conseillons de prendre birt-report-designer-all-in-one-2_0_1. - Eclipse http://www.eclipse.org/downloads/download.php?file=/eclipse/downloads/drops/R-3.2.2-200702121330/eclipse-SDK-3.2.2-macosx-carbon.tar.gz - Hibernate (JBossIDE-1.5-ALL.zip à dézipper) http://sourceforge.net/project/showfiles.php?group_id=22866&package_id=72248&release_id=382687