Projet CRM avec SIEBEL - Université de Montpellier
Transcription
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