Projet CRM avec SIEBEL - Université de Montpellier

Université Montpellier II
Faculté des Sciences
Master 2
Informatique Pour les Sciences
Projet CRM avec SIEBEL
Rapport de stage présenté par
Baidy DIOP
Sous la direction de
Mme Souhila KACI
Pour l’obtention du Master 2
Informatique
Entreprise d’accueil : CGI
Tuteur en entreprise : Samuel REYNAUD
Année Universitaire 2013-2014
Université Montpellier II
Remerciements
Je tiens tout d’abord à remercier l’ensemble de l’équipe AMADEUS pour ses conseils et son
accueil convivial, mais également l’ensemble des collaborateurs de la société.
Je remercie également Monsieur Mickaël CLERC pour la confiance qu’il m’a accordée dans
le cadre du projet AMADEUS.
Madame Christiana MAZIANI mérite aussi ma gratitude pour le temps qu’elle m’a accordé et
pour les connaissances qu’elle m’a apportées.
Je remercie aussi la faculté des sciences de Montpellier et l’ensemble du corps enseignant
pour la formation et pour l’enseignement que l’on m’a inculqué durant cette année de master
2.
Pour finir, je remercie tout particulièrement mon maitre de stage Monsieur Samuel
REYNAUD pour sa patience.
II
Sommaire
Remerciements ................................................................................................................................... II
Sommaire ............................................................................................................................................ III
Glossaire ............................................................................................................................................. IV
Introduction ......................................................................................................................................... 1
1 Contexte du stage ........................................................................................................................... 2
1.1
Présentation Groupe CGI ................................................................................................. 2
1.2
Missions réalisées durant le stage .................................................................................. 6
2 Projet AMADEUS .......................................................................................................................... 7
2.1 Description du projet ........................................................................................................................ 7
2.2 Le système d’information Amadeus ............................................................................................ 8
2.3 Contexte technologique : CRM, progiciel Siebel .................................................................. 10
2.4 Le paramétrage à l’aide de Siebel Tools .................................................................................. 12
2.5 Méthodologie Agile – Scrum ...................................................................................................... 16
2.6 Mon rôle dans le projet ................................................................................................................ 21
3 Projet : Client léger « Cartographie Siebel » ........................................................................ 23
3.1 Objectifs de l’application ............................................................................................................. 23
3.2 Conception ........................................................................................................................................ 25
4 Bilan ............................................................................................................................................... 38
Conclusion ......................................................................................................................................... 39
Références .......................................................................................................................................... 40
Annexes .............................................................................................................................................. 41
1 Formulaire de connexion : Code Prime Faces Nouvelle Page de connexion ....... 41
2 Code Prime Faces : Nouvelle Page des Onglets .............................................................. 43
III
Glossaire
Business Component (BC): Composant métier qui permet l’accès à une collection de colonnes
d’une table. Il agrège une ou plusieurs tables.
Business Object (BO): Composant métier faisant partie de la couche Business de Siebel. Il
regroupe un BC parent et un ou plusieurs BC fils.
Java Bean : Un composant JavaBean est une simple classe Java qui respecte certaines
conventions sur le nommage, la construction et le comportement des méthodes.
Java Server Faces : Framework Java, dédié au développement d'applications Web.
PrimeFaces : Librairie Open Source proposant une multitude de composants Web pour le
framework JSF.
Repository : Il contient les tables de la base Siebel, l'ensemble des définitions d'objets et de
scripts Siebel. Ils sont compilés dans un fichier appelé repository (de type SRF).
CRM/GRC : La gestion de la relation client (abrégée GRC) est la traduction de l'anglais
Customer Relationship Management (CRM). La GRC a pour but de créer et entretenir une
relation mutuellement bénéfique entre une entreprise et ses clients. Dans ce mode de relations
commerciales, l'entreprise s'attache la fidélité du client en lui offrant une qualité de service
qu'il ne trouverait pas ailleurs. L'image souvent employée pour illustrer ce concept est celle de
la relation entre un petit commerçant et ses clients. La fidélité de ces derniers est
récompensée, car le commerçant connaît leurs attentes et est capable d'y répondre et de les
anticiper (comme un boulanger qui vous met de côté une baguette cuite selon votre préférence
et vous fait crédit).
IV
Introduction
Aujourd'hui une des premières ressources de nombreuses entreprises est, après son personnel,
l'information. A tous les niveaux d'une entreprise, des quantités importantes d'informations
sont échangées, manipulées, traitées chaque jour. L'amélioration des performances d'une
entreprise, tant au niveau financier qu'au niveau de la satisfaction de sa clientèle, passe
souvent par une meilleure intégration de ses différents services. De plus en plus, les
entreprises ont su exploiter ces informations. Ainsi, de nouvelles technologies permettant aux
entreprises de mieux connaître leur clientèle ont vu le jour: c’est le cas dans le domaine du
CRM (Customer Relationship Management). Dans le CRM ou Gestion de la Relation Client,
les technologies SIEBEL sont devenues incontournables.
C’est ainsi que le Group - CGI plus particulièrement le Centre de Services du
Languedoc(CSL) de Montpellier s’est spécialisé dans le développement de solution CRM et
BI (Business Intelligence) avec un savoir-faire au développement d’applications Siebel. Le
CSL dispose de capacités industrielles pour prendre en charge l’ensemble du cycle de vie des
applications CRM – analyse et choix de la solution, implémentation, évolution et
maintenance, avec un modèle de sourcing répondant aux attentes du client. Aujourd’hui près
de 60% des projets traités au C.S.L portent sur la solution Siebel.
Mais comment intégrer les données des différents services d’une entreprise ? Par quels
moyens ? Quels sont les enjeux ? Ces interrogations m'ont amené à effectuer un stage d'une
durée de 6 mois au sein de CGI Montpellier.
Le présent rapport va permettre d’identifier les différentes phases de mon stage. Je
commencerai par présenter l’entreprise CGI et plus particulièrement le CSL, l’antenne dans
laquelle j’ai réalisé ce stage mais aussi les différentes missions auxquelles j’ai été affecté.
Ensuite, je détaillerai le projet CRM Amadeus ainsi que l’outil et la méthode de conduite de
projet utilisé pour le réaliser. Puis je ferai un bilan de mes différentes missions : points positifs
et difficultés rencontrés. Et enfin, dans le cadre de l’industrialisation des processus, je
déclinerai les objectifs et les technologies utilisées pour réaliser la nouvelle application
Cartographie.
Année Universitaire 2013-2014
Université Montpellier II
1 Contexte du stage
1.1 Présentation Groupe CGI
De 1968 à aujourd’hui, cette entreprise a connu de nombreuses évolutions. Tout d’abord
connu sous le nom d’Unilog, puis de Logica, elle se nomme CGI depuis août 2012.
Afin de mieux comprendre l’histoire de cette société et les avantages que lui ont apportés ces
différents changements, nous allons découvrir les étapes qu’elle a traversées ainsi que les
métiers qu’elle exerce.
1.1.1 D’Unilog vers CGI
La société Unilog est une société de service en informatique qui a été créée en 1968 et qui est
entrée en bourse vingt ans plus tard.
Cependant en 2005, Unilog fusionne puis devient Logica ce qui lui permet d’accéder au
marché européen.
Logica est un acteur européen majeur des services informatiques. Le groupe réunit 39 000
personnes dans 36 pays ainsi que 9 000 collaborateurs français. Son activité englobe le conseil
en management, l’intégration de systèmes et l’outsourcing.
Ses 1 000 consultants se différencient par l’équilibre de leurs compétences sur les volets
métiers, fonctionnels et technologiques
En aout 2012, la société Logica est officiellement rachetée par le groupe canadien CGI fondé
en 1976.Cette acquisition a permis au groupe d’agrandir son équipe de 31 000 à 69 000
professionnels répartis dans 40 pays.
Aujourd’hui le Groupe CGI est présent dans toutes les grandes villes de France où chaque
ville est spécialisée dans un domaine précis.
2
Figure 1 Cartographie des Centres de Services en France
La présence de CGI sur le continent Américain, en Europe et en Asie permet au groupe de
répondre aux besoins et aux exigences de ses clients partout dans le monde.
3
1.1.2 Métiers de CGI Montpellier
CGI est une Société de Services en Ingénierie Informatique (S.S.I.I.). Le bâtiment de
Castelnau-le-Lez est séparé en deux agences : SOL et CSL.
Sud-Ouest Languedoc (SOL) intervient sur des missions de conseils, d’intégration et
d’outsourcing pour des clients locaux.
Le Centre de Services du Languedoc (C.S.L.), est spécialisé dans deux technologies : la
Business Intelligence (B.I.) et le Customer Relationship Management (C.R.M.). Ainsi, tous
les projets touchant de près ou de loin au CRM ou à la BI, sont traités au CSL. Le CSL
compte 165 consultants, dont 125 à Montpellier et 40 en Inde. Le diagramme ci-dessous
présente la répartition de l’activité au CSL.
Répartition de l'activité
3%
6%
SIEBEL
2%
SFDC, MS CRM,
Fusion CRM
lnformatica
7%
40%
Datastage
11%
SAS
19%
Reporting
12%
GCM (Neolane /
Unica)
Figure 2 Diagramme de répartition de l’activité au sein du CSL
Une grande partie des missions effectuées par le CSL touche au secteur du CRM. En effet
c’est sur cette technologie que le CSL a le plus de recul. Néanmoins, l’informatique
décisionnelle prenant de plus en plus d’ampleur dans les entreprises, le CSL souhaite
développer très rapidement son pôle BI.
4
1.1.3 Expertise sectorielle
Veille sectorielle, compréhension des enjeux métiers, capitalisation des expériences, et
maîtrise des technologies innovantes mobilisent les équipes d'experts sectoriels de CGI à
l'échelle mondiale. CGI est présent dans l'assurance, la banque, les transports, l'énergie mais
aussi dans les télécoms ou la distribution. Les expertises se traduisent en solutions concrètes
et adaptées à chaque secteur.
Figure 3 Expertise sectorielle
5
1.2
Missions réalisées durant le stage
Mon stage s’est articulé sur deux missions distinctes : tout d’abord participer à un projet de
CRM pour un client grand compte Amadeus et d’autre part le développement d’une
application web Java EE nommée Cartographie.
La première partie du stage m’a conduit à m’intéresser au domaine de la Gestion des
Relations Client ou CRM, à étudier de manière globale la problématique de l’intégration des
différentes sources d’informations d’une entreprise et la manière de mener un projet en
informatique, puis faire un tour d’horizon des solutions proposées par l’application SIEBEL.
C’est dans ce contexte que j’ai effectué une formation d’une semaine sur l’administration
fonctionnelle et les techniques de développement avec l’application SIEBEL. Par la suite, j’ai
intégré une équipe de 6 personnes chargée de l’élaboration et la conduite du projet CRM pour
le compte d’Amadeus. Cette première partie du stage a été suivie par Mickaël CLERC, chef
du projet, ce qui m’a donné une première occasion de faire l’expérience de participer à un
projet d’envergure en informatique.
La seconde partie de mon stage a été consacrée à transformer une application
« Cartographie » développée en VBA en une application web Java EE. Cette mission rentrait
dans le cadre de l’industrialisation des processus mis en œuvre par le CSL. En résumé,
l’outil « Cartographie » permet, à partir du nom technique de la vue (couche présentation de
Siebel : ce que voit l’utilisateur), de lister les objets Siebel impactés et utilisés. Cette seconde
partie a été suivie par Nicolas ZRAIK, ingénieur en technologie de l’information. C’était
l’occasion d’améliorer mes connaissances en technologie du web.
6
2 Projet AMADEUS
Amadeus est le premier fournisseur mondial de solutions technologiques et de distribution
pour l'industrie du voyage et du tourisme (solutions de traitement des réservations pour
l'industrie du voyage). Les prestataires de voyage (compagnies traditionnelles et à bas prix,
hôteliers, croisiéristes, compagnies ferroviaires, de ferry, de location de voitures et touropérateurs) et agences de voyages (en ligne et hors ligne) bénéficient de la puissance de
traitement des transactions et des solutions technologiques fournies par Amadeus. Les offres
d’Amadeus sont organisées en quatre grandes catégories :
Distribution & contenu : Des solutions qui permettent aux distributeurs d'accéder
à une offre de voyages exhaustive et donnent aux fournisseurs les moyens d'optimiser
leur distribution.
Ventes & e-commerce : Des solutions qui permettent d'accéder au marché et de
vendre à travers tous les canaux de distribution.
Business Management : Des solutions technologiques développées dans le but
d'optimiser et de rationaliser les processus.
Services & Consulting : Des services et solutions technologiques pour exploiter
pleinement le potentiel commercial de chaque client et optimiser les investissements
technologiques.
2.1 Description du projet
Depuis 2004, Amadeus a développé sa solution CRM autour du logiciel Siebel. Les
différentes évolutions apportées à la solution au cours des années (moyenne de 2 lots évolutifs
par année) ont rendu la solution instable et difficile à maintenir. En effet, les performances
d’accès aux données et de navigation dans l’application devenaient de plus en plus médiocres
suite à l’ajout continuel de nouvelles fonctionnalités sans forcément d’analyse d’impact sur
l’existant. De plus, le risque de régression à chaque nouvelle évolution ou correctifs
augmentait de façon exponentielle.
Fin 2012, Amadeus (avec le conseil de CGI), a du faire un choix. En effet, une migration du
logiciel Siebel (7.8 à 8.1) était nécessaire pour rendre l’application compatible avec les
nouvelles versions des navigateurs Internet et continuer à bénéficier du support d’Oracle.
Pour cela les trois solutions proposées à Amadeus étaient les suivantes :



