développement sur le logiciel naya et...
Post on 12-Sep-2018
216 Views
Preview:
TRANSCRIPT
Master 1 MIAGE
Année universitaire: 2013-2014
Entreprise d'accueil: BMI System
Rapport d’activités
Développement sur le logiciel NAYA et
l'extranet
Tutrice enseignante Tuteur de stage Étudiant
Catherine SEXTON Romain GIRARDOT Xavier TANG
Date et signature:
2 / 47
3 / 47
Table des matières
Remerciements ....................................................................................................................................... 4
Introduction .............................................................................................................................................. 5
1 L'entreprise: BMI System ................................................................................................................. 6
1.1 Présentation............................................................................................................................. 6
1.2 Contexte de l'offre .................................................................................................................... 7
1.3 Les produits ............................................................................................................................. 8
1.4 Organisation de l'entreprise pour le développement ............................................................. 11
2 Les missions du stage .................................................................................................................... 12
2.1 Avant-propos: les technologies utilisées ............................................................................... 12
2.1.1 Les langages informatiques et l'environnement web ........................................................ 12
2.1.2 Les logiciels ....................................................................................................................... 13
2.1.3 La gestion de version ........................................................................................................ 15
2.2 Prendre connaissance avec le contexte de travail ................................................................ 21
2.2.1 Les formations ................................................................................................................... 21
2.2.2 L'extranet ........................................................................................................................... 24
2.3 Demandes d'évolution sur les éditions et les formulaires ..................................................... 26
2.3.1 Préambule ......................................................................................................................... 26
2.3.2 Mon travail sur les éditions ................................................................................................ 27
2.3.3 Mon travail sur les formulaires ........................................................................................... 33
2.4 Création d'un nouveau composant pour l'extranet: Formation des clients ........................... 35
2.4.1 Le fonctionnement du composant ..................................................................................... 35
2.4.2 Son développement ........................................................................................................... 38
2.5 Mise à jour de portail ............................................................................................................. 41
Conclusion ............................................................................................................................................. 44
Bilan personnel ...................................................................................................................................... 45
Glossaire................................................................................................................................................ 46
Bibliographie .......................................................................................................................................... 47
4 / 47
Remerciements
Je tiens à remercier Monsieur Romain GIRARDOT (tuteur de stage) pour m’avoir offert l’opportunité
d’effectuer mon stage au sein de son entreprise.
Je remercie également les "Techos" pour leur aide et les conseils qu'ils m’ont apporté dans les "DE"
et pour leur accompagnement.
Je tiens à remercier tout particulièrement et à témoigner toute ma reconnaissance à l’ensemble du
personnel avec qui j’ai eu la chance de travailler, pour leur accueil sympathique ainsi que leur
coopération professionnelle tout au long de ce stage.
Enfin, je remercie Madame Catherine SEXTON (tutrice enseignante) de m’avoir suivi pour mon stage.
5 / 47
Introduction
Le domaine dans lequel j’ai voulu effectuer mon stage est le développement informatique car, le
développement est un domaine qui me plaît et où je peux mettre en oeuvre mes acquis reçus tout au
long de ma formation universitaire. De plus, j’étais curieux de savoir comment s'organise le travail sur
un projet en entreprise. J’attendais, aussi, que ce stage m’apprenne les méthodes de travail pour la
réalisation professionnelle d’un logiciel notamment pour l’analyse et l’organisation à effectuer pour son
élaboration. Dans mon cas, le stage a commencé le lundi 5 mai 2014 et s'est terminé le vendredi 29
août 2014, soit une durée de 4 mois. Il s’est déroulé chez BMI System, un éditeur de logiciel, à
Montrouge (92) dans l'immeuble Le Miroir où résident plusieurs autres entreprises. Dans ce rapport,
vous trouverez une description de l'entreprise et une présentation de mes activités.
6 / 47
1 L'entreprise: BMI System
1.1 Présentation
BMI System est un éditeur de logiciel français spécialisé dans la qualité et les affaires réglementaires
pour l'industrie de santé (industrie pharmaceutique, industrie du dispositif médical et industrie
cosmétique). L'entreprise travaille à 87,5% pour l'industrie pharmaceutique, à 10% pour l'industrie du
dispositif médical et à 2,5% pour l'industrie du cosmétique. Son chiffre d'affaire est de 1.533.401 € en
2012.
Elle a été créée en 2004. Ses fondateurs sont Laurent Clerc (directeur général, expert en conformité
réglementaire pharmaceutique), Brigitte Dillen (président, CEO) et Francis Geysermans (directeur
général, expert en conduite et coordination de projets développements).
Ses activités s'étendent sur plusieurs pays: France, Belgique, Angleterre, Suisse, Etats-Unis et
Vietnam. Lors de mon stage, l'équipe travaillait principalement pour la France et le Vietnam.
L'entreprise, étant un pionnier dans le domaine des affaires réglementaires pour l'industrie de santé,
elle a des contrats avec de nombreux clients qui sont entre autres: Actelion, Alcon, Alfa Wassermann,
ALK, Amgen, AstraZeneca, BMS, Boehringer Ingelheim, Daiichi Sankyo, Expanscience, Ferring, Flynn
Pharma, Galderma, Ipsen, LFB, Menarini, MSD, Nordic Pharma, Novex Pharma, Novo Nordisk, Pfizer,
Puressentiel, ResMed, Roche, Takeda, Terumo, The Medicines Company, UCB Pharma, Vascutek,
Zambon. Elles sont toutes de l'industrie de santé (pharmaceutique, cosmétique, dispositif médical).
Figure 1 - L'implantation des activités de BMI System (source: http://www.bmi-system.com/fr)
7 / 47
1.2 Contexte de l'offre
L'entreprise propose des logiciels permettant aux industries de santé d'être conforme à la loi en
vigueur. En effet, le secteur de la santé est très règlementé. Ces industries ont un devoir de
transparence. Que ce soit en France ou à l'étranger, elles ont des lois à respecter. Nous avons vu
précédemment que les services de BMI System sont aussi présent à l'international.
L'objectif de ces lois est d'assurer une plus grande transparence dans les relations entre les
professionnels de santé (médecins, ...) et les entreprises du secteur (pharmaceutique, ...) afin de
mettre fin à des pratiques d'incitation à la prescription. Certains laboratoires pharmaceutiques, peu
scrupuleux, ne se gêne pas à offrir de l'argent ou des cadeaux aux médecins, pharmaciens et autres
professionnels de santé pour les encourager à prescrire ou à recommander leurs médicaments.
Les lois que nous pouvons citer sont, par exemple:
- pour la France, la loi "DMOS" (Diverses mesures d’Ordre Social) ou loi "anti-cadeaux" du 27
janvier 1993 qui a reçu un renforcement progressif par les lois du 4 mars 2002, du 26 février 2007 et
décret du 25 mars 2007, et la loi Bertrand du 29 décembre 2011 relative au renforcement de la
sécurité sanitaire du médicament et des produits de santé;
- pour le Royaume-Uni, la UK Bribery Act de 2010;
- pour les Etats-Unis, la Sunshine Act de 1976 et la Foreign Corrupt Practices Act (ou FCPA)
de 1977.
8 / 47
1.3 Les produits
Les logiciels que propose BMI System se nomment NAYA, YALTO et TYMEA. NAYA est destiné à
l'industrie pharmaceutique, YALTO à l'industrie du dispositif médical et TYMEA à l'industrie
cosmétique.
Ce sont des applications web écrit en HTML, CSS, PHP et JavaScript qui sont donc accessible grâce
à des navigateurs internet. Une fois le développement et les tests finis, le client reçoit son produit qui
sera installé sur un serveur web qui lui appartient.
Les trois logiciels sont identiques. Il y a seulement le logo qui change.
Figure 2 - Logo des trois logiciels de BMI System
Présentation du logiciel:
Ci-dessous, il vous est montré la page d'accueil de l'application NAYA d'un client quelconque. Nous
pouvons y voir le logo NAYA, en haut, à droite, qui permet de différencier ce dernier des deux autres
types de logiciel (le logo change suivant le type de logiciel).
Figure 3 - Page d'accueil de NAYA pour Astra Zeneca sous Mozilla Firefox
9 / 47
Le menu à gauche permet d'accéder aux fonctionnalités du
logiciel.
On y distingue trois parties. Il y a:
- NAYA DMOS qui regroupe les fonctions permettant de remplir
des formulaires pour répondre aux exigences des lois sur la
transparence (comme la loi DMOS).
- NAYA Référentiels permet d'ajouter dans la base de données
des personnes ou des instances comme des professionnels de
santé, des associations.
- NAYA Administration permet de personnaliser le logiciel
comme l'interface graphique, le menu, les éditions(1)
, les
privilèges des utilisateurs.
Les rubriques de ces trois parties (par exemple,
"R.sponsorisée/DIU/DES" pour NAYA DMOS) permettent
d'accéder aux composants qu'ils font références.
Figure 4 - Le menu NAYA d'Astra Zeneca
10 / 47
Lorsqu'on clique sur une rubrique de la partie NAYA DMOS, par exemple "R.sponsorisée/DIU/DES"
qui est la rubrique permettant de gérer les réunions sponsorisées, nous arrivons sur une page
contenant un tableau répertoriant tous les réunions sponsorisées ajouter par les utilisateurs.
Figure 5 - Page d'accueil pour les réunions sponsorisées de NAYA DMOS
Voici un exemple de formulaire de NAYA DMOS que l'utilisateur peut remplir (qui est, ici, celui qui
correspond aux réunions sponsorisés):
Figure 6 - Formulaire pour ajouter une réunion sponsorisée
11 / 47
1.4 Organisation de l'entreprise pour le développement
Ci-dessous est présenté l'organigramme des personnels liés au développement.
J'ai principalement travaillé avec les développeurs qui m'ont aidé à réaliser mes missions en me
donnant des conseils et en répondant à mes questions. Plus particulièrement, j'ai travaillé avec
Clément Mas, Cyril KABACHE, Baishan WEN, Yijing LU, François LE PRIOL et Christophe ABRIOUX.
Les chefs de projet ont pour rôle de donner des missions comme des demandes d'évolution(2)
et de
superviser ces missions (par exemple, faire des points sur ce qui a été fait). Des missions m'ont été
données par Nickie CAILLAUD, Julie ONGENAED, Laure PIERARD et Violaine VERHEECKE.
Les gestionnaires d'infrastructure permettent de donner les accès aux portails(3)
et s'occupe de
l'administration réseaux. Pour certaines missions, j'ai demandé à Marc SOBOL ou à Matthieu MINET
(stagiaire en gestion d'infrastructure et recruté à la suite de son stage) de me donner des accès de
portail et de déchattrer(4)
des portails quand j'en avais besoin. "Déchattrer" signifie débloquer un portail
afin de pouvoir y faire des modifications comme des mises à jour.
Figure 7 - Extrait de l'organigramme de l'entreprise montrant la partie fonction métier
12 / 47
2 Les missions du stage
2.1 Avant-propos: les technologies utilisées
2.1.1 Les langages informatiques et l'environnement web
Premièrement, le domaine d'activité de ce stage est le développement informatique.
Les langages informatique qui était nécessaire de connaître sont:
- Java, que je n'ai pas utilisé lors de mes missions;
- PHP, qui permet d'accéder à la base de données MySQL;
- SQL, pour les requêtes à faire sur la base de données MySQL;
- XHTML et JavaScript, qui permettent de mettre en forme les pages web générées;
- XML, qui est utilisé par l'outil Devtool(5)
développé par l'entreprise aidant à créer des
composants(6)
pour les logiciels et l'extranet de l'entreprise.
Les logiciels (NAYA, TYMEA, YALTO) et l'extranet sont des applications web développées avec
Joomla!, un CMS (Content Management System). Ils sont très ressemblants car, ils ont la même
structure. Pour ajouter ou modifier un composant, on y procède donc de la même manière.
Extranet Logiciel NAYA
Figure 8 - Comparaison entre l'extranet et le logiciel NAYA
13 / 47
Un composant est une fonctionnalité du logiciel. Par exemple, dans les figures 5 et 6, est présenté le
composant qui permet de gérer les réunions sponsorisées. Dans le code, il se nomme
"naya_dmos_sponsor_jfmc@ASTRA". Nous pouvons connaître le nom technique d'un composant
depuis le logiciel comme le montre la figure 9, ci-dessous.
2.1.2 Les logiciels
Le développement s'est fait en environnement Windows 7 avec les logiciels Eclipse et WampServer.
WAMPServer permet de simuler de façon locale le comportement de l’application sur Internet grâce à
un serveur Apache et de gérer une base de données MySQL grâce au gestionnaire de base de
données PHPMyAdmin.
Eclipse est un environnement de développement permettant de développer et de compiler les
programmes. Il est possible d'y développer dans des langages différents. En l'occurrence, pour ce
stage, j'ai écrit en XML et PHP avec ce logiciel et la compilation correspond à la génération de
composant.
La figure 10 (ci-dessous) montre comment générer un composant. C'est identique à la compilation
d'un programme Java sous Eclipse. En fait, la génération d'un composant va créer son archive ZIP qui
sert pour l'installation dans un portail. Pour faire cela, il faut absolument que WampServer soit ouvert
car, ceci va importer la base de données MySQL relative au composant.
Figure 9 - Nom technique du composant qui gère les réunions sponsorisées du
logiciel NAYA d'Astra Zeneca
On choisit le composant
qu'on veut générer. Dans
cet exemple, on génère le
composant
BADGER_DEPLOYMENT.
Par la suite, plusieurs
fenêtres vont apparaitre.
Cliquer ici
14 / 47
Cette fenêtre apparaît. Elle demande
de choisir le type de base de
données (MySQL ou Oracle) qu'on
souhaite utiliser pour ce composant.
On choisit MySQL (clic sur OK) car,
c'est le seul qui puisse être utilisé
pour le moment.
Celle-ci permet de créer une
documentation du fichier "BML(7)
"
correspondant à ce composant.
BML est un nom inventé par
l'entreprise pour parler du fichier
XML permettant de définir les
éléments de formulaire d'un
composant.
Celle-ci permet de mettre l'archive
zip du composant dans le serveur
FTP afin que ce dernier soit partager
à tout le monde. Il faut faire cela
seulement si on est sûr d'avoir fini de
coder et de tester.
Fenêtre 1
Fenêtre 2
Fenêtre 3
Fenêtre 4
Celle-ci permet d'ajouter le
composant dans la gestion des
composants dans l'extranet.
15 / 47
Figure 10 - Génération d'un composant Joomla! sous Eclipse
2.1.3 La gestion de version
Le projet de BMI System étant grand (une vingtaine de clients) et où plusieurs développeurs travaillent
dessus, il est nécessaire d'utiliser le gestionnaire de version Subversion (SVN).
SVN est intégré à Eclipse et permet de gérer le projet afin de mettre à jour le code et les versions des
fichiers modifiés. Grâce à SVN, le code est centralisé et est identique pour tous les développeurs. En
résumé, SVN permet de centraliser le projet et d'obtenir une traçabilité concernant les modifications
faites.
Les fichiers du projet sont stockés dans un serveur SVN où tout le monde peut aller les récupérer afin
de mettre à jour les fichiers locaux. L'adresse du serveur SVN est svn://svn.bmi-
system.com/svn_badger.
Les trois fonctionnalités utiles de SVN sur Eclipse:
1°) Voir les informations SVN d'un fichier:
Pour connaître des informations relatives à un fichier comme la date et l'auteur de sa dernière
modification, il faut:
- faire un clic droit sur le fichier qu'on souhaite s'informer afin de faire apparaitre un menu
contextuel, puis cliquer sur "Properties"
Enfin, dans la console d'Eclipse, on voit une liste des
fichiers PHP générés et que l'archive zip a été créée.
16 / 47
- dans "Properties", il faut choisir "SVN Info". Ainsi les informations SVN du fichier s'affichent.
Figure 11 - Etape 1: voir les informations SVN du fichier BADGER_DEPLOYMENT.xml
Figure 12 - Informations SVN du
fichier BADGER_DEPLOYMENT.xml
On voit que l'auteur du dernier
changement est "xtang", que sa date
de modification est "22/07/2014
10:33" et enfin que l'identifiant de la
version du fichier est" 34543".
17 / 47
2°) Mettre à jour le fichier modifié dans le serveur SVN:
Une fois qu'on a fini de modifier le code d'un fichier, on peut l'enregistrer dans le serveur SVN
afin que tous puissent bénéficier du fichier mis à jour. Pour cela, il suffit de faire un "COMMIT" du
fichier.
On procède de cette façon:
- d'abord, on fait un clic droit sur le fichier pour qu'apparaisse le menu contextuel. Dans le
menu contextuel, on clique sur "Commit..." de la rubrique "Team".
Figure 13 - Etape 1: mettre à jour le fichier BADGER_DEPLOYMENT.xml
18 / 47
- ensuite, sur la fenêtre qui apparaît, il faut cliquer sur OK pour confirmer la mise à jour du
fichier dans le serveur SVN. A présent, le fichier est partagé avec les modifications effectuées.
Figure 14 - Etape 2: fenêtre de confirmation pour faire le "COMMIT" de BADGER_DEPLOYMENT.xml
19 / 47
3°) Mettre à jour des fichiers locaux:
Pour être sûr de travailler sur la dernière version du projet, il est conseillé de mettre à jour les
fichiers locaux avant de programmer sur Eclipse.
Pour mettre à jour les fichiers locaux, il faut:
- dans un premier temps, choisir le répertoire ou le fichier qu'on souhaite mettre à jour, faire
un clic droit afin qu'apparaisse le menu contextuel. Sur le menu contextuel, on clique sur "Synchronize
with Repository". Le logiciel recherche alors s'il y a des fichiers à mettre à jour (cela peut prendre du
temps).
Figure 15 - Etape 1: Synchroniser avec le serveur SVN pour le répertoire "model"
Le répertoire "model" contient tous les fichiers relatifs aux composants des logiciels (NAYA, TYMEA,
YALTO) et de l'extranet de BMI System.
20 / 47
- dans un second temps, mettre à jour les fichiers locaux avec ceux du serveur SVN trouvés
lors de la recherche de l'étape précédente. Pour cela, on fait un clic droit sur le répertoire ou le fichier
qu'on souhaite mettre à jour pour qu'apparaisse le menu contextuel. Dans le menu contextuel, on
clique sur "Update" de la rubrique "Team". Les fichiers locaux sont alors mis à jour.
Figure 16 - Etape 2: Mettre à jour le répertoire "model"
21 / 47
2.2 Prendre connaissance avec le contexte de travail
2.2.1 Les formations
Sur l'industrie de santé et la qualité:
L'entreprise BMI System, travaillant sur un sujet assez complexe (les affaires réglementaires pour
l'industrie de santé) et ayant un devoir de proposer des logiciels conformes à des normes en vigueur,
il m'était nécessaire d'avoir une sensibilisation sur ces sujets pour mieux comprendre l'intérêt des
logiciels.
J'ai donc participé, la première semaine, à des cours traitant des lois sur les affaires réglementaires
pour l'industrie de santé et de la qualité. Dans l'entreprise, ces cours sont nommés "formations".
La qualité pour le développement d'un logiciel consiste à suivre une norme et des processus afin
d'avoir une certification donnée par une tierce partie. BMI System est certifié ISO 9001:2008 par le
bureau VERITAS, une société spécialisée dans la normalisation et la certification. Cette certification
permet de démontrer que ses produits sont conformes tantôt aux exigences des clients, tantôt aux
exigences réglementaires et d'accroître la satisfaction de ses clients.
En résumé ce que j'ai compris de ces formations, c'est que l'industrie de la santé est très
règlementée, beaucoup de documents formels doivent être rendus et les procédures de compte à
rendre en vers la loi sont assez fastidieuses à réaliser, d'où l'utilité d'un logiciel pour remédier à cela.
De plus, BMI System se doit de respecter une qualité dans la réalisation de ses logiciels.
Sur les tests de logiciel:
Lors de la première semaine, j'ai rendu visite à une testeuse Julie CASTANT et aux responsables
qualités Ana DIAZ et Loÿs-François MARIE. Ils m'ont appris comment s'effectuait le test d'un
composant du logiciel. Lorsque le test est fini et qu'un bug est trouvé, ils en informent le développeur
ayant travaillé sur ce composant. Les chefs de projet sont souvent en contact avec eux afin de mettre
en commun ce qui est à corriger et de préparer les demandes d'évolution.
Le test d'un composant se présente de la façon suivante: le testeur doit suivre un logigramme(8)
qui
explique les étapes de saisie et les états du logiciel. Si le logiciel ne se comporte pas comme il était
prévu dans le logigramme, c'est qu'il y a un bug.
Ci-dessous est présent un extrait de logigramme du composant naya_dmos_decl_simple (permettant
de saisir des déclarations pour la loi DMOS). Cet extrait de logigramme va nous servir comme
exemple. Après la figure 17, je vais vous présenter les manipulations à faire pour tester l'avancement
d'état pour aller de "Mise au point" à "En attente de validation 1".
22 / 47
Figure 17 - Extrait du logigramme du composant naya_dmos_decl_simple
Dans la page de l'état "Mise au point", il est obligatoire de saisir le nom de la déclaration simplifié. Ici,
"Mise au point" se nomme "Saisie d'un nouveau dossier". Pour faire passer de l'état "Mise au point" à
"En attente de validation 1", il faut cliquer sur le bouton "Enregistrer". Cette transition s'appelle
"Soumettre pour confirmation".
Figure 18 - Page de l'état "Mise au point"
23 / 47
Une fois la première page remplie et avoir cliquer sur "Enregistrer", on arrive sur la page de l'état "En
attente de validation 1" qui, dans cet exemple, se nomme "En attente de validation par le
responsable".
Dans le logigramme, nous pouvons voir que les états et les transitions sont regroupés par le type
d'utilisateur censé l'exécuter. Les types d'utilisateur sont appelés "rôles". Nous pouvons voir qu'il y a
les rôles: Initiateur du projet, Validateur 1 du projet, Validateur 2 du projet, Validateur 3 du projet.
Dans le logiciel de test, il y a une section nommée "Quick Login" et composée de boutons qui permet
de changer le rôle d'utilisateur pour les test.
Figure 19 - Page de l'état "En attente de validation 1"
Figure 20 - Section "Quick Login"
Il se situe en haut, à gauche de
l'interface graphique du logiciel.
24 / 47
2.2.2 L'extranet
L'extranet est accessible par login/mot de passe à l'adresse http://extranet.bmi-system.com. Il y a
d'abord, une accessibilité par .htaccess et une deuxième spécifique au site par base de données. La
première permet d'interdire à quiconque qui n'a pas de login/mot de passe d'accéder au site. La
deuxième permet de donner son identité dans le site et de dire qu'on y est connecté. Il a pour fonction
de gérer le travail à effectuer et les ressources humaines.
Figure 21 - Authentification de premier niveau par .htaccess
Les fonctionnalités que j'utilisais, étaient la gestion des demandes d'évolution, la gestion des portails
et la gestion des lots.
Une demande d'évolution est une tâche donnée par un chef de projet à un développeur, qui permettra
d'apporter une amélioration ou une nouvelle fonctionnalité à un projet. La gestion des demandes
d'évolution permet aux développeurs de voir toutes les demandes d'évolution qui lui sont confiées, et
aussi d'avertir que le travail demandé est terminé.
Figure 22 - Authentification
de deuxième niveau
25 / 47
La gestion des portails permet d'accéder aux portails des clients et de connaître les identifiants pour y
faire des mises à jour de composant.
La gestion des lots sert aux chefs de projet de donner les composants avec la version(9)
attendue pour
une mise à jour de portail.
Figure 24 - La page d'accueil de la gestion des portails
Figure 23 - La page d'accueil de la gestion des demandes d'évolution
Figure 25 - Les composants avec leur version d'un lot
26 / 47
2.3 Demandes d'évolution sur les éditions et les formulaires
2.3.1 Préambule
Le logiciel NAYA est constitué de plusieurs composants. Les composants ont d'abord une page
d'accueil qui présente une liste des dossiers créés. Quand on appuie sur le bouton "Créer", on arrive
sur un formulaire permettant de remplir un dossier. Souvent, un dossier est composé d'éditions.
Figure 26 - Page d'accueil d'un composant
Dans un formulaire, les champs de saisie peuvent être du texte, des dates, des fichiers ou des listes
de valeur. Ils sont accompagnés d'un libellé.
Figure 27 - Un champ de saisie d'un formulaire
Une édition est un document au format RTF, WORD ou PDF qui accompagne un dossier. Cela peut
être une lettre ou une déclaration.
Bouton "Créer"
Libellé Champ texte
Figure 28 - Extrait de déclaration de
congrès d'Astra Zeneca
27 / 47
2.3.2 Mon travail sur les éditions
- Modification d'éléments dans les éditions:
Dans certaines demandes d'évolution, il m'a été demandé de, par exemple, changer le nom du
signataire d'une lettre. Pour cela, il fallait seulement modifier, dans le document, l'élément demandé
puis, faire une mise à jour du composant "Edition" correspondant au client.
L'archive ZIP correspondant au composant est constitué d'un fichier SQL permettant de mettre à jour
la base de données et du répertoire contenant toutes les éditions du client. Cette archive sera mis
dans le serveur pour être partagée et servir à la mise à jour d'un portail ultérieurement. A la fin d'une
modification d'un composant, on crée toujours son archive ZIP avec sa version (ex: 2014_05_20-a).
Figure 29 - Le contenu d'une archive du composant "Edition"
Figure 30 - Extrait du contenu du fichier SQL
- Correction de code PHP:
Dans une édition, des données de la base de données n'étaient pas récupérées. Il fallait alors corriger
le code PHP correspondant à la fonctionnalité de création de l'édition.
Pour cette demande d'évolution, j'ai utilisé mes connaissances en programmation et les cours de
Principes d'utilisation des SGBD (enseignement de premier semestre en Master MIAGE). Cela m'a
permis de comprendre plus en détail la base de données de l'application, d'analyser le problème qui
était que l'algorithme du code n'était pas bien choisi (les données n'étaient pas cherchées dans la
base de données mais dans ce qui avait été conservé dans la saisie du formulaire).
Cela correspondait à la demande d'évolution DE-14/02645, où dans la "déclaration contrat", la
spécialité du professionnel de santé n'était pas reprise dans le tableau "Liste des orateurs".
28 / 47
Figure 31 - La partie de l'édition à corriger
Figure 32 - Partie du code PHP corrigée
Non-corrigée
Corrigée
pour chaque médecin trouvé
On récupère la spécialité du médecin.
La ligne de code provoquant le
problème (en commentaire)
on récupère l'établissement du médecin.
On crée le tableau de l'édition (nom, prénom, spécialité, établissement...).
29 / 47
- Création d'une édition:
Dans la demande d'évolution DE-14/03417, il m'a été demandé de créer une édition pour le
composant naya_dmos_contrat_siege@ASTRA du client Astra Zeneca. Cette édition devait être
accessible à l'état "En attente d'envoie du courrier de MEO", et seulement pour les rôles responsable
DMOS (validateur DMOS) et au déclarant. Son format de sortie est WORD.
Dans l'édition, des valeurs de champs saisis par l'utilisateur dans le formulaire du composant devaient
y être ajoutées. Pour réaliser cela, on utilise une librairie PHP qui se nomme "odtphp". Elle permet de
créer des documents OpenOffice.org avec le langage PHP et d'y faire des manipulations comme
l'ajout dynamique de chaîne de caractères.
Pour ce travail, j'ai donc utilisé mes connaissances en programmation et en langage PHP.
La création d'une édition se déroule de la façon suivante:
1°) On déclenche la création d'une édition.
Figure 33 - Page d'accueil de la gestion des éditions
2°) On confirme cette création en choisissant le composant dans lequel l'édition est liée.
Figure 34 - Confirmation de la création d'édition (état: Choix du composant)
Clic pour déclencher la création
Accéder à la gestion d'éditions
30 / 47
3°) On définit le type de modèle c'est-à-dire sur quel format est le fichier d'édition (soit le format
OpenOffice Writer ODT, soit le format RTF). le format de sortie (DOC, ODT, RTF, PDF), le fichier
modèle et le code PHP qui permettra de créer complètement l'édition. Quand on a fini de définir
l'édition, on enregistre et active l'édition.
Figure 35 - Définition de l'édition (état: Edition en cours de réalisation)
Le composant naya_dmos_contrat_siege@ASTRA correspond à la gestion des contrats sièges. Voici
le résultat d'édition obtenu si le formulaire est rempli de cette façon:
Enregistrer
Clic pour activer
31 / 47
Figure 36 - Formulaire du composant naya_dmos_contrat_siege@ASTRA rempli
Figure 37 - L'édition obtenue par le formulaire de la figure 36
Dans la figure 37, on peut voir qu'il y a des mots entre accolades dans l'édition modèle. Ces mots sont
des variables qui seront remplacées par des valeurs à la génération grâce à la librairie PHP "odtphp".
Ces valeurs sont, en l'occurrence: PRENOM_PS=Jean, NOM_PS=Dupont, IDENTIFIANT=CS-2014-
0109, DATE_DECLARATION=05/08/2014, DATE_DU_JOUR=05/08/2014.
L'édition modèle (avant génération) L'édition résultat (après génération)
Clic pour générer une édition
32 / 47
Voici le code PHP qui permet de remplir l'édition et qui définit les règles d'accès à l'édition:
Figure 38 - Code PHP pour remplir l'édition
Figure 39 - Code PHP qui donne les règles d'accès à l'édition
Affectation des variables par les valeurs du
formulaire grâce à la librairie "odtphp". Les
valeurs sont récupérées dans la base de
données.
Permet au déclarant d'y accéder
Permet au validateur DMOS d'y accéder
Accès à l'état En attente envoi du courrier
MEO
33 / 47
2.3.3 Mon travail sur les formulaires
- Modification du nom du libellé d'un champ:
Dans la demande d'évolution DE-14/02641, je devais renommer le libellé du champs "ORIGINE" pour
qu'il soit renommer "Source" au lieu de "Origine" pour le composant
naya_dmos_evnt_non_declare@ACTELION.
Pour faire ceci, il faut modifier le fichier BML, y rechercher le champ "ORIGINE" puis, modifier le
libellé. Pour rappel, le fichier BML permet de définir les éléments (comme les champs de saisie) du
formulaire d'un composant.
Voici comment se présente le fichier BML et le résultat de la correction:
Figure 40 - Extrait du BML de NAYA_DMOS_EVNT_NON_DECLARE@ACTELION
Figure 41 - Le formulaire corrigé où le libellé 'Origine' est remplacé par 'Source'
34 / 47
- Ajout d'une valeur dans une liste de valeurs:
Dans la demande d'évolution DE-14/02685, il m'était demandé d'ajouter le type "Convention de
formation" dans la liste de valeur du champ "TYPE_CONTRAT" pour le composant
badger_evolution_contrat@BMI.
Pour faire cela, dans le BML, il fallait rechercher le champ "TYPE_CONTRAT", ajouter une variable
dans l'attribut "domain", puis définir la variable pour qu'elle ait la valeur "Convention de formation".
Dans ce cas, c'est ainsi que la variable a été définie:
define("_BADGER_EVOLUTION_CONTRAT_CONTRAT_TYPE_CONTRAT_CONVENTION_FORMATION",
"Convention de formation");
Voici le résultat de la modification:
Figure 42 - Le champ "TYPE_CONTRAT" corrigé
35 / 47
2.4 Création d'un nouveau composant pour l'extranet: Formation des
clients
Etant donné que les logiciels de BMI System sont assez complexes à utiliser, des formations sont
proposées aux clients pour leur apprendre à les utiliser. Il était alors nécessaire de gérer et de
répertorier ces formations.
C'est Nickie CAILLAUD, une chef de projet, qui m' a donné la charge du développement de ce
composant. Ce composant sera alors accessible sur l'extranet (http://extranet.bmi-system.com).
2.4.1 Le fonctionnement du composant
En réalité, ce composant est composé de deux composants: badger_formation_formation et
badger_formation_session. Le composant badger_formation_session est accessible depuis le
composant badger_formation_formation. Une formation a plusieurs sessions.
Voici comment se présente le formulaire de badger_formation_formation:
Figure 43 - Formulaire du composant badger_formation_formation
Composant badger_formation_session
Créer une session
Boutons de transition
36 / 47
Lorsqu'on crée une session, on arrive sur son formulaire de création.
Figure 44 - Formulaire du composant badger_formation_session
Plusieurs transitions existent pour les deux composants. Voici les logigrammes expliquant les
transitions des deux composants.
Figure 45 - Logigramme du composant badger_formation_session
37 / 47
Figure 46 - Logigramme du composant badger_formation_formation
38 / 47
Les transitions permettent de donner l'état du dossier en cours et d'apporter des fonctionnalités en
plus suivant chaque transition. Par exemple, des champs de saisie peuvent être débloqués d'une
transition à l'autre, ou des courriers électroniques (notifications(10)
) peuvent être envoyés à des
personnes afin de notifier l'état du dossier.
Figure 47 - Boutons de transition et champ "Sessions" bloqué à l'état "Saisie d'une formation"
Comme dit précédemment, un composant contient comme fonctionnalités un formulaire et en page
d'accueil, un tableau présentant les dossiers créés.
Les colonnes du tableau de la page d'accueil du composant badger_formation_formation sont
l'identifiant de la formation créée, son intitulé, le client suivant cette formation, la date de début de la
première session de cette formation, le temps restant avant que la première session commence et
l'état (ou statut) du dossier. Il est possible d'y faire des recherches. Dans ce logiciel, les recherches
sont appelées "filtres".
Figure 48 - Filtres et tableau de la page d'accueil du composant badger_formation_formation
2.4.2 Son développement
Pour créer l'interface d'un composant (champs de saisie, transitions, colonnes du tableau d'accueil,
les rôles d'utilisateur), il faut utiliser Devtool, un logiciel créé par l'entreprise. Devtool crée le fichier
BML. Un fichier BML est écrit en XML et définit les éléments d'un composant. Il permet de créer le
squelette du composant. Ce fichier BML sera utilisé par le générateur (compilateur sous Eclipse) pour
créer les fichiers PHP et HTML du composant. Il est accessible via l'adresse: http://localhost/devtool.
Par exemple, pour ajouter un champ de type texte, on procède de cette façon:
39 / 47
1°) On va dans la section "Champs", puis on clique sur le bouton "Ajouter un champ".
Figure 49 - Section "Champ" de Devtool
2°) Une fenêtre apparaît pour saisir les caractéristiques du champ, puis on enregistre. Le champ est
créé.
Figure 50 - Fenêtre d'ajout de champ sur Devtool
Pour ajouter des fonctionnalités propres au composant comme l'importation de données depuis un
fichiers Excel, il faut écrire du code PHP directement sur le fichier BML ou dans un fichier PHP à part
qui sera appelé par le BML (par un "include").
Par exemple, pour les identifiants des formations, il fallait leur appliquer un format bien défini, qui peut
se présenter comme cela: FC-2014-0001.
Il était alors nécessaire d'ajouter du code PHP pour qu'il y ait cette fonctionnalité (car, accès à la base
de données, ajout de date dynamique).
En-tête Année actuelle
Compteur de formations créées
40 / 47
Dans le BML, le code PHP doit être ajouter dans des balises spécifiques (custom-code et code). La
figure 51 présente le code qui permet de créer un identifiant de formation.
Figure 51 - Code PHP pour l'identifiant des formations
Lors du développement d'un composant, il est nécessaire de lui donner une version après chaque
modification. La version indique la version précédente et la version actuelle du composant. Par
exemple, le nom d'un archive ZIP d'un composant peut être:
badger_formation_formation_mysql 2014.07.24-a to 2014.08.04-a.zip
Dans le BML, la définition de version se fait dans le tag upgrade. Ce tag décrit en plus les
modifications effectuées.
Nom du
composant
Type de base de
données
version précédente version actuelle
<upgrade previous-version="2014.07.24-a" target-version="2014.08.04-a" active="TRUE" generator-version="1021" author="xtang" mode="complete" name="U2014_08_04__a"> <description name="DESCRIPTION_7172393"> <text lang="french" name="TEXT_6540954"> <![CDATA[ Ajout de l'action "Générer des éditions" ]]> </text> </description> </upgrade>
Figure 52 - Un tag upgrade dans le BML
On sélectionne, dans la base de
données, toutes les formations
créées cette année.
S'il n'y a pas de formation créée
cette année, le compteur de
formation créée est à 0001 (ce qui
veut dire que c'est le premier de
l'année).
Sinon, on incrémente le compteur.
L'identifiant de formation finalement
créée.
41 / 47
2.5 Mise à jour de portail
Une tâche, qu'on me donnait souvent à faire, était la mise à jour de portail. Ces mises à jour sont
faites, lorsque le client le demande. Il y a aussi un portail de "démo" que j'ai dû mettre à jour. Il permet
de faire des démonstrations pour des clients afin qu'ils prennent de nouveaux modules et de présenter
le logiciel NAYA à de nouveaux clients.
Les étapes de mise à jour sont les suivantes:
1°) Le chef de projet indique les composants à mettre à jour avec la version demandée à laquelle ils
doivent atteindre. Souvent, les mises à jour sont présentées dans le composant de gestion des lots de
l'extranet.
Figure 53 - Composants à mettre à jour présentés dans gestion des lots
2°) Ensuite, on accède à la partie administrator Joomla du portail pour accéder à la liste de tous les
composants qui y sont installés, afin de voir la version des composants.
Figure 54 - Liste des composants installés visible sur administrator Joomla
3°) On récupère tous les archives ZIP des composants allant de la version actuelle jusqu'à celle
demandée, avec le logiciel Filezilla ou depuis le composant "Gestion des composants".
Version du composant Tous les composants installés
42 / 47
Figure 55 - Récupération des archives ZIP sous Filezilla
Figure 56 - Récupération des archives ZIP depuis Gestion des composants de l'extranet
4°) Une fois les archives ZIP récupérées, dans administrator Joomla, on met à jour un composant.
On sélectionne le composant à mettre à jour, puis on clique sur le bouton "upgrade".
Les archives ZIP d'un composant
Cliquer pour accéder à la page de
mise à jour
Fenêtre de choix de fichier pour mettre à jour
La page de mise à jour
Sur la page de mise à jour, on clique
sur "Parcourir" pour choisir l'archive
ZIP.
43 / 47
Figure 57 - Manipulation de mise à jour d'un composant
Il faut réitérer cette manipulation jusqu'à la version demandée ce qui est long et fastidieux à réaliser.
En effet, dans la figure 58, on peut voir qu'il y a beaucoup d'archives ZIP à mettre à jour pour le
composant naya_dmos_prise_en_charge.
Une fois l'archive ZIP choisie, on
clique sur le bouton "Upload File &
Install" et on accède à une page
indiquant que la mise à jour a
fonctionné ou non.
Figure 58 - Les archives ZIP à mettre à jour pour le composant
naya_dmos_prise_en_charge (portail du client Novo)
44 / 47
Conclusion
Ce stage m'a fait comprendre que l'informatique peut être utilisé pour des domaines très variés. En
effet, BMI System donne ses services d'éditeur logiciel pour l'industrie de santé. Les affaires
règlementaires sont très importantes pour cette industrie, ce qui est une bonne spécialité vers laquelle
un éditeur logiciel peut se tourner. Concernant les missions du stage, les difficultés que j'ai été
confrontées sont de comprendre le code du projet NAYA, de connaître les méthodes de
développement pour certaines fonctionnalités (comme la création d'édition) et de comprendre
certaines demandes d'évolution. Ces difficultés ont pu être résolues grâce à l'aide des développeurs
qui étaient très disponibles pour toutes questions et aussi à celle des chefs de projet. J'ai pu connaître
l'organisation pour le développement d'un logiciel en entreprise: les chefs de projet donne les
missions aux développeurs et les supervise, des tests se font par les chefs de projet quand le
développement est fini. Aussi, j'ai pu connaître le process de développement de l'entreprise. En
résumé, un composant passe par trois stades qui sont le développement, la recette et la production.
Un portail est dédié pour chaque stade. Une fois les tests finis en développement, le composant est
installé en recette, ainsi de suite jusqu'en production. La production est le produit final qui est présenté
au client.
45 / 47
Bilan personnel
Ce stage est en adéquation avec mon projet professionnel car, l'activité du stage est le
développement informatique et c'est un domaine vers lequel je voudrais exercer mon futur métier. J'ai
pu me rendre compte que mes connaissances en informatique et donc mes études universitaires
(DUT Informatique et Master MIAGE) ont été très utiles.
Grâce à ce stage, j'ai découvert un nouvel environnement d'entreprise par rapport à mon premier
stage de DUT Informatique. L'entreprise BMI System est plus grande que celle du premier stage qui
ne comptait que six employés. J'ai vu une méthode et une organisation de travail que je ne
connaissais pas, ce qui est enrichissant. Ce stage a été une bonne expérience en entreprise.
46 / 47
Glossaire
(1) Édition: c'est un document (PDF, WORD, RTF) généré par certains composants qui sont, en
général, liés à la partie NAYA DMOS (pour les affaires règlementaires). Par exemple, cela peut être
des déclarations.
(2) Demande d'évolution: c'est une amélioration qu'il faut réaliser sur un portail ou un composant. Ce
sont les chefs de projet qui en donne aux développeurs.
(3) Portail: c'est un site internet d'une application NAYA. Il y a trois type de portail: développement,
recette et production. C'est dans les portails de développement qu'on installe et teste lors du
développement. La production c'est le produit final du logiciel.
(4) Déchattrer: donner le droit d'installer et de mettre à jour des composants dans un portail. Ce sont
les gestionnaires d'infrastructure qui ont la charge de déchattrer les portails.
(5) Devtool: c'est une application créée par l'entreprise qui aide à créer un composant en générant le
BML. C'est un moyen de créer un fichier BML grâce à une interface graphique.
(6) Composant: c'est une nouvelle fonctionnalité qui peut être installée à un portail.
(7) BML: c'est un fichier écrit en XML, qui permet de générer un composant. Il y décrit les éléments du
composant comme les champs, les rôles d'utilisateur. Le générateur se sert de ce fichier pour générer
les fichiers PHP permettant le fonctionnement du composant.
(8) Logigramme: C'est un schéma qui présente le fonctionnement d'un composant, avec ses transitions
et ses états.
(9) Version: le versionnage des composants est très important car, un composant évolue tout le temps.
Lors de l'installation d'un composant, il faut faire attention de la correspondance de la version actuelle
avec celle qu'on veut installer. Il ne faut pas confondre les versions de composant avec celles de
SVN.
(10) Notification: c'est un courrier électronique envoyé à une personne lors du changement d'état de
dossier d'un composant. Par exemple, dans l'extranet, il y a un composant de gestion des demandes
d'évolution, quand une demande d'évolution passe à l'état 'Test (interne)', un e-mail est envoyé au
chef de projet qui a donné cette demande d'évolution au développeur, pour l'avertir de la fin du
développement.
47 / 47
Bibliographie
http://www.bmi-system.com/fr: le site de l'entreprise BMI System
http://www.php.net/manual/fr/index.php: ce site m’a été utile pour consulter comment utiliser des
fonctions du langage PHP.
http://docs.joomla.org: la documentation pour le développement sous Joomla!, utile pour la
manipulation de base de données
top related