Download - Rapport Sem2

8/18/2019 Rapport Sem2

1/40

Projet M1

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

type Business Object

Professeur Tuteur : Thierry Spriet


2/40

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 ...........................................................................................................41.6 Rappel sur les solutions envisagées.........................................................................5

2 La plate-forme SPAGOBI...............................................................................................52.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........................................................................83.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 ............................................................154.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).............................................. 174.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..........................................................................224.7.5 Exécution......................................................................................................23

5 Hibernate......................................................................................................................245.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 .................................................................................................369 Conclusions..................................................................................................................38


3/40

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


4/40

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 cettederniè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 lelangage 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}


5/40

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 lefichier 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-formenous 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 travaillerindé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.


6/40

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 sontté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 configurationslégères et enfin l'installation des moteurs souhaités (Birt, QBE,...).


7/40

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 disabledCette 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 pass'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) etdé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


8/40

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éesré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 del'installeur graphique, nous avons découvert et pris en main Talend Open Studio dans saversion 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 programmeurd'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.


9/40

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 permettrontde 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éeslogin/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


10/40

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 voudrionsremplir à partir des 2 premières afin qu’elle nous fournisse les informations demandées.


11/40

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


12/40

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


13/40

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 danslequel 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 deconception (Report Designer) et la partie moteur d'exécution (Report Engine et donc le

SpagoBIBirtEngine).


14/40

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éesné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


15/40


16/40

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.


17/40

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


18/40

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 parexemple( 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 quelrapport 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.


19/40

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 ledé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 del’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.


20/40

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 pourl’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 suivante4. 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 ».


21/40

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 encliquant sur l’image du milieu


22/40

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


23/40

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


24/40

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 » dela 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 dedonné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)


25/40

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 lacouche d'accès.

L'utilisation de Hibernate permettra d'utiliser n'importe quelle BDD, tout en gardant le codeJava 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, onajoute (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


26/40

figure 22 : Configurer le fichier cfg

Type de la base : mySQL/PostgreSQL/,…

Driver de la base : exemple pour postgreSQL : org.postgreSQL.Driverurl de la connexion : sous la forme « jdbc:typeDeBase://adresse:port/baseDeDonnées

login : login pour la connexion à la base de donnéespassword : 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 lestables 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


27/40

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’unenouvelle 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 :

factory

org.apache.commons.dbcp.BasicDataSourceFactory

driverClassName

org.postgresql.Driver

url

jdbc:postgresql://localhost:5432/freebo

username

freebo

password

freebopass

maxActive

20


28/40

maxIdle

10

maxWait

-1

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 moteurQBE l’existence d’une nouvelle source de données en remplaçant la ligne désignant

l’ancienne par celle désignant la nouvelle :

à 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) Dansexo-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 » (lechoix 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 :

Foodmart2 db

jdbc/sbifoodmart2

javax.sql.DataSource

Container

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


29/40


30/40

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.


31/40

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 :


32/40

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 » telsque 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 :

en rapport avec le nouveau datamart à « exploiter ».

Il faut à présent charger ce fichier modifié grâce au bouton « parcourir », puis sauvegarder.


33/40

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


34/40

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 deSpagoBI (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 sontencore 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.


35/40

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 »


Sujet : « tmap editor error »


Sujet : « A beginning error with DBConnections »


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


Sujet : « [SpagoBI] Recherche de documentation »



36/40

Sujet : « Si qqun connait spagoBI »


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 pilotageo 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éesimplé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


37/40

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


38/40

9 Conclusions

Le domaine de la Business Intelligence regroupe des fonctionnalités très demandées dans ledomaine 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èsaux 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.


39/40


40/40

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

- Eclipsehttp://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_i

d=382687