Abandonner Siebel et passer sur une autre technologie (Sales Forces)
Exécuter une migration technique de l’application sans modifier les fonctionnalités
proposées.
Repartir d’une version initiale de Siebel et repenser l’ensemble de la solution
7
La troisième solution a été choisie par Amadeus. En effet, même si elle représente un coût
plus important qu’une migration seulement technique, elle s’avère beaucoup moins onéreuse
dans le temps : l’application étant plus stable.
De plus, cette solution a permis d’intégrer une phase de construction avec les utilisateurs pour
repenser avec eux les fonctionnalités de l’application. Ainsi, l’objectif d’Amadeus était de
renforcer l’adhésion des utilisateurs à l’application.
Afin de mener à bien ce projet, le choix de la méthode Scrum (méthode Agile) a été validé
afin de répondre le plus rapidement aux différentes exigences des clients Amadeus. Cette
méthode offre en effet le plus de souplesse pour intégrer les retours clients.
Deux équipes mixtes (Amadeus et CGI) de 6 à 7 personnes ont été formées pour mettre en
place la solution autour du logiciel Siebel.
2.2 Le système d’information Amadeus
Le système d’information d’Amadeus est riche et varié, comme le montre la figure ci-dessous.
Figure 4 Système d’information CRM
8
Les composantes gérées par le logiciel Siebel sont :





Sales : Application permettant aux commerciaux d’Amadeus de suivre l’ensemble de
leur relation client :
o Qualification de prospects
o Détection d’opportunités
o Suivi d’activité
o Reporting
eService : Portail Web, permettant aux clients Amadeus de saisir eux-mêmes leur
demande d’assistance.
HD (Help Desk) : Application via laquelle les employés Amadeus traite les demandes
d’assistance émises par les clients par téléphone, mail ou par le portail eService.
CTI : Outil de connexion entre Siebel et le centre téléphonique
eTraining : Portail Web utilisés par les clients Amadeus pour leur demande de
formation. Ces demandes de formations ainsi que leur suivi (réservation de salle, de
formateur…) sont ensuite traités par les employés Amadeus dans l’application HD.
Les autres applications connectées à l’environnement Siebel concernent la messagerie, la
facturation, les référentiels….
9
2.3 Contexte technologique : CRM, progiciel Siebel
Il s’agit d’une application CRM (Customer Relationship Management) : elle vise à référencer
les activités de chaque client pour ainsi mieux cibler leurs besoins.
2.3.1 Architecture logique des serveurs
Figure 5 Architecture logique des serveurs
Le ou les serveurs Siebel contiennent:
-Un fichier de configuration .cfg, définissant les paramètres pour le fichier repository et la
base de données (connexions Local, Sample, Serveur).
-Un fichier de repository .srf désigne l’application configurée : c’est l’outil Tools compilé en
exécutable.
-Des fichiers Web Templates .swt, spécifiant des modèles d’IHM.
10
2.3.2 Comment utiliser Siebel
Pour accéder aux applications Siebel, l’utilisateur possède différents choix :
-Client léger Siebel Web: travail à distance ou sur site sans installation de Siebel, juste IE,
grâce à l’URL en intranet/extranet
-Siebel Handled and Mobile Web Client : application Siebel et base de données locale
installées sur les ordinateurs portables pour travailler chez un client, en déplacement…
-Client lourd Siebel : utilisé pour tester les développements en local avant de les remonter par
les développeurs et en client dédié sur le serveur Siebel par les administrateurs (accès direct
au repository de référence).
2.3.3 Composition de l’application
L’application Siebel est constituée de trois couches différentes :
Figure 6 Les trois couches de Siebel
11
Respectivement, les objets définis par ces couches sont les suivants :
Figure 7 Composition du repository de Siebel
C’est sur ces objets que porte le développement : leurs définitions composent le Repository
File. Pour y avoir accès, le développeur se sert de l’application Siebel Tools.
2.4 Le paramétrage à l’aide de Siebel Tools
Siebel Tools est une application permettant au développeur de modifier les objets du
Repository. Cependant, pour des soucis de travail en équipe et de sécurité d’intégrité du
Repository, le développeur travail sur son référentiel en local avant de remonter ses
développements sur le serveur grâce au principe du Check In/Check Out.
2.4.1 Le principe du Check In/Check Out
Il permet le travail en équipe :
-Chaque développeur a un référentiel en local, à synchroniser avant modification
-Le découpage par projet permet de ne réserver qu’une partie de l’application à modifier
12
2.4.2 Les objets dans Siebel Tools
Les principaux objets de l’application sont :
Les Objets Siebel
-Les Business Components : c’est la couche logique au-dessus de la structure classique tablecolonne, et qui permet d’accéder aux données de l’application. Un BC pointe sur une table
principale, mais permet aussi d’accéder à plusieurs tables via les jointures.
13
-Les Business Objects : c’est la couche logique permettant de regrouper fonctionnellement les
BC entre eux. Une vue se base sur un seul BO. Au même titre que le BC, le BO pointe sur un
BC principal, mais aussi vers d’autres BC via des Links.
-Les Applets : c’est la couche utilisateur (Interface Homme-Machine), et permet l’accès aux
données du BC auquel elle est rattachée. L’Applet existe principalement sous deux formes : la
List Applet, qui permet d’afficher les enregistrements sous forme de liste, et la Form Applet,
qui elle affiche les données d’un enregistrement sous forme de formulaire.
Pour faire le lien entre l’application et les objets paramétrables dans Tools, il suffit de se
connecter à l’application et de cliquer, dans le menu aide, sur l’option « A propos de la vue »,
comme indiqué ci-dessous :
14
2.4.3 Exemple
Dans la vue ci-dessous, on veut apporter des modifications sur la Form Applet :
Une fois positionné sur la vue à modifier et à l’aide de l’option « A propos de la vue », on
identifie l’applet (ici Order Entry - Order Form Applet (Sales)):
NB : cet écran nous informe de l’ensemble des objets affichés à l’écran (écran, vue, BO, BC
et applet). Ces informations sont présentées de façon hiérarchique et dans l’ordre d’apparition
à l’écran.
Ensuite, dans Tools, à l’aide de l’Object Explorer, on se positionne sur le type de
l’objet et on requête sur le nom de l’applet :
15
NB : attention au système de Check Out/Check In
On effectue ensuite les modifications désirées, dans la mesure du possible en utilisant
le comportement standard des objets. Si et seulement si cela n’est pas possible, on réalise la
fonctionnalité voulue. Dans ce cas, il est impératif de respecter les best practices.
2.5 Méthodologie Agile – Scrum
Les méthodes de développement agile, aussi appelé développement adaptatif, sont des
méthodes axées sur les personnes avec pour objectif, la satisfaction du client en s'appuyant sur
la réalisation d'un logiciel entièrement fonctionnel tout au long de sa fabrication.
16
2.5.1 Principe et différentes phases
Le principe de la méthodologie SCRUM est de développer un logiciel de manière
incrémentale en maintenant une liste totalement transparente des demandes d'évolutions ou de
corrections à implémenter (backlog). Avec des livraisons très fréquentes, toutes les 4
semaines en général, le client reçoit un logiciel à chaque fois, un logiciel possédant toujours
plus de fonctionnalités et en parfait état de fonctionnement. Pour cela, la méthode s'appuie sur
des développements itératifs à un rythme constant d'une durée de 2 à 4 semaines. Les
évolutions peuvent donc être plus facilement intégrées que dans un cycle en V.
Concrètement, cette méthode nécessite 4 types de réunions :
-
Les réunions quotidiennes : chaque jour, toute l'équipe se réunit, généralement
debout, pendant 15 minutes environ pour répondre aux 3 questions suivantes : qu'ai-je
fait hier ?, Que vais-je faire aujourd'hui ? Y a- t- il un obstacle gênant aujourd'hui ?
-
Les réunions de planifications : toute l'équipe se réunit pour décider des
fonctionnalités qui vont composer le sprint suivant et mettre à jour la liste générale.
-
Les réunions de revue de travail : lors de cette réunion, chacun présente ce qu'il a
fait pendant la durée du sprint. Une démonstration des nouvelles fonctionnalités ou de
présentation de l'architecture est organisée. Il s'agit d'une réunion informelle de 2
heures environ à laquelle participe toute l'équipe.
-
Les réunions de rétrospectives : à chaque fin de sprint, l'équipe fait le point sur ce
qui a bien fonctionné et sur ce qui a moins bien fonctionné. Lors de cette réunion
d'une durée de 15 à 30 minutes où chacun est invité et parle en son nom, un vote de
confiance est organisé pour décider des améliorations à apporter.
17
Figure 8 Fonctionnement de la méthode Scrum
L'avantage de la méthode est de réduire au strict minimum la documentation afin de gagner en
productivité. L'idée ici est de ne faire que la documentation minimale qui permet de garder
l'historique des décisions prises sur le projet et de pouvoir facilement intervenir sur le logiciel
lorsqu'il sera entré en phase de maintenance.
2.5.2 Organisation
La méthodologie SCRUM fait intervenir 3 rôles principaux qui sont :
-
Product owner : Dans la majorité des projets, le responsable produit (Product owner)
est le responsable de l'équipe projet client. C'est lui qui va définir et prioriser la liste
des fonctionnalités du produit et choisir la date et le contenu de chaque sprint sur la
base des valeurs (charges) qui lui sont communiquées par l'équipe.
-
ScrumMaster : Véritable facilitateur sur le projet, il veille à ce que chacun puisse
travailler au maximum de ses capacités en éliminant les obstacles et en protégeant
l'équipe des perturbations extérieures. Il porte également une attention particulière au
respect des différentes phases de SCRUM.
-
Equipe : d'une taille allant de 4 à 10 personnes en général, l'équipe regroupe tous les
rôles habituellement nécessaires à un projet, à savoir l'architecte, le concepteur, le
développeur, le testeur, etc. L'équipe s'organise elle-même et elle reste inchangée
pendant toute la durée d'un sprint.
18
Figure 9 Méthodologie Scrum Organisation
2.5.3 Avantages
Scrum se différencie des autres méthodes de développement par ses avantages qui font de ce
procédé une réponse pragmatique aux contraintes actuelles des chefs de produits :
-
Méthode itérative et incrémentielle : cela permet d'éviter "l'effet tunnel", c'est-àdire le fait de ne voir le résultat qu'à la livraison finale et rien ou presque rien pendant
toute la phase de développement, si fréquent dans les développements avec le cycle en
V.
-
Adaptabilité maximale pour du développement de produits et d'applications : la
composition séquentielle du contenu des sprints permet d'ajouter une modification ou
19
une fonctionnalité qui n'était pas prévue au départ. C'est principalement cela qui rend
cette méthode "agile".
-
Méthode participative : chaque membre de l'équipe est invité à s'exprimer et il peut
participer à toutes les décisions prises sur le projet. Il est donc plus impliqué et plus
motivé.
-
Augmentation de la communication : en travaillant dans la même salle de
développement, ou en étant connecté avec différents moyens de communication,
l'équipe peut communiquer facilement et échanger sur les obstacles afin de les
supprimer au plus tôt.
-
Maximisation de la coopération : les échanges quotidiens entre le client et l'équipe
permettent un rapprochement et une entraide se met logiquement en place.
-
Augmentation de la productivité : en supprimant certaines "contraintes" des
méthodes classiques comme la documentation ou la formalisation exagérée, SCRUM
permet d'augmenter la productivité de l'équipe. En ajoutant à cela la qualification de
chaque module permettant d'en déterminer un chiffrage, chacun peut se positionner
par rapport à la productivité moyenne de l'équipe.
2.5.4 Risques et solutions
La méthodologie SCRUM n'est pas une réponse miracle à tous les problèmes inhérents au
développement de logiciels informatiques. Il faut rester vigilant sur les risques ci-dessous,
risques qui possèdent néanmoins, une réponse systématique puisée dans l'extrapolation de la
méthode :
-
Taille de l'équipe : généralement limitée à 7 ou 10 personnes, la taille de l'équipe peut
devenir un obstacle si elle dépasse ces préconisations. L'organisation des réunions
devient alors impossible et les fondements mêmes de la méthode sont alors mis à mal.
La solution consiste à réaliser des Scrum de Scrum. Il s'agit ici de constituer de scinder
le projet en équipes de taille recommandée et d'ajouter une instance de niveau
supérieure regroupant les ScrumMaster de chaque Scrum.
-
Demandes multiples : Les demandes peuvent émaner de multiples canaux sur un
projet et peuvent parfois être difficile à gérer du fait de leur aspect contradictoire. Au
niveau de la recette des livraisons, ces contradictions peuvent alors ralentir le
processus de validation. Pour remédier ce problème, il est impératif d'utiliser un outil
unique de gestion des demandes, outil qui est proposé en standard sur les projets.
-
Qualité des développements : Plus le nombre d'équipes augmente, plus la qualité est
difficile à maîtriser. Ce postulat est d'autant plus vrai dès lors que le projet est réparti
20
sur plusieurs sites. Les risques sont particulièrement liés à la qualité du code et au
nombre de défauts répertoriés au moment de l'intégration. Pour cela, il est important
d'avoir une politique qualité rigoureuse et un plan qualité projet qui définit
précisément les règles du projet. Des audits de code fréquents et la mise en place
d'indicateurs mesurant la performance des développeurs permettent de minimiser ce
risque.
2.5.5 Application sur le projet
Sur le projet Amadeus, la méthode Scrum a été utilisée pendant toute la période de
développement de l’application : 12 sprints de 4 semaines.
Les ressources de développement était séparée en 2 équipes mixtes (composées de
collaborateurs CGI et Amadeus) de 6 à 7 personnes. Chaque équipe possédait un Scrum
master et un Product Owner.
Les réunions quotidiennes étaient réalisées via un outil participatif (Hangout) car les membres
des équipes étaient séparés sur 2 sites (Sophia Antipolis et Montpellier). De plus, le suivi de
l’avancement des tâches et la réalisation des indicateurs de suivi (Burndown chart) était
également réalisés via un outil collaboratif : IceScrum.
Suite à la réunion quotidienne une réunion appelée « Scrum of Scrum », était réalisée entre
les Scrum Master et Product Owner afin de synchroniser l’activité des équipes et gérer les
problèmes commun d’infrastructure.
2.6 Mon rôle dans le projet
Après une formation sur les technologies Siebel, j’ai intégré l’équipe qui était en charge du
développement des modules eService et Help Desk (HD). C’est ainsi que j’ai participé aux
différents sprints (8 à 12), soit en développant des Vues, soit en résolvant des defects (Bugs
ou changements de fonctionnalités sur les développements effectués dans les sprints
précédents).
En réalité, chaque développeur possède un environnement local où il effectue ses
développements avant de les remontés sur le serveur. En effet, le développeur doit :




Effectuer ses développements ;
Tester ses développements ;
Après validation, les remonter sur le serveur ;
Et enfin, rédiger les documents fonctionnels et techniques de ses développements.
21
J’ai eu aussi à traduire les Vues développées dans différentes langues. En effet, du point de
vue technique, chaque libellé dans l’application correspond à un objet nommé symbolic
strings. Une symbolic strings correspond à un libellé en plusieurs langues. Dans cet exemple
ci-dessous, la symbolic string porte comme nom technique SBL_#AGREEMENT_PRINT et
contient la traduction en français, anglais et italien du libellé « imprimer le contrat ». Suivant
la langue avec laquelle l’utilisateur se connecte, les libellés prendront la valeur
correspondante.
Figure 10 Exemple de Symbolic Strings
Cependant, toute l’équipe travaille sur un serveur distant à travers un TSE (Terminal Server
Edition). Ce TSE permet aux utilisateurs d’accéder aux applications et aux données qui sont
stockées dessus. Un des principaux avantages de ce type d’outil est de permettre à tous les
utilisateurs de profiter des mêmes applications sans avoir à effectuer des installations sur les
postes clients, mais également de centraliser les données tout en les sécurisant. Mais, la
principale contrainte reste la qualité du réseau. En cas de défaillance du réseau, le TSE
devient inaccessible, donc le développement.
Plus concrètement, l’utilisation d’un TSE et des outils de gestions de version tels que SVN
permettent donc aux membres de l’équipe distants de participer aux développements et aux
tests sur les mêmes outils et documents que ceux utilisés par les équipes en place.
22
3 Projet : Client léger « Cartographie Siebel »
3.1 Objectifs de l’application
Cartographie Siebel est un utilitaire interne développé en Visual Basic (VB). Le but de cet
outil est de générer un compte rendu technique d’une application Siebel à partir des
informations contenues dans le Repository de l’application. A partir du nom technique de la
vue, l’outil doit renvoyer les objets Siebel Tools impactés et utilisés. L’outil doit fournir une
vue de synthèse des objets (graphiques) utilisés dans l’application.
Objectifs de l’outil :
• Le premier est de lister les objets utilisés dans l’application afin d’en évaluer sa complexité.
• Réaliser une vue détaillée par type d’objet Siebel (Applet, Business Component, etc.).
Cartographie la version VB :
Figure 11 Onglet de connexion
L’application se présente sous forme d’onglet (feuille Excel), comme nous le montre l’écran
ci-dessus. L’onglet « Parameter » permet la connexion sur l’application Siebel. Tous les
autres onglets (en bas de l’écran en vert) représentent les objets (Business Object, Business
23
Component, Applets, etc…) identifiés impactant dans la création de la vue étudiée.
L’application offre aussi une vue de synthèse des Objets dans l’Onglet Stats.
Figure 12 Onglet Synthèse des objets
Il m’a été demandé de transformer cet outil en une application web Java EE. En accord avec
mon tuteur (outillage) cité précédemment, mon choix s’est porté sur les outils suivants pour
réaliser la nouvelle application : Netbeans, JSF, Prime Faces, Maven.
24
3.2 Conception
3.2.1 Technologies utilisées
Les développements sont effectués dans une machine virtuelle (facilité d’installation sur un
poste sans droit administrateur) équipée des logiciels et librairies nécessaires :
NetBeans 8.0 : NetBeans est un environnement de développement intégré (EDI), placé en
open source par Sun. En plus de Java, NetBeans permet également de supporter différents
autres langages, comme Python, C, C++, JavaScript, XML, Ruby, PHP et HTML. Conçu en
Java, NetBeans est disponible sous Windows, Linux, Solaris (sur x86 et SPARC), Mac OS X
ou sous une version indépendante des systèmes d'exploitation (requérant une machine
virtuelle Java). Un environnement Java Development Kit JDK est requis pour les
développements en Java. NetBeans constitue par ailleurs une plateforme qui permet le
développement d'applications spécifiques (bibliothèque Swing (Java)). L'IDE NetBeans
s'appuie sur cette plateforme.
Tomcat : est un serveur d'applications Java. Elle permet de générer une réponse HTML à une
requête.
Figure 13 Architecture serveur d’applications
Concrètement, le serveur d'applications va :
-
récupérer les requêtes HTTP issues des clients ;
les mettre dans des boîtes, des objets, que notre code sera capable de manipuler ;
faire passer ces objets dans la moulinette (qu'est notre application), via le conteneur ;
renvoyer des réponses HTTP aux clients, en se basant sur les objets retournés par
notre code.
25
JavaServer Faces (abrégé en JSF) est un Framework Java basé sur la notion de composants
et destiné au développement d'applications Web. JSF est techniquement comparable à Swing
ou SWT sauf qu'ils sont utilisés pour le développement d'application bureau, en JSF et en
Swing l'état d'un composant (représenté par un objet java) est enregistré lors du rendu de la
page, pour être ensuite restauré au retour de la requête.
Une page JSF est une page xhtml (ou jsp) liée aux Managed Bean via le langage EL. JSF est
principalement constitué de :
-
Un ensemble d'APIs pour la représentation et la gestion des composants, de leur état,
des évènements, de la validation des entrées et la conversion des sorties,
l'internationalisation et l'accessibilité ainsi que la navigation inter-vues.
-
Deux jeux de composants standards (affichage de texte, saisie de texte, tables, zone à
cocher, etc.): html et core.
-
Deux bibliothèques de balises JSP (une pour chaque jeu de composants) pour
permettre l'utilisation des JSPs pour la construction de vues JSF.
-
Un modèle évènementiel côté serveur.
-
Les Managed Beans : qui forment la couche contrôle de JSF.
-
Unified Expression Language : abrégé en EL ou langage d'expressions unifié pour JSF
et JSP 2.0. Il permet de lier les composants aux managed beans.
L'objectif de JSF est de faciliter le développement des interfaces utilisateurs des applications
web, or les deux composants standards de JSF (html et core) s'avèrent limités et insuffisants
pour le développement d'applications d'entreprise. Des jeux de composants additionnels qui
offrent de nouveaux composants plus riches sont indispensables pour le développement en
JSF, Prime faces en offre un qui a prouvé son efficacité.
Maven : Maven permet de faciliter et d'automatiser certaines tâches de la gestion d'un projet
Java. Il permet notamment :
-
d'automatiser certaines tâches : compilation, tests unitaires et déploiement des
applications qui composent le projet.
-
de gérer des dépendances vis à vis des bibliothèques nécessaires au projet.
-
de générer des documentations concernant le projet.
26
Maven utilise un paradigme connu sous le nom de Project Object Model (POM) afin de
décrire un projet logiciel, ses dépendances avec des modules externes et l'ordre à suivre pour
sa production.
Figure 14 Structure projet avec Maven
Il est livré avec un grand nombre de tâches prédéfinies, comme la compilation de code Java
ou encore sa modularisation.
3.2.2 Prime Faces
Prime faces est un jar facile à ajouter dans un projet JSF pour obtenir un jeu de composants
additionnel beaucoup avancé qui prend en compte les nouveautés des technologies du web
surtout Ajax.
JSF est une technologie souvent jugée insuffisante quand on désire développer des
applications professionnelles, c'est pourquoi on peut lui adjoindre des librairies de composants
additionnels.
Cette librairie propose des dizaines de composants insérés directement dans le code.
Ces composants vont du simple bouton ou liste déroulante au diagramme circulaire en passant
par les barres de progression.
27
Dans l’exemple ci-dessus, la librairie Prime Faces est importée via le xmlns. Le bouton
intitulé « Test connection » est ensuite associé à la librairie avec le préfixe « p ».
Un CSS respectant la charte graphique de CGI et un Template ont également été fournis pour
être réutilisés par l’outil de Cartographie Siebel.
3.2.3 Managed JavaBeans
La partie logique de l’application est gérée à l’aide de classes Java de type Managed Bean. Un
bean est une instance de classe serializable, qui possède un constructeur sans paramètre.
Toutes les propriétés d’un Bean sont obligatoirement accessibles par les getters, et les
propriétés qui sont modifiables possèdent en plus des setters. Avant de pouvoir être utilisé par
l’application, chaque managed Bean doit être déclaré à l’aide du fichier de configuration
faces-config.xml de l'application.
Figure 15 Exemple d’une classe java représentant un Bean
JSF permet d’utiliser des Managed Beans qui permettent d’associer à des composants UI
(User Interface) des propriétés et des méthodes. Plus précisément, ce sont les EL (Expression
du Langage) qui permettent de lier la valeur d’un composant à une propriété ou méthode
présente dans le bean associé.
28
Dans l’exemple suivant, la valeur du champ texte « Password » est associée à la variable «
pwd » se trouvant dans la classe « UserBean » d’où l’expression # {userBean.pwd}.
En réalité un JavaBeans est en fait une classe qui respecte un certain nombre de conventions
de nommage et de comportements.
3.2.4 Développement
Une fois l’idée de solution retenue, le développement proprement dit a pu commencer. Face à
l’ampleur de la tâche, il est apparu nécessaire de se fixer des étapes dans le développement.
Ces étapes correspondent généralement à des sous-parties distinctes du travail. L’avancement
de mon travail a été suivi spécifiquement par Nicolas ZRAIK auquel je faisais des comptes
rendus de l’évolution toutes les une à deux semaines. Ces réunions permettaient aussi de faire
des choix sur des détails techniques survenant au cours du développement.
Pour le développement de l’application, j’ai choisi le modèle de conception MVC qui semble
le mieux adapté à nos besoin. Voici dans les grandes lignes ce qu'impose MVC ainsi qu’une
courte introduction de chacune des couches composant une telle application web:
Figure 16 Représentation du modèle MVC


Modèle : Dans le modèle, on trouve à la fois les données et les traitements à appliquer
à ces données.
Vue : Contient tout ce qui concerne l'interaction avec l'utilisateur et la présentation des
données (mise en forme, affichage).
29

Contrôleur : Tout ce qui concerne le contrôle des actions de l'utilisateur et des
données doit être contenu dans cette couche.
3.2.4.1 Modèle
Pour chaque onglet de l’ancienne application, j’ai constitué un objet java (Modèle de donnée)
représentant celui-ci. Prenons l’exemple de l’onglet Applet :
Figure 17 Onglet Applet
L’onglet Applet affiche l’ensemble des applets utilisées par la vue traitée, ici la vue traitée est
« Account List View » (indiquée dans la colonne View) et les Applets qui la composent,
indiquées dans la colonne Applet Name sont « SIS Account Entry Applet et SIS Account List
Applet ». Toutes les autres colonnes (Class, Scripted, Mode, Search Spec, BC, Projet et
Changed) représentent des attributs des Applets.
Donc pour cet onglet, la classe Java correspondante est la suivante :
30
Figure 18 Classe Java représentant un onglet de l’ancienne Application
Ainsi, j’ai procédé de la même manière pour tous les onglets de l’ancienne application pour
représenter mes modèles.
3.2.4.2 Contrôleur
Pour gérer les actions de l’utilisateur, deux Java Beans ont été constitués :

Un bean « userLoggin »qui gère la connexion et la déconnexion au serveur Siebel.
31

Et une dernière « viewManagedBean» qui se charge des fonctionnalités suivantes : la
récupération des données sur le repository Siebel; création d’une vue de synthèse
(graphique) des Objets trouvés; retour à un nouveau traitement d’une vue.
Cependant, Siebel fournit des jars qui contiennent des méthodes pour se connecter, récupérer
des données en Java. Naturellement ces jars sont inclus dans le projet.
-
Bean userLoggin
Figure 19 Bean userLoggin
Comme on le voit sur la figure ci-dessus, il y a un lien héritage de notre Bean avec une classe
Java SiebelDataBean qui se trouve dans les jars cités précédemment.
32
Exemple : La connexion
En encadré la méthode « login » qui est héritée de SiebelDataBean.
-
Bean viewManagedBean
Figure 20 Bean viewManagedBean
33
C’est dans ce contrôleur que se trouve les méthodes ou requêtes qui se chargent d’aller
prendre les données sur Siebel.
Méthode pour récupérer Business Object de la vue
La méthode getViewData (String viewName) est en quelque sorte une requête qui prend en
entrée le nom de la vue et rend en sortie un objet VisibleItemBO chargé des données. En effet,
l’objet retourné n’est rien d’autre qu’une ligne de l’onglet BO de l’ancienne application.
La requête fonctionne principalement de la manière suivante :

La première ligne permet de se positionner sur le Business Component « Repository
View » pour pouvoir un accès aux données.
34


Puis, j’utilise la méthode setSearchExpr (encadrer en rouge), pour faire un filtre des
données par rapport au Ripository Id (que l’utilisateur avait indiqué lors de sa
connexion) et le nom de la vue en précisant que les données des champs actif.
Et enfin, je charge les données récupérées via les setters de mon modèle.
J’ai procédé de la même manière pour reconstituer les autres onglets de l’ancienne
application.
3.2.4.3 Vue
Pour ce qui concerne les vues, j’ai utilisé la bibliothèque Prime faces.
Figure 21 Nouvelle Page de connexion
Code Prime Faces(voir Annexe 1)
35
Figure 22 Nouvelle Page des Onglets
Code Prime Faces(voir Annexe 2)
36
Figure 23 Nouvelle Page de synthèse des Objets
37
4 Bilan
Quelques problèmes rencontrés
Concernant la partie projet Amadeus, j’ai rencontré des difficultés d’adaptation à l’application
Siebel. Il m’a fallu un mois pour comprendre son fonctionnement. Le principal problème a été
de me retrouver par rapport aux environnements (production, UAT…).N’ayant pas
d’expériences sur cette technologie, je mettais du temps à réaliser certaines tâches. Par
exemple, pour résoudre les defects : il faut avoir une bonne connaissance de Siebel, souvent le
defect a été déjà résolu dans la version antérieure de l’application.
Concernant la partie de l’industrialisation, il était prévu de développer trois applications. En
effet, il était prévu de faire 50% projet Amadeus et 50% sur l’industrialisation. Et en réalité, le
temps consacré au projet Amadeus a été largement supérieur. Donc faute de temps, j’ai du me
résoudre à développer qu’une application. De plus, mon encadrant était sur un autre projet : il
n’avait pas beaucoup de temps à me consacrer. Et il n’avait pas une bonne connaissance des
applications sur lesquelles je devais développer.
Points positifs
Avec l’industrialisation, j’ai pu transformer une application développé en VBA(Excel) en une
application web. Le développement de la Cartographie m’a permis de consolider mes
connaissances acquis en cours de technologie du web. A cette occasion, j’ai pu découvrir
d’autres outils tels que JSF, JavaBean, Prime Faces…
Participer au projet Amadeus a été une expérience enrichissante. J’ai découvert le
déroulement d’un projet informatique. Surtout, j’ai appris à développer avec une nouvelle
technologie : Siebel. Les connaissances acquises en programmation orientée objet et en Base
de Données m’ont beaucoup aidées comprendre l’environnement Siebel.
38
Conclusion
Ce stage de fin d’étude a été pour moi la première expérience professionnelle dans le domaine
de l’informatique.
J’ai découvert le déroulement d’un projet informatique dans une entreprise, ce qui m’a permis
de mettre en œuvre les compétences que j’ai pu acquérir lors de mon cursus universitaire. J’ai
acquis également de nouvelles connaissances dans le domaine CRM et j’ai appris à travailler
en équipe.
Mon bilan personnel est riche comme peut l’attester le travail que j’ai réalisé tout au long de
ces six mois. Tout d’abord techniquement, l’univers Siebel propose une architecture
totalement nouvelle à mes yeux. J’ai pu grâce à ce stage aborder quelques aspects de cet outil
CRM de pointe.
Ensuite le travail en société de services m’a permis d’acquérir une certaine rigueur dans mon
travail. Le cycle de vie d’un projet au CSL passe par plusieurs étapes et chacune d’entre elles
est soumise à un contrôle. L’exigence est donc très haute et la fiabilité des outils doit être sans
failles. Cet aspect m’a par la même occasion permis de mesurer la portée du travail demandé.
Au final, cette expérience m’a été très fructueuse autant d’un point de vue personnel que
professionnel. Elle m’a permis de dissiper mes appréhensions sur le monde du travail.
39
Références




Fonctionnement Siebel : Document Fonctionnels (propriété CGI)
Administration Siebel : Document Techniques (propriété CGI)
The Scrum Alliance: www.scrumalliance.org
Agile project management with Scrum, Ken Schwaber
40
Annexes
1 Formulaire de connexion : Code Prime Faces
Nouvelle Page de connexion
<h:form>
<p:panel header="Connexion" style="width:450px;
height:390px;
position:absolute;
left:50%;
top:50%;
margin-left:-250px;
margin-top:-250px;">
<p:messages />
<p:panelGrid columns="3" >
<h:outputLabel for="username" value="Enter username:"/>
<p:inputText id="username" value="#{userLoggin.username}"
required="true"/>
<h:message for="username" />
<h:outputLabel for="password" value="Enter the password:"/>
<p:password id="password" value="#{userLoggin.password}"
required="true" />
<h:message for="password" />
<h:outputLabel for="repository" value="Enter Id Repository:"/>
<p:inputText id="repository" value="#{userLoggin.repository}"
required="true"/>
<h:message for="repository"/>
<h:outputLabel for="language" value="Language:"/>
<p:inputText id="language" value="#{userLoggin.language}"
required="true"/>
<h:message for="language" />
<h:outputLabel for="objectManager" value="Enter ObjectManager:"/>
<p:inputText id="objectManager" value="#{userLoggin.objectManager}"
required="true"/>
<h:message for="objectManager"/>
<h:outputLabel for="enterpriseName" value="Enter EnterpriseName:"/>
<p:inputText id="enterpriseName"
value="#{userLoggin.enterpriseName}" required="true"/>
41
<h:message for="enterpriseName"/>
<h:outputLabel for="serverPort" value="Enter ServerPort:"/>
<p:inputText id="serverPort" value="#{userLoggin.serverPort}"
required="true"/>
<h:message for="serverPort"/>
<h:outputLabel for="serverHostname" value="Enter ServerHostname:" />
<p:inputText id="serverHostname"
value="#{userLoggin.serverHostname}" required="true"/>
<h:message for="serverHostname"/>
<h:outputLabel for="ApplicationName" value="Application Name:" />
<p:inputText id="ApplicationName" value="#{userLoggin.appliName}"
required="true"/>
<h:message for="ApplicationName"/>
</p:panelGrid>
<h:panelGrid columns="1" width="80%">
<p:commandButton value="Login" action="#{userLoggin.connect()}"
styleClass="loginButton" ajax="false">
<f:setPropertyActionListener
target="#{viewManagedBean.userLoggin}" value="#{userLoggin}"/>
</p:commandButton>
</h:panelGrid>
</p:panel>
</h:form>
42
2 Code Prime Faces : Nouvelle Page des Onglets
<p:tabView orientation="top" dynamic="true">
<p:tab title="Business Object">
<h:panelGrid columns="1" cellpadding="20" width="100%">
<p:dataTable value="#{viewManagedBean.tableResultBO}" var="p">
<p:column headerText="Project">
<h:outputText value="#{p.projectNameBO}"/>
</p:column>
<p:column headerText="Business Object">
<h:outputText value="#{p.boName}" />
</p:column>
<p:column headerText="View Name">
<h:outputText value="#{p.viewName}" />
</p:column>
<p:column headerText="Update">
<h:outputText value="#{p.changedBO}" />
</p:column>
<p:column headerText="Title Base Row">
<h:outputText value="#{p.titleBaseRowBO}" />
</p:column>
<p:column headerText="Title Ref Default">
<h:outputText value="#{p.titleRefDefaultBO}" />
</p:column>
</p:dataTable>
</h:panelGrid>
</p:tab>
<p:tab title="Applet">
<h:panelGrid columns="1" cellpadding="20" width="100%">
<p:dataTable value="#{viewManagedBean.tableResultApp}" var="m">
<p:column headerText="Name View">
<h:outputText value="#{m.viewName}" />
</p:column>
43
<p:column headerText="Name Applet">
<h:outputText value="#{m.appletName}" />
</p:column>
<p:column headerText="mode">
<h:outputText value="#{m.mode}" />
</p:column>
<p:column headerText="BC Name">
<h:outputText value="#{m.bcName}" />
</p:column>
<p:column headerText="Project Name">
<h:outputText value="#{m.projetName}" />
</p:column>
<p:column headerText="Scripted Applet">
<h:outputText value="#{m.scriptedApplet}" />
</p:column>
<p:column headerText="SearchSpect">
<h:outputText value="#{m.searchSpec}" />
</p:column>
<p:column headerText="Class Applet">
<h:outputText value="#{m.classApplet}" />
</p:column>
<p:column headerText="Update">
<h:outputText value="#{m.changedApplet}" />
</p:column>
</p:dataTable>
</h:panelGrid>
</p:tab>
<p:tab title="Business Component">
<h:panelGrid columns="1" cellpadding="20" width="100%">
<p:dataTable value="#{viewManagedBean.tableResultBusC}" var="n">
<p:column headerText="Name BusComp">
<h:outputText value="#{n.bcName}" />
</p:column>
<p:column headerText="Name View">
<h:outputText value="#{n.viewNamebc}" />
44
</p:column>
<p:column headerText="Applet Name">
<h:outputText value="#{n.appletNamebc}" />
</p:column>
<p:column headerText="Project Name">
<h:outputText value="#{n.projectNameBC}" />
</p:column>
<p:column headerText="Table Name">
<h:outputText value="#{n.tableName}" />
</p:column>
<p:column headerText="Sort Spec">
<h:outputText value="#{n.sortSpecBC}" />
</p:column>
<p:column headerText="Search Spech">
<h:outputText value="#{n.searchSpecBC}" />
</p:column>
<p:column headerText="Scripted ">
<h:outputText value="#{n.scriptedBC}" />
</p:column>
<p:column headerText="Update">
<h:outputText value="#{n.changedBC}" />
</p:column>
</p:dataTable>
</h:panelGrid>
</p:tab>
<p:tab title="Table">
<h:panelGrid columns="1" cellpadding="20" width="100%">
<p:dataTable value="#{viewManagedBean.tableResulttable}" var="t">
<p:column headerText="Name Table">
<h:outputText value="#{t.tableName}" />
</p:column>
<p:column headerText="Name View">
<h:outputText value="#{t.viewtable}" />
</p:column>
<p:column headerText="Name Bus Comp">
<h:outputText value="#{t.bctable}" />
</p:column>
45
<p:column headerText="Name Applet">
<h:outputText value="#{t.apptable}" />
</p:column>
<p:column headerText="Alias">
<h:outputText value="#{t.tableAlias}" />
</p:column>
<p:column headerText="Type">
<h:outputText value="#{t.type}" />
</p:column>
</p:dataTable>
</h:panelGrid>
</p:tab>
<p:tab title="Fields">
<h:panelGrid columns="3" cellpadding="20" width="200%">
<p:dataTable value="#{viewManagedBean.tableResultfieldApp}" var="f" >
<!--fields Applet-->
<p:column headerText="Name view " style="width: 220px">
<h:outputText value="#{f.viewfa}" />
</p:column>
<p:column headerText="Name Bus Comp " style="width: 220px">
<h:outputText value="#{f.buscompfa}" />
</p:column>
<p:column headerText="Name Applet " style="width: 220px">
<h:outputText value="#{f.appNamefa}" />
</p:column>
<p:column headerText="Name " style="width: 220px">
<h:outputText value="#{f.name}" />
</p:column>
<p:column headerText="Display Name " style="width: 220px">
<h:outputText value="#{f.displName}" />
</p:column>
<p:column headerText="Update " style="width: 220px">
<h:outputText value="#{f.changedfap}" />
</p:column>
46
<p:column headerText="Pick Applet " style="width: 220px">
<h:outputText value="#{f.pickApplet}" />
</p:column>
<p:column headerText="MVG Applet " style="width: 220px">
<h:outputText value="#{f.mvgApplet}" />
</p:column>
<p:column headerText="Show in List " style="width: 220px">
<h:outputText value="#{f.showinL}" />
</p:column>
<p:column headerText="Runtime" style="width: 220px">
<h:outputText value="#{f.runtime}" />
</p:column>
<p:column headerText="Read Only " style="width: 220px">
<h:outputText value="#{f.readOnly}" />
</p:column>
<!--fields BC-->
<p:column headerText="Field Name " style="width: 220px">
<h:outputText value="#{f.fieldName}" />
</p:column>
<p:column headerText="Calculeted " style="width: 220px">
<h:outputText value="#{f.calc}" />
</p:column>
<p:column headerText="Calculated Value " style="width: 220px">
<h:outputText value="#{f.calcValue}" />
</p:column>
<p:column headerText="update" style="width: 220px">
<h:outputText value="#{f.changedfbc}" />
</p:column>
<p:column headerText="Colunm" style="width: 220px">
<h:outputText value="#{f.column}" />
</p:column>
<p:column headerText="Default Value Post" style="width: 220px">
<h:outputText value="#{f.defaultvaluePost}" />
</p:column>
<p:column headerText="Default ValuePre " style="width: 220px">
<h:outputText value="#{f.defaultvaluePre}" />
</p:column>
47
<p:column headerText="Dest Field" style="width: 220px">
<h:outputText value="#{f.destField}" />
</p:column>
<p:column headerText="Force Active" style="width: 220px">
<h:outputText value="#{f.forceActive}" />
</p:column>
<p:column headerText="Join" style="width: 220px">
<h:outputText value="#{f.join}" />
</p:column>
<p:column headerText="mvl Bus Comp Name " style="width: 220px">
<h:outputText value="#{f.mvlBusCompName}" />
</p:column>
<p:column headerText="mv link " style="width: 220px">
<h:outputText value="#{f.mvlink}" />
</p:column>
<p:column headerText="No Copy " style="width: 220px">
<h:outputText value="#{f.noCopy}" />
</p:column>
<p:column headerText="pickList " style="width: 220px">
<h:outputText value="#{f.pickList}" />
</p:column>
<p:column headerText="Read Only " style="width: 220px">
<h:outputText value="#{f.readOn}" />
</p:column>
<p:column headerText="Required " style="width: 220px">
<h:outputText value="#{f.required}" />
</p:column>
<p:column headerText="Type Field " style="width: 220px">
<h:outputText value="#{f.typefield}" />
</p:column>
</p:dataTable>
</h:panelGrid>
</p:tab>
<p:tab title="Pick List">
<h:panelGrid columns="1" cellpadding="20" width="100%">
<p:dataTable value="#{viewManagedBean.tableResultPickList}" var="pi">
<p:column headerText="Name">
<h:outputText value="#{pi.picklistName}" />
48
</p:column>
<p:column headerText="Pick List Busc Comp">
<h:outputText value="#{pi.pickListBusinessComponent}" />
</p:column>
<p:column headerText="Type Value">
<h:outputText value="#{pi.pickListTypeField}" />
</p:column>
<p:column headerText="Type Value">
<h:outputText value="#{pi.pickListTypeValue}" />
</p:column>
</p:dataTable>
</h:panelGrid>
</p:tab>
<p:tab title="MultiValue Link">
<h:panelGrid columns="1" cellpadding="20" width="100%">
<p:dataTable value="#{viewManagedBean.tableResultMvL}" var="mvl">
<p:column headerText="MVLink Name">
<h:outputText value="#{mvl.multiValueLinkName}" />
</p:column>
<p:column headerText="Parent BC">
<h:outputText value="#{mvl.BCParentName}" />
</p:column>
<p:column headerText="Child BC" style="width: 220px">
<h:outputText value="#{mvl.destinationLink}"/>
</p:column>
<p:column headerText="Link" style="width: 220px">
<h:outputText value="#{mvl.destinationLink}" />
</p:column>
<p:column headerText="Auto Primary">
<h:outputText value="#{mvl.autoPrimary}" />
</p:column>
<p:column headerText="Primary Id Field ">
<h:outputText value="#{mvl.primaryIdField}" />
</p:column>
<p:column headerText="Source Id Field">
<h:outputText value="#{mvl.sourceField}" />
49
</p:column>
<p:column headerText="Type Field">
<h:outputText value="#{mvl.typeField}" />
</p:column>
<p:column headerText="Type Value">
<h:outputText value="#{mvl.typeValue}" />
</p:column>
<p:column headerText="Updated">
<h:outputText value="#{mvl.changedMVL}" />
</p:column>
</p:dataTable>
</h:panelGrid>
</p:tab>
<p:tab title="Link">
<h:panelGrid columns="1" cellpadding="20" width="100%">
<p:dataTable value="#{viewManagedBean.tableResultlink}" var="li">
<p:column headerText="Name" style="width: 230px">
<h:outputText value="#{li.linkName}" />
</p:column>
<p:column headerText="Parent BC" style="width: 120px">
<h:outputText value="#{li.parentBusinessCompanent}"/>
</p:column>
<p:column headerText="Child Bus Comp" style="width: 180px">
<h:outputText value="#{li.childBusinessCompanent}"/>
</p:column>
<p:column headerText="Source Field" style="width: 120px">
<h:outputText value="#{li.sourceField}"/>
</p:column>
<p:column headerText="Dest Field" style="width: 120px">
<h:outputText value="#{li.destinationFieldLK}"/>
</p:column>
<p:column headerText="Inter Table" style="width: 120px">
<h:outputText value="#{li.interTable}"/>
</p:column>
<p:column headerText="Parent column" style="width: 100px">
<h:outputText value="#{li.interParentColumn}"/>
</p:column>
50
<p:column headerText="Child column" style="width: 120px">
<h:outputText value="#{li.childColumn}"/>
</p:column>
<p:column headerText="Search Spec" style="width: 120px">
<h:outputText value="#{li.searchSpecLK}" />
</p:column>
<p:column headerText="No Associate" style="width: 120px">
<h:outputText value="#{li.noAssociate}" />
</p:column>
<p:column headerText="No Delete" style="width: 120px">
<h:outputText value="#{li.noDelete}" />
</p:column>
<p:column headerText="No Insert" style="width: 120px">
<h:outputText value="#{li.noInsert}" />
</p:column>
<p:column headerText="No Update" style="width: 120px">
<h:outputText value="#{li.noUpdate}" />
</p:column>
<p:column headerText="No Inter Delete" style="width: 120px">
<h:outputText value="#{li.noInterDelete}" />
</p:column>
<p:column headerText="Update" style="width: 120px">
<h:outputText value="#{li.changedLK}" />
</p:column>
</p:dataTable>
</h:panelGrid>
</p:tab>
<p:tab title="Screen">
<h:panelGrid columns="1" cellpadding="20" width="100%">
<p:dataTable value="#{viewManagedBean.userLoggin.tableResultscreen}"
var="sc">
<p:column headerText="Name">
<h:outputText value="#{sc.nameScreen}" />
</p:column>
<p:column headerText="Project Name">
<h:outputText value="#{sc.projectname}" />
51
</p:column>
<p:column headerText="Label">
<h:outputText value="#{sc.name}" />
</p:column>
</p:dataTable>
</h:panelGrid>
</p:tab>
<p:tab title="List Object">
<h:panelGrid columns="7" cellpadding="10">
<p:dataTable value="#{viewManagedBean.listpick}" var="lpi">
<p:column headerText="List Pick">
<h:outputText value="#{lpi}" />
</p:column>
</p:dataTable>
<p:dataTable value="#{viewManagedBean.listtable}" var="tl">
<p:column headerText="List Table">
<h:outputText value="#{tl}" />
</p:column>
</p:dataTable>
<p:dataTable value="#{viewManagedBean.listapplet}" var="ll">
<p:column headerText="List applet">
<h:outputText value="#{ll}" />
</p:column>
</p:dataTable>
<p:dataTable value="#{viewManagedBean.listbusob}" var="lbo">
<p:column headerText="List Business Object">
<h:outputText value="#{lbo}" />
</p:column>
</p:dataTable>
<p:dataTable value="#{viewManagedBean.listbusc}" var="lbc">
<p:column headerText="List Business Componant">
<h:outputText value="#{lbc}" />
</p:column>
</p:dataTable>
52
<p:dataTable value="#{viewManagedBean.listlink}" var="lk">
<p:column headerText="List Link">
<h:outputText value="#{lk}" />
</p:column>
</p:dataTable>
<p:dataTable value="#{viewManagedBean.userLoggin.listscren}" var="ls">
<p:column headerText="List Screen">
<h:outputText value="#{ls}" />
</p:column>
</p:dataTable>
</h:panelGrid>
</p:tab>
<p:tab title="Statistic">
<h:panelGrid >
<p:chart type="bar" model="#{viewManagedBean.barModel}"
style="height:500px;width:1000px" />
</h:panelGrid>
</p:tab>
</p:tabView>
</p:layoutUnit>
53