Conception et développement d’un module d’authentification

et de gestion des droits d’utilisation en ligne

pour Télévasc

Soutenu par M. Souhail HAMDI4ème année, option Automatique

et Génie Informatique

Tuteur de stage :M. Serge TAHE

Maître de stage :M. Thibaud LEVRARD

Année universitaire 2010Stage effectué au sein de Télévasc

Laboratoire de Biologie Neuro-vasculaire Intégrée

2

REMERCIEMENTS

Je tiens dans un premier temps à remercier l'ensemble de l'équipe Télévasc, ainsi que toutes les personnes qui m'ont accueillies et qui ont contribué au bon déroulement de ce stage.

Je remercie plus spécialement mon encadrant de stage M. Thibaud LEVRARD qui a su me guider afin d'achever avec succès la mission qui m'a été confiée.

Intégrer Télévasc m'a donné l'occasion de travailler sur des notions qui m'étaient inconnues, de manipuler des outils de développement assez complexes et ainsi d'en maîtriser l'usage grâce au soutien permanent et du suivi efficace de l'équipe.

Je souhaite remercier M. Serge TAHE pour son suivi et surtout pour les cours qu'il a mis à la disponibilité des développeurs afin de faciliter la compréhension des notions complexes du langage Java.

Un grand merci pour mon école l'ISTIA, grâce à qui j'ai l'occasion de réaliser mes projets professionnels.

3

Sommaire 1 Introduction........................................................................................................................5

1.1 Historique et finalités de Télévasc...............................................................................5 1.2 Équipe de Télévasc......................................................................................................6 1.3 Services en ligne.........................................................................................................6 1.4 MedSpectrum : l'outil utilisé pour l'intégration du module d'authentification.............7 1.5 Architecture technique actuelle de Télévasc................................................................7 1.6 Situation du stage au sein de Télévasc.........................................................................8 1.7 Cahier des charges général..........................................................................................9

1.7.1 Quatre étapes principales.....................................................................................9 1.7.2 Documentation et environnements de développement.......................................11

2 Prise en main et amélioration de la couche métier existante.............................................12 2.1 Architecture de la couche métier...............................................................................12 2.2 Modélisation et administration de la base de données PostgreSQL...........................13

2.2.1 Configuration du Système de Gestion de Base de Données Relationnelles........14 2.2.2 Conception des schémas de base de données.....................................................16 2.2.3 Exemple d'une création de table : la table « Compte ».......................................21

2.3 Persistance des données en Java...............................................................................23 2.3.1 Serveur applicatif Glassfish...............................................................................23 2.3.2 Rappel sur les outils de persistance de données.................................................23

2.4 Problèmes rencontrés lors de cette étape...................................................................25 3 Création d'un module d'authentification et de gestion des droits et son intégration dans l'applet MedSpectrum...........................................................................................................26

3.1 Structure générale du module d'authentification........................................................26 3.1.1 Classe UIUserConnection..................................................................................28 3.1.2 Classe UIJoinServicePack..................................................................................29 3.1.3 Classe UIPanelAlerteMessage...........................................................................30

3.2 Communication entre les trois classes via le « Design Pattern Observer »...............31 3.3 Documents réalisés....................................................................................................32

3.3.1 Génération de la Javadoc...................................................................................32 3.3.2 Documentation technique...................................................................................32 3.3.3 Prise en main de la bibliothèque JUnit et réalisation de tests unitaires..............32

3.3.3.1 Scénarios de tests........................................................................................32 3.3.3.2 Intégration des tests dans le projet..............................................................33

4 Conception et réalisation d'une applet de gestion des droits utilisateurs...........................35 4.1 Cahier des charges.....................................................................................................35 4.2 Conception de l'applet...............................................................................................36 4.3 L'administration des utilisateurs................................................................................37 4.4 L'administration des packs de logiciels.....................................................................40 4.5 L'administration des logiciels utilisateurs..................................................................42 4.6 L'administration des droits d'utilisation des fonctionnalités des logiciels..................43

5 Conclusion et perspectives...............................................................................................44

4

1 Introduction

Face au développement rapide du domaine médical et à l'augmentation du volume des données à stocker, les chercheurs ont besoin de nouveaux moyens logiciels afin de réaliser des traitements plus rapides. Ces nouvelles techniques reposent sur l'enregistrement d'informations complexes, notamment dans les domaines de l'imagerie médicale et de la physiologie.

Le projet du stage s'intègre dans le cadre du développement de la plateforme Télévasc et permettra de fournir un moyen de gestion des utilisateurs de ses services. Cet outil dans sa version finale pourra être intégré à l’ensemble des outils développés.

Le présent rapport présentera les services proposés par Télévasc ainsi que l'architecture technique qui permet leur mise en ligne pour les utilisateurs. Ces derniers sont principalement des médecins et des chercheurs.

Les parties qui suivront traiteront de la manière dont le projet intègre la plateforme, ainsi que les améliorations qui seront effectuées de façon à ce que la gestion existantes de l'utilisation de ces services soit affinée.

1.1 Historique et finalités de Télévasc

Le stage s'est déroulé au sein de Télévasc, qui est une structure innovante proposant des services via Internet, pour l'analyse d'images échographiques et de signaux vasculaires. Le service est né de la rencontre entre deux étudiants spécialisés dans le traitement et l'analyse d'images et deux médecins du CHU d'Angers rattachés au sein du laboratoire de recherches « biologie neuro-vasculaire intégrée », soutenu par le CNRS, l'INSERM et le CNES(UMR CNRS 6214 – INSERM 771).

Télévasc est une plateforme innovante du CHU d'Angers qui propose trois types de prestations dans le domaine biomédical pour :

✗ l'analyse via Internet d'images échographiques et de signaux physiologiques✗ l'analyse à façon à la demande du client✗ la gestion des données multicentriques issues de protocoles de recherche

La spécificité et la force de Télévasc reposent sur la mise à jour régulière des algorithmes et des méthodes d’analyse adaptés au domaine vasculaire.

Les plus-values de la mise en ligne des services par rapport à l’utilisation d’un « logiciel standard d’analyse d’images » sont incontestablement l’évolutivité, la standardisation et centralisation des mesures. Le service Télévasc permet d'affranchir des coûts liés à la maintenance des logiciels standards basés chez le client.

5

1.2 Équipe de Télévasc

L'équipe de Télévasc comporte quatre principaux membres :

✗ M. Marc-Antoine Custaud : Co-fondateur de Télévasc est docteur en médecine spécialisé dans la physiologie. Parallèlement à ses activités de recherche il est enseignant à l'université d'Angers. il apporte son expertise lors de la validation cliniques des outils d'analyses.

✗ M. Georges Leftheriotis : Co-fondateur de Télévasc est docteur en médecine spécialisé en angiologie et responsable du service des explorations fonctionnelles vasculaires au CHU d'Angers. Parallèlement à ses activités de recherche, il est enseignant à l'université d'Angers. Son expertise est d'une aide précieuse lors de la validation clinique des outils d'analyses.

✗ M. Victor de Germain : Ingénieur spécialisé dans l'analyse du signal et de l'image et Co-fondateur de Télévasc. Diplômé d'un master 2 en ingénierie en Optoéléctronique signal et imagerie, il a acquis une expertise dans le développement d'outils d'analyse pour l'aide au diagnostic dans le domaine vasculaire. Il est également administrateur du site Télévasc.

✗ M. Thibaud Levrard : Ingénieur développeur diplômé de l'ISTIA en Ingénierie des Systèmes Industriels et des Projets. Il s'occupe du développement des différents projets ainsi que d'autres taches.

1.3 Services en ligne

Les différents outils d'analyses et d'archivage en ligne proposés par Télévasc sont les suivants :

✗ IMT@Télévasc : un outil pour la mesure de l'épaisseur intima média. Elle est un index d'athérosclérose indépendant des facteurs de risque vasculaire « classiques » tels que le tabac, l'hypertension, l'âge, le sexe, le diabète et la dyslipidémie.

✗ MedSpectrum@Télévasc : un outil pour la mesure de la variabilité de la fréquence cardiaque. Elle est calculée en analysant une série chronologique de la fréquence cardiaque. C'est un indicateur de la régulation de la fonction circulatoire.

✗ SBRs@Télévasc : un outil pour l'analyse de la boucle baroréflexe. Elle caractérise de façon intégrative la régulation à court terme de la pression artérielle et de fréquence cardiaque.

✗ Archimed@Télévasc : une application en ligne pour la gestion des données issues d'un protocole de recherche. L'objectif principal est de faciliter le classement et l'organisation des données d'une étude multicentrique.

6

1.4 MedSpectrum : l'outil utilisé pour l'intégration du module d'authentification

MedSpectrum est un outil d'extraction des spectres fréquentiels issus de signaux physiologiques (Électrocardiogramme, pression artérielle...). Il permet d'estimer les fréquences qui composent un signal à partir de méthodologies d'analyse largement utilisées dans le domaine médical.

Figure 1 : Copie écran de MedSpectrum

1.5 Architecture technique actuelle de Télévasc

Les logiciels cités précédemment sont accessibles à partir de l'URL www.televasc.fr. Leur utilisation est possible après que l'utilisateur se soit enregistré. Avec son login et mot de passe, l'utilisateur peut ensuite s'authentifier sur le site de Télévasc, et peut ensuite accéder aux outils d'analyses et d'archivage.

Figure 2 : Architecture actuelle de Télévasc

7

Internet

www.televasc.fr

Serveur du CHU

Les différents outils d'analyse Base de donnéesutilisateurs

Outil d'archivage de données

1.6 Situation du stage au sein de Télévasc

L'accès aux logiciels d'analyses et d'archivage se fait, jusqu'à maintenant, sans contrôle d'accès ni gestion d'utilisation. C'est à dire que tous les utilisateurs sont au même niveau et ont accès libre à toutes les applications. Aucune information n'est récoltée.

L'objectif principal du projet de stage est de permettre une gestion plus fine des utilisateurs ainsi que de l'utilisation de ces outils. Et ceci en enregistrant les informations sur les sessions d'utilisation, et de développer du côté du serveur les différents outils et méthodes d'utilisation définies dans le cahier des charges. Du côté du client, il s'agira de créer l'interface graphique qui permettra l'exploitation des applications, et ceci suivant l'architecture ci-dessous :

Figure 3 : Architecture de l'intégration du projet de stage dans Télévasc

A partir de la « Figure 3 », on voit que le développement débutera par l'étude de la base de données et de la couche métier existante. Une solution qui convient aux nouveaux besoins de la plateforme Télévasc doit être proposée.

La demande d'authentification se fera au moment du chargement de l'applet par le client. Les données de sessions de connexions et d'utilisation des différents outils seront stockées, ce qui permettra par la suite de réaliser des statistiques d'utilisation, par client ou par outil. La gestion des droits d'utilisation se fera par client. A noter qu'il s'agit ici de client Télévasc.

Lors du chargement de l'applet et après authentification, le client concerné n'aura accès qu'aux logiciels ou fonctionnalités dont il a souscrit. Un système de facturation pour l'utilisation de ces outils sera mis en place. Tout cela nécessite une base de données capable de stocker toutes les données décrites précédemment.

8

Internet

Authentification avec login et mot de passe

Serveur du CHU

Les différents outils d'analyse et d'archivage

Base de donnéesutilisateurs

Gestion des accésGestion des accés&&

StatistiquesStatistiques

www.televasc.fr

1.7 Cahier des charges général

Le projet s'intègre dans le cadre du développement de la plateforme Télévasc et permettra de fournir un moyen de gestion des utilisateurs des services en ligne. Cet outil dans sa version finale pourra être intégré à l’ensemble des outils développés.

1.7.1 Quatre étapes principales

Le stage s'est décomposé en quatre principales étapes, à commencer « côté serveur » au « côté client » :

✗ Étape 1 : Prise en main et amélioration de la couche métier existante.Cette étape d’une durée de 20 jours de travail effectif consistera dans un premier temps à installer et configurer le Système de Gestion de Base de Données Relationnelle PostgreSQL. Il s’agira ensuite de redéfinir la base de données et de faire le lien avec l’application MedSpectrum afin de maitriser l’usage de l’application. Le livrable de cette étape est le code de l’EJB local permettant de gérer les différentes tables ainsi que son test unitaire.

✗ Étape 2 : Création d'un module d'authentification et de vérification des droits, puis intégration et validation de l'applet MedSpectrum.Cette étape d’une durée de 20 jours de travail effectif consistera à développer l’interface d’authentification au sein de l’applet MedSpectrum. Cette étape consistera également à intégrer dans l’applet les méthodes de vérification des droits des utilisateurs par rapport au service MedSpectrum. Le livrable de cette étape est l’applet MedSpectrum mis à jour ainsi que les tests unitaires des modification effectuées.

✗ Étape 3 : Conception et réalisation d'une applet de gestion des droits utilisateurs.Cette étape d’une durée 38 jours de travail effectif . Dans les étapes précédentes, les droits des utilisateurs vis-à-vis des services étaient saisis manuellement. Il s’agira ici de concevoir et développer l’applet permettant de réaliser l’interface entre la base de données et les utilisateurs (les membres de l’équipe Télévasc).

✗ Étape 4 : Déploiement distant et validation de l'applet MedSpectrum avec gestion des droits.Cette étape d’une durée de 20 jours de travail effectif consistera à déployer et valider le fonctionnement de MedSpectrum à distance. Cette étape sera validée par l’applet MedSpectrum déployée et fonctionnelle à distance.

9

GANTT Prévisionnel

10

1.7.2 Documentation et environnements de développement

L'étape « documentation » est primordiale dans tout début de stage. Elle permet la familiarisation avec les différents outils de développement et les nouvelles notions de programmation utilisés. L'intérêt réside dans la préparation technique pour le développement, c'est à dire l'assimilation de ce nouveau vocabulaire et de ces nouvelles notions, qui restent assez complexes.

Le développement des applications s'est déroulé sous le système d'exploitation Ubuntu 10.4, et ceci en utilisant le langage Java sous Netbeans 6.5.1. Le choix d'une version antérieure de Netbeans se justifie par deux raisons :

✗ les problèmes et bugs récurrents ont été résolus.✗ le framework « Icefaces » utilisé par @rchimed, qui permet aux développeurs

de réaliser leur applications web, est compatible avec cette version de Netbeans.

Le schéma de la base de données a été réalisé grâce au logiciel Windesign. C'est un logiciel qui se base sur la méthode Merise qui est une méthode d'analyse, de conception et de gestion de projet intégrée. La majeure raison qui justifie ce choix est que ce logiciel permet de concevoir le Modèle Conceptuel de Données (MCD) ainsi que le Modèle Logique de Données (MLD) , qui sont tous deux primordiaux pour assurer la fiabilité et la cohérence du traitement et du développement de l'application.

Ces deux schémas seront intégrés dans le système de gestion de base de données relationnelles Postgresql 8.3, grâce au langage SQL. La raison pour laquelle nous avons choisi Postgresql 8.3 est que c'est un outil pour lequel le retour d'expérience est très satisfaisant. Il permet surtout les manipulations que Télévasc souhaite avoir pour sa base de données.

La partie transactionnelle est gérée grâce au framework Toplink . Ce dernier assure la correspondance entre le monde objet de Java et le monde relationnel de la base de données.

Lors du projet de stage, il était question de comprendre ces outils et de s'en servir afin de réaliser les traitements souhaités. La partie concernant la configuration de l'environnement Java dans lequel sera réalisé le travail, a été effectuée au préalable.

Nous avons vu ici le socle sur lequel repose le travail à effectuer. Ce qui vient par la suite va traiter des configurations et des améliorations qui seront effectuées.

11

2 Prise en main et amélioration de la couche métier existante

Dans cette partie seront exposées les différentes étapes qui ont permis l'amélioration de la couche métier. C'est à dire l'architecture web retenue, la modélisation de la nouvelle base de données et son implémentation dans l'application.

La couche métier correspond à la partie fonctionnelle d'une application, elle décrit les différentes opérations et méthodes qui vont permettre les traitements souhaités. Elle se situe généralement entre la couche d'accès aux données et le client. Dans notre cas, ce que nous définissons par « la couche métier », est le projet dans lequel seront définit les méthodes de connexion, de déconnexion, ainsi que toutes les méthodes d'accès aux données de la base.

2.1 Architecture de la couche métier

La gestion de projet Java commence généralement par la définition d'un modèle en couches sur lequel le traitement sera basé. L'architecture multi-couches retenue est la suivante :

Figure 4 : Le modèle en couches

La réalisation de ce modèle a permis de définir les différentes étapes de développement à suivre. On commence par l'administration de la base de données, puis la génération des entités, et enfin l'intégration et l'amélioration de la couche métier.

L'administration de la base de données consiste en la conception des schémas de la base, c'est à dire le MCD et le MLD. Cependant, il est nécessaire d'installer et de configurer le système qui permet la gestion des bases de données relationnelles. Ce qui est expliqué dans le chapitre qui va suivre.

12

Serveur Télévasc

EJBMétier

EJBCRUD

Base dedonnées

JVM Serveur

Internet

2.2 Modélisation et administration de la base de données PostgreSQL

Une base de données relationnelle est un stock d'informations décomposées et organisées dans des tables reliées entre elles par des associations.

PostgreSQL est le système de gestion de base de données relationnelles « SGBDR » qui en assure l'administration et la gestion. Et hormis le fait que ce soit déjà le SGBDR utilisé par les développeurs de Télévasc, PostgreSQL est un bon choix car c'est un outil libre qui propose des fonctionnalités comparables à celle d'Oracle.

PostgreSQL offre :

✗ la possibilité d'imposer des contraintes à l'insertion des données✗ la garantie de l'intégrité des données stockées✗ la possibilité de créer des vues✗ la possibilité d'hériter des tables et des types de données✗ la programmation côté serveur✗ la possibilité d'effectuer plusieurs transactions en une seule opération✗ la gestion des événements grâce aux triggers

D'autres Systèmes de Gestion de Base de Données Relationnelles proposent des fonctionnalités tout aussi intéressante tel que MySQL. Mais ce qui nous intéresse dans ce projet est la gestion des clés, primaires et étrangères. On s'intéresse aussi à la garantie d'intégrité des données et la possibilité de réaliser plusieurs transactions lourdes en une seule opération.

Les deux systèmes : PostgreSQL et MySQL, possèdent des qualités indéniables en termes de stabilité, de flexibilité et de performances. Une comparaison s'est avéré nécessaire afin de cibler les besoins et confirmer notre choix.

Fonctionnalités SGBDR PostgreSQL MySQL

Performance Plus lent Plus rapide

Réplication de la base de données Oui Oui

Support de clé étrangère Oui Non

ODBC Oui Oui

JDBC Oui Oui

Figure 5 : Tableau comparatif des fonctionnalités dePostgreSQL et de MySQL (source : www.zdnet.fr)

13

Dans la conception de bases de données complexes, PostgreSQL est plus adapté aux besoins de Télévasc. Il est connu pour avoir un comportement stable quelle que soit la plateforme ou l'environnement dans lesquels on l'utilise.

PostgreSQL permet la gestion de grosses bases de données. Et comme décrit précédemment, les retours d'expériences sont satisfaisants.

Figure 6 : Architecture de PostgreSQL

PostgreSQL fonctionne sur le modèle client-serveur. Il permet de gérer plusieurs bases de données et autorise plusieurs connections simultanées. Comme la « Figure 6 » le montre, les clients du serveur PostgreSQL sont divers (PSQL, PgAdmin...).

2.2.1 Configuration du Système de Gestion de Base de Données Relationnelles

La configuration débute par l'installation du serveur PostgreSQL. Dans le gestionnaire de paquets Synaptic sous Ubuntu, on sélectionne les paquets à installer :

Postgresql 8.3Ensuite à partir de l'invite de commande, on se connecte sous l'utilisateur

postgres en tapant la commande :

PostgreSQL est un serveur qui permet de se connecter à différentes bases de données. Par défaut, seul l'utilisateur postgres peut se connecter.

14

souhail@souhail-laptop:~$ sudo -s -u postgrespostgres@souhail-laptop:~$

Autreclient

ClientPSQL

ClientPgAdmin

PostgreSQL(Serveur)

Base deDonnées 1

Base deDonnées 2

Par la suite on crée pour cet utilisateur un répertoire, avec les droits nécessaires, dans lequel seront stockés les différents fichiers de configuration. Et ceci selon les commandes suivantes :

On a donc créé un répertoire portant le nom de « stockage » dans lequel on trouvera les fichiers de configuration, puis plus tard les données.

La dernière étape de configuration est de créer un groupe de base de données. C'est la création du répertoire dans lequel seront stockées les données de la base, et la génération des tables partagées du catalogue. La commande qui permet cela est « initdb ». Elle initialise notamment la locale et le codage de l'ensemble de caractères par défaut du groupe de base de données.

15

postgres@souhail-laptop:~$ mkdir -p /var/lib/postgres/stockagepostgres@souhail-laptop:~$ chown -R postgres:postgres /var/lib/postgrespostgres@souhail-laptop:~$ chmod -R 700 /var/lib/postgres

postgres@souhail-laptop:~$ cd /usr/lib/postgresql/8.3/bin/postgres@souhail-laptop:/usr/lib/postgresql/8.3/bin$ ./initdb -D /var/lib/postgres/stockage/Les fichiers de ce cluster appartiendront à l'utilisateur « postgres ».Le processus serveur doit également lui appartenir.Le cluster sera initialisé avec la locale fr_FR.utf8.L'encodage par défaut des bases de données a été configuré en conséquenceavec UTF8.La configuration de la recherche plein texte a été initialisée à « french ».correction des droits sur le répertoire existant /var/lib/postgres/stockage... okcréation des sous-répertoires... oksélection de la valeur par défaut de max_connections... 100sélection des valeurs par défaut de shared_buffers/max_fsm_pages... 24MB/153600création des fichiers de configuration... okcréation de la base de données template1 dans /var/lib/postgres/stockage/base/1... okinitialisation de pg_authid... okinitialisation des dépendances... okcréation des vues système... okchargement de la description des objets système... okcréation des conversions... okcréation des dictionnaires... okinitialisation des droits sur les objets internes... okcréation du schéma d'informations... oklancement du vacuum sur la base de données template1... okcopie de template1 vers template0... okcopie de template1 vers postgres... okATTENTION : active l'authentification « trust » pour les connexionslocales.Vous pouvez modifier ceci en éditant pg_hba.conf ou en utilisant l'option -Aau prochain lancement d'initdb.Succès. Vous pouvez maintenant lancer le serveur de bases de données par : ./postgres -D /var/lib/postgres/stockageou ./pg_ctl -D /var/lib/postgres/stockage -l journal_applicatif startpostgres@souhail-laptop:/usr/lib/postgresql/8.3/bin$

Une fois ce message de succès généré, on peut à présent lancer le serveur de base de données grâce à la commande fournie :

Il faut aussi veiller à créer un nouvel utilisateur de la base de données, à qui on donne le rôle de super utilisateur :

2.2.2 Conception des schémas de base de données

✗ Rappels sur les modèles de base de données utilisés :

Il existe plusieurs types de schémas de base de données. A travers cette partie du rapport, seront exposées les deux utilisés :

✗ Le Modèle Conceptuel des Données(MCD) a pour but d'écrire de façon formelle les données qui seront utilisées par le système d'information. Il s'agit donc d'une présentation des données, facilement compréhensible et qui permet de décrire le système d'information à l'aide de tables(entités).

✗ Le Modèle Logique des Données(MLD) qui consiste à décrire la structure de données utilisée sans faire référence à un langage de programmation. Il s'agit donc de préciser le type de données utilisées lors des traitements. Ainsi, le modèle logique est dépendant du type de base de données utilisé.

✗ Étude de l'existant : « le schéma initial de gestion de la base de données »

Le schéma de base que Télévasc possédait est le suivant :

Figure 7 : Schéma de base de données existant, réalisé avec SQL Designer

16

postgres@souhail-laptop:~$ ./postgres -D /var/lib/postgres/stockage

postgres@souhail-laptop:~$ createuser utilisateur

Après discussion , on constate que les informations à stocker sont les suivantes :

✗ Informations personnelles sur l'utilisateur✗ Informations sur le compte de cet utilisateur : login, mot de passe, date de

création du compte.✗ Informations sur les sessions de connexion de l'utilisateur✗ Informations sur les services que Télévasc propose✗ Informations sur les droits d'utilisation de service attribués à l'utilisateur✗ Ainsi que les historiques d'utilisation

L'amélioration de la base de données a conduit à une réunion avec les membres concernés de Télévasc afin de valider la nouvelle étude à suivre.

✗ Description de la base de données améliorée : Un utilisateur est décrit par un identifiant, un nom, un prénom, une adresse, une profession et le champ détails pour des informations complémentaires, et enfin une version pour permettre les modifications des données. Cet utilisateur peut posséder un ou plusieurs comptes. Un compte est définie par un identifiant, une date de création, un login et un mot de passe, et pareil que pour l'entité utilisateur, deux champs Détails et version. Un compte ne peut être possédé que par un seul et unique utilisateur. Une entité Session contient les données de connexions, c'est à dire selon un identifiant, on a une date et heure de début et de fin de connexion, une durée d'utilisation et une version.

Un responsable est considéré comme un potentiel utilisateur. Cette entité Responsable est décrite par un identifiant, une fonction au sein du service Télévasc et une version. Ce responsable est capable de définir une entité Service_Pack, composée d'un identifiant, un nom de Service_Pack, une durée de validité, un prix hors taxes et une version. Toute mise à jour effectuée sur la table Service_Pack, par un responsable, est enregistrée dans une entité HistoriqueServicePack qui contient un identifiant, la date et l'heure de la modification et une description. Les tables Compte et Service_Pack sont reliées grâce à une association porteuse « Souscrire » contenant les propriétés suivantes : Début et fin de contrat, prix final et le nombre d'utilisation du Service_Pack. L'association Souscrire sert principalement à l'administrateur afin de faire bénéficier un utilisateur de remise sur ses utilisations des services de Télévasc.

Un Service_Pack propose des logiciels accessibles à l'utilisateur, leur nombre varie de 1 jusqu'à N selon ce que propose le Pack. Ces mêmes logiciels sont composés d'une ou plusieurs fonctionnalités, celles-ci se trouve dans l'entité Fonctionnalités_Logiciels qui est une table statique, et qui contient deux champs : identifiant et Description. Une fonctionnalité_Logiciel concerne un et un seul logiciel.

17

On a aussi définit une entité Fonctionnalités_Attribuées qui est une table dynamique, contenant un identifiant et un type de fonction, qui décrit les fonctionnalités des logiciels qu'un utilisateur a le droit d'utiliser, et ceci en relation avec son compte.

On archive aussi l'historique de connexion (cela permet de faire des statistiques d'utilisation par fonctionnalités et par utilisateur). Cette entité HistoriqueUtilisationFonctionnalités est constituée d'un identifiant, une date et heure de début et de fin d'utilisation d'une fonctionnalité attribuée, ainsi que d'un compteur d'utilisation.

Un responsable peut gérer les droits d'utilisation d'une fonctionnalité attribuée, et ceci grâce au champ AccèsOK, qui autorise ou non un utilisateur à accéder à une fonctionnalité attribuée.

Une fois la description de la base de données discutée et validée par l'équipe de Télévasc, l'étape de l'intégration peut alors commencer.

Figure 7 : Logiciel choisi pour la modélisation et la conceptiondes schémas de base de données

Windesign se base sur la méthode Merise qui est une méthode d'analyse, de conception et de gestion de projet intégrée. Il propose une interface graphique assez riche et surtout facile à manipuler. On commence par réaliser le MCD, et après vérification d'éventuelles incohérence, Windesign génère automatiquement le MLD.

Le passage par cette étape est important, car on définie le traitement que nous allons suivre lors de la programmation. Le schéma de la base de données subi des modifications au fur et à mesure que l'on avance dans le projet, l'idéal est que ces modifications soient minimes pour que cela n'affecte pas beaucoup le programme.

18

Figure 9 : Le Modèle Conceptuel des Données utilisé pour le stockage des données utiles à la couche métier

Figure 10 : Le Modèle Logique des Données utilisé pour le stockage des données utiles à la couche métier

2.2.3 Exemple d'une création de table : la table « Compte »

Cette étape consiste à écrire le script qui va permettre à PostgreSQL de créer la base de données décrite précédemment. Vu que le langage SQL pour PostgreSQL est différent syntaxiquement de celui de la norme. Une première étape a été de se familiariser avec la syntaxe du langage SQL pour PostgreSQL.

Pour administrer une base de données PostgreSQL, il existe plusieurs clients d'administration :

✗ outil en ligne de commandes tel que psql✗ outils graphique tel que : Druid, pgAdmin III , phpPgAdmin

L'outil choisi est pgAdminIII car il propose une interface graphique facile à manipuler. Des fonctionnalités comme la gestion des connexions, une navigation assez agréable, ainsi que différentes propriétés(propriétés de la BDD, des tables, du serveur ...) accessibles graphiquement.

Figure 11 : Copie d'écran de l'interface graphiquede pgAdminIII

21

On peut commencer l'écriture du script de la base de données.

Tout d'abord, on commence par la définition des paramètres de PostgreSQL :

Ensuite, on écrit la requête qui permet de créer chaque table. Ce qui suit concerne uniquement la création de la table Compte.

On crée une séquence afin de définir le pas d'incrémentation de la clé primaire.

On définit ensuite les clés primaire et étrangère.

Ce script est à exécuter pour chacune des 14 tables générées par le MLD présenté préalablement, et ensuite le générer dans pgAdminIII.

22

SET client_encoding = 'UTF8';SET standard_conforming_strings = off;SET check_function_bodies = false;SET client_min_messages = warning;SET escape_string_warning = off;CREATE PROCEDURAL LANGUAGE plpgsql;SET search_path = public, pg_catalog;SET default_tablespace = '';SET default_with_oids = false;

---------------------------------- -------------------------------------------------------------------- Table Compte -------------------------------------------------------------------- ----------------------------------CREATE TABLE compte ( id bigint NOT NULL, // Clé primaire de la table Compte date_creation timestamp without time zone NOT NULL, login VARCHAR DEFAULT NULL, mot_de_passe VARCHAR DEFAULT NULL, details_compte text DEFAULT 'false'::text NOT NULL, version_compte INTEGER DEFAULT NULL, id_utilisateur bigint NOT NULL // fait référence à la clé étrangère);

CREATE SEQUENCE compte_id_seq INCREMENT BY 1 // Pas d'incrémentation NO MAXVALUE NO MINVALUE CACHE 1;ALTER SEQUENCE compte_id_seq OWNED BY compte.id ; // Propriétaire de l'idSELECT pg_catalog.setval('compte_id_seq', 1, true) ; // Définit la valeur de début de id

ALTER TABLE ONLY compte // Contrainte de clé primaire ADD CONSTRAINT compte_pkey PRIMARY KEY (id);ALTER TABLE ONLY compte ADD CONSTRAINT compte_id_utilisateur_fkey // Contrainte de clé étrangèreFOREIGN KEY (id_utilisateur) REFERENCES utilisateur(id);

2.3 Persistance des données en Java

Afin de stocker des données dans PostgreSQL, on utilise le mécanisme de persistance des données (décrit par la spécification JPA). Ce mécanisme propose des fonctionnalités standards en la sauvegarde et la restauration de données. Un des avantages de l'utilisation de JPA est de permettre la factorisation de ligne de code.

2.3.1 Serveur applicatif Glassfish

Cette architecture de composants, présentée dans la « Figure 4 », se situe côté serveur pour la plateforme JEE(Java Entreprise Edition). Le serveur distant/applicatif choisi est Glassfish, qui est un outil libre de Sun.

2.3.2 Rappel sur les outils de persistance de données

✗ Les entitésLa persistance des données est faite à l'aide de composants, nommés entités,

qui sont déployées sur des serveurs applicatifs. On peut voir une entité comme une image d'une table de notre base de données. L'accès aux données passe par les images/entités des tables, et non directement avec la base de données. Le lien entre la base de données relationnelle et ces entités, est assuré grâce au framework Toplink qui s'occupe de gèrer la partie transactionnelle.

Ce qui suit présente un exemple de génération automatique de l'entité qui fait référence à la table Compte.

23

@Entity@Table(name = "compte")@NamedQueries({@NamedQuery(name = "Compte.findAll", query = "SELECT c FROM Compte c"),...})public class Compte implements Serializable { private static final long serialVersionUID = 1L; @Id @Basic(optional = false) @Column(name = "id") @SequenceGenerator(name="compte_id_seq", allocationSize=1) @GeneratedValue(strategy=GenerationType.SEQUENCE, generator="compte_id_seq") private Long id; @Basic(optional = false) @Column(name = "date_creation") @Temporal(TemporalType.TIMESTAMP) private Date dateCreation; @Column(name = "login") private String login; @Column(name = "mot_de_passe") private String motDePasse; @JoinColumn(name = "id_utilisateur", referencedColumnName = "id") @ManyToOne(optional = false) private Utilisateur idUtilisateur; // Constructeurs, Getters & Setters ...

Le logiciel Netbeans permet de générer automatiquement les entités à partir de la base de données créée précédemment (cf chapitre 2.2.2). Cependant, certaines modifications ont été apportées à ces entités, et ceci notamment, au niveau de l'incrémentation automatique de l'identifiant. Autrement dit, puisque PostgreSQL utilise la table de séquence pour automatiser cette incrémentation, on se doit d'ajouter les annotations @SequenceGenerator et @GeneratedValue.

Certaines bases de données telles que MySQL, utilisent l'incrémentation automatique des clés primaires (identifiants de tables).

✗ L es « Entreprise Java Beans » (EJB)

La logique métier et la persistance des données sont effectués grâce à des composants EJB. Les EJB utilisés lors de ce stage sont :

✗ Les « EJB CRUD » : Ces outils permettent de réaliser des opérations sur les tables de la base de données, Create – Read – Update – Delete. Ces EJB ont été défini sans état, c'est à dire qu'ils ne conservent pas les données entre chaque appel du client.

Ce code concerne l'« EJB CRUD » sans état de la table Compte. Il est généré automatiquement et est modifié afin que les erreurs soient gérées par l'exception mise en place, c'est à dire ProtosafeException.

24

@Stateless()public class CompteFacade implements CompteFacadeLocal { @PersistenceContext private EntityManager em;public Compte create(Compte compte) { try { em.persist(compte) ; return compte; } catch (Throwable th) { throw new ProtoSafeException(th, 0); } } public Compte edit(Compte compte) { try { return em.merge(compte); } catch (Throwable th) { throw new ProtoSafeException(th, 1); } } public void remove(Compte compte) { try{ em.remove(em.merge(compte)); } catch (Throwable th) { throw new ProtoSafeException(th, 2); } }

✗ « EJB Métier » : Cet EJB contient les règles métiers de l'application. Il est dit « EJB Métier Stateful », c'est un composant avec état, il est capable de conserver l'état du bean dans des variables d'instance durant toute la durée de la conversation avec un client.

Ce code concerne le bean avec état qui utilise les « EJB CRUD » décrits précédemment, et qui contient toutes les méthodes qui seront visibles depuis Internet.Exemples de méthodes : seConnecter(login,mdp), ajouterCompte(Compte leCompte).

2.4 Problèmes rencontrés lors de cette étape

Cette étape s'est bien déroulée conformément aux attentes de Télévasc. Tant au niveau de la durée et du résultat souhaité. Cependant quelque difficultés ont été rencontrées :

✗ Lors de l'extinction de l'ordinateur, la base de données créée via PostgreSQL ainsi que ses données étaient perdues. Ceci était dû à une mauvaise configuration. Ce problème a été résolu en renouvelant la configuration du fichier postgresql.conf et en démarrant PostgreSQL à l'aide d'un autre service « daemon Linux ».

✗ Les nouvelles notions du langage Java rencontrées lors de cette étape ont été délicates à gérer. Surtout lors du débogage d'erreurs de programmation (EJB ou autres) qu'il a fallu comprendre, interpréter et surtout corriger.

25

@Stateful(mappedName = "service.session.SessionBean")@TransactionAttribute(TransactionAttributeType.REQUIRED)public class SessionBean implements ISessionLocal { /** * Méthodes CRUD pour les entités */ @EJB private CompteFacadeLocal beanCompte = null ;//Constructeur de Beans. . .@Override public Compte seConnecter(String login, String mdp) {// Code de la méthode qui permet à un utilisateur de se connecter//grâce à son login et mot de passe}

3 Création d'un module d'authentification et de gestion des droits et son intégration dans l'applet MedSpectrum

L'étape précédente a permis de définir les différentes méthodes métier d'accès à un service Télévasc, et de pouvoir ainsi préparer le terrain afin de gérer l'utilisation des logiciels mis en ligne. Nous allons ici aborder la conception et le développement de l'interface graphique permettant l'accès ou non à un service Télévasc, avec gestion des droits. Ce module graphique sera par la suite intégré dans les logiciels Télévasc.

3.1 Structure générale du module d'authentification

Le but de cette étape est de faire en sorte que lorsque l'utilisateur charge sur sa machine le logiciel qu'il souhaite utiliser, un module d'authentification sous forme de JDialog s'affiche lui demandant de s'authentifier. Une fois identifié, l'utilisateur pourra utiliser cette application selon les droits qui lui seront attribués par les administrateurs Télévasc.

Après la conception de la base de données, la génération des « EJB CRUD » et le développement de « l'EJB métier », on passe à l'interface graphique qui va interagir entre l'utilisateur et l'applet. Pour cela, nous avons choisi un composant de type JDialog afin d'assurer la gestion des accès à l'applet.

La classe JDialog permet de créer des boîtes de dialogue, qui permettent des interactions entre le langage Java et l'utilisateur de l'application. Les dialogues sont des conteneurs de premier niveau comme JFrame. Une fenêtre dialogue peut être :

✗ modal : lorsqu’il est actif toute interaction avec les autres fenêtres sont bloquées. Les dialogues JOptionPane sont modaux.

✗ non modal : ne bloque pas les interactions avec les autres fenêtres, ainsi pour créer un dialogue non modal, on est obligé de passer par la classe JDialog.

On peut représenter cette architecture dans le modèle en couche suivant :

Figure 12 : Le modèle en couches finale

26

Serveur Télévasc

Internet

EJBMétier

EJBCRUD

Base dedonnées

JVM ServeurJVM Client

Applet

Une fois le composant à utiliser est définit, l'étape de conception de l'interface peut alors commencer.

L'interface va comporter trois classes de type JPanel :

✗ UIUserConnection : avec deux champs de saisie de texte pour le login et mot de passe de l'utilisateur afin de l'identifier. Ainsi que deux boutons « Connection » et « Cancel ».

✗ UIJoinServicePack : avec un composant JComboBox contenant les noms des packs disponibles dans la base de données. Ainsi qu'un composant de type JList dans lequel vont s'afficher les logiciels composants le pack sélectionné.

✗ UIPanelAlerteMessage : avec un composant JLabel dans lequel seront affichés tous les messages d'alerte lors de l'utilisation du module d'authentification.

Voici le résultat final du module d'authentification :

Figure 13 : L'interface graphique réalisée

Les parties qui suivront vont traiter les trois JPanel cités précédemment. Ce traitement sera situé « côté client », néanmoins le code présenté a été réalisé et testé « côté serveur ».

27

3.1.1 Classe UIUserConnection

Ce JPanel contient deux champs pour le login et le mot de passe ainsi que deux boutons :

✗ Un bouton « Connection » appelle la méthode seConnecter(String login, String password) , dont voici un extrait :

28

@Override public Compte seConnecter(String login, String mdp) { // Vérification préalable de la demande de connection if( getCompteSession() != null ) { throw new ProtoSafeException("You are already connected, please disconnect", 0); } //Vérification de la valeur et la longueur du Login et du mdp if( login == null || login.equals("") || login.length() < 5 || mdp == null || mdp.equals("") || mdp.length() < 5){ throw new ProtoSafeException("Format of login / password not correct", 1); } //On définit une variable Compte Compte tempCompte = null; // Verification login et mot de passe dans base de données tempCompte = getBeanCompte().checkCompte(login, mdp); // Si mauvais login if( tempCompte == null ) { //on crée la nouvelle session qui va contenir les infos précédentes sessionC = getBeanSession().create(sessionC); throw new ProtoSafeException("Login / password not correct", 2); } else // Si login et mot de passe ok { if( tempCompte.getId() != null ) { //on instancie le Compte courant avec la valeur du compte qui s'est connecté setCompteSession(tempCompte); //après avoir récupéré les informations on le met à 0 tempCompte = null; //on crée cette nouvelle session sessionC = getBeanSession().create(sessionC); return getCompteSession(); } else // Bon login mauvais mot de passe { //on remplie la table Session avec les informations sur la connexion getBeanSession().create(sessionC); //on crée cette nouvelle session throw new ProtoSafeException("Login / password not correct", 3); } } }

✗ Un bouton « Cancel » qui met tous les champs de la fenêtre à leur état initial, c'est à dire à vide. Il fait surtout appelle à la méthode seDeconnecter() qui déconnecte l'utilisateur et enregistre des informations sur sa session(Heures de début et de fin...) . Voici un extrait de la méthode seDéconnecter() :

3.1.2 Classe UIJoinServicePack

Ce JPanel contient deux composants Java : une JCombobox et une JList, qui vont charger à partir de la base de données, la liste des services auxquels l'utilisateur a souscrit. Il pourra donc utiliser le service qu'il souhaite selon ses droits.Ce JPanel contient trois importantes méthodes :

✗ loadPackList() : charge, dans la liste déroulante, les noms des packs auxquels l'utilisateur a souscrit.

✗ loadSoftware() : récupère de la base de données les logiciels qui composent le pack sélectionné dans la liste déroulante, et affiche le tout dans la JList.

✗ useSelectedPack() : valide l'utilisation du logiciel, et le charge avec les restrictions souhaitées.

29

/** * Création d'une session utilisateur de déconnexion et initialise à null * la variable contenant le compte de la session * @return boolean true si déconnecté */ public boolean seDeconnecter() { if(getCompteSession() == null) { // Vérification de l'identification de l'utilisateur return true; } //on récupère la date de déconnexion sessionC.setDateHeureFin(new Date(System.currentTimeMillis())); // definition de la session du compte //si le Compte est null if(getCompteSession().getId() == null) { //on note la déconnexion du compte sessionC.setConnected(false); //on note le détail sessionC.setDétailsSession("User disconnected !!"); }//si le compte n'est pas null else { //on note le détail sessionC.setDétailsSession("User " + getCompteSession().getIdUtilisateur().getNom()

+ " disconnected"); sessionC.setIdCompte(getCompteSession()); } //Création de la session sessionC = getBeanSession().edit(sessionC); //on fait appel à la méthode reset() qui met à jour la totalité des variables Session reset(); return true; }

3.1.3 Classe UIPanelAlerteMessage

Ce JPanel UIPanelAlerteMessage, contient un JLabel. Le but de ce JPanel est d'afficher tous les messages possibles lors de l'utilisation, afin que l'utilisateur soit alerté et guidé lors de la navigation.

Voici un schéma qui montre la chronologie suivie :

Figure 14 : L'architecture de gestion des messages d'alertes

L'avantage d'avoir un seul JLabel est que l'utilisateur ne sera pas perdu lors de sa navigation. Tous les messages d'alertes possibles y seront affichés.

30

Connexion Déconnexion

3.2 Communication entre les trois classes via le « Design Pattern Observer »

Une fois l'interface graphique réalisée et les principales méthodes d'utilisation codées, on peut passer à la gestion de la communication entre ses différents Jpanel. Pour cela, on utilise le « Design Pattern Observer » : il définit une relation entre objets de type un-à-plusieurs, de façon que, si un objet change d’état, tous ceux qui en dépendent en soient informés et mis à jour automatiquement.Les « Design Pattern » décrivent des solutions standard pour répondre à des problèmes d'architecture et de conception des logiciels.

Figure 15 : Diagramme de classes implémentant le « Design Pattern Observer »

Le module UIUserConnection est observé par UIJoinServicePack afin de charger la liste déroulante avec les informations de l'utilisateur qui se connecte, et UIPanelAlerteMessage qui met à jour un message de succès ou non de l'authentification. Le module UIJoinServicePack est observé par UIPanelAlerteMessage afin d'informer l'utilisateur durant sa connexion.

31

3.3 Documents réalisés

3.3.1 Génération de la Javadoc

Pour chacune des étapes du projet, la documentation du code est nécessaire, de façon à ce que le travail effectué puisse être repris par la suite pour d'éventuelles améliorations ou changements.

Le logiciel NetBeans offre la possibilité de générer automatiquement la Javadoc, et ceci en effectuant un clique droit sur le projet en question puis en sélectionnant « Generate Javadoc ». Cette dernière est enregistrée avec les fichiers du projet et ceci sous forme de fichier .html accessible grâce à un navigateur web.

3.3.2 Documentation technique

Cette une étape primordiale grâce à laquelle le personnel de Télévasc saura comment intégrer le module d'authentification réalisé, dans les différentes applications. La documentation technique assure ainsi la maintenabilité du code développé.

3.3.3 Prise en main de la bibliothèque JUnit et réalisation de tests unitaires

3.3.3.1 Scénarios de tests

Dans un premier temps, on définit des scénarios qu'un utilisateur pourrait rencontrer, puis on vérifie la réaction du logiciel vis à vis de ces situations.

Utilisateurs Descriptions des situations Résultat attendu

Utilisateur 1 Souscription valable au Pack contenant le logiciel MedSpectrum

Chargement du logiciel avec succès

Utilisateur 2 Aucune souscription réalisée Refus du chargement du logiciel

Utilisateur 3 Souscription au Pack contenant le logiciel MedSpectrum, mais la date a expirée

Refus du chargement du logiciel

Utilisateur 4 Souscription à un Pack qui ne contient pas MedSpectrum

Refus du chargement du logiciel

Figure 16 : Tableau récapitulatif des scénarios de tests effectués

32

✗ Situation 1 : L'utilisateur « user 1 » a souscrit à un pack dans lequel se trouve le logiciel qu'il souhaite utiliser et dont la date est toujours valide, situation normale.

Résultat attendu : L'utilisateur accède au logiciel et aux fonctionnalités auxquelles il a un droit d'utilisation.

✗ Situation 2 : L'utilisateur « user 2 » n'a souscrit à aucun pack et ne peut donc utiliser aucun logiciel.

Résultat attendu : L'utilisateur voit s'afficher un message disant qu'il n'a souscrit à aucun pack. Il peut donc accéder au logiciel mais ne peut rien utiliser.

✗ Situation 3 : L'utilisateur « user 3 » a souscrit à un pack sauf que la date d'utilisation a expirée.

Résultat attendu : L'utilisateur voit s'afficher un message disant que le pack a expiré.

✗ Situation 4 : L'utilisateur « user 4 » a souscrit à un pack qui ne contient pas le logiciel qu'il souhaite utiliser.

Résultat attendu : L'utilisateur voit s'afficher un message disant que le pack sélectionné ne contient pas le logiciel auquel il souhaite accéder.

3.3.3.2 Intégration des tests dans le projet

La bibliothèque JUnit permet d'appliquer les tests définis au préalable sur le module d'authentification en question.JUnit est un framework de tests unitaires pour le langage Java. Les tests unitaires permettent de vérifier si le comportement de chaque méthode de chaque classe Java est bien celui désiré. JUnit fournit donc un cadre de développement et d'exécution pour ce type de tests.

33

Voici un extrait du code de la classe JUnit :

Les tests unitaires nous permettent d'attester de la validité du programme réalisé, et d'en détecter les failles puis de les corriger. La rédaction de ces tests n'est pas toujours agréable à faire, néanmoins on assure à l'application plus de stabilité et une meilleure fiabilité. Ces test ont été passés avec succès.

34

/*** Cette classe a pour but de tester les procédures de : Connexion - Déconnexion * Définition de service - Définition de logiciel - Vérification et utilisation de fonctionnalitépublic class JUnitTest { private ISessionLocal session = null; private String msg=""; private Compte conectedCompte = null; private SessionCompte s = new SessionCompte(); public JUnitTest() { } /* * Cette méthode est lancée avant les méthodes précédées par l'annotation @Test */ @Before public void setUp() throws NamingException { InitialContext ctx = null; try { ctx = new InitialContext(); System.out.println("Initialisation du context de l'application ok"); session = (ISessionLocal) ctx.lookup("service.session.SessionBean"); } catch (NamingException ex) { Logger.getLogger(JUnitTest.class.getName()).log(Level.SEVERE, null, ex); } }/*** Méthode qui teste la méthode seConnecter(String login, String mdp) @Test public void seConnecter(){ //Scénario 1 : Login et mot de passe vides try{ conectedCompte = session.seConnecter("", ""); }catch(ProtoSafeException ex){ msg = ex.getMessage(); } assertEquals("Format of login / password not correct",msg); //Scénario 2 : Login ok et mot de passe vide try { conectedCompte = session.seConnecter("demodemo", "fhfh456"); }catch(ProtoSafeException ex) { msg = ex.getMessage(); } assertEquals("Bad login or password", msg); assertNull(conectedCompte); //Scénario 3 : Login et mot de passe ok try { conectedCompte = session.seConnecter("demodemo", "demodemo"); }catch(ProtoSafeException ex) { msg = ex.getMessage(); } assertNotNull(conectedCompte); }

4 Conception et réalisation d'une applet de gestion des droits utilisateurs

Le travail effectué précédemment a contribué à l'assimilation et à la familiarisation avec la conception d'applets sous le langage JAVA. Ce qui a permis une certaine aisance pour l'organisation et la réalisation du travail pour cette étape.

4.1 Cahier des charges

Cette troisième étape du projet de stage consiste à concevoir une applet qui permet la gestion et l'administration des données de la base, ainsi que les droits de chaque utilisateur. L'applet fonctionnera de la manière suivante :

✗ L'administrateur pourra charger à partir d'un fichier « .sql » la liste des utilisateurs de Télévasc. A partir de cette liste, il pourra affecter à l'utilisateur sélectionné le pack de logiciels auquel il a souscrit.

✗ L'administrateur pourra créer un nouveau pack de logiciels avec les contraintes et logiciels souhaités.

✗ L'administrateur pourra créer pour chaque logiciels une fonctionnalité.✗ L'administrateur donnera ou non l'autorisation à l'utilisateur sélectionné

d'utiliser la fonctionnalité logiciel en question.Le tout sera présenter à l'aide d'un JTabbedPane, et ceci selon l'interface graphique suivante :

Figure 17 : Copie écran de l'appet d'administration des droits des utilisateurs

35

4.2 Conception de l'applet

L'organisation du travail pour cette étape a suivi les points suivants :

✗ le développement « côté serveur » des différentes méthodes d'administration✗ la vérification de la maintenabilité de ces méthodes grâce un test JUnit✗ la conception de l'interface graphique qui permettra une fluidité dans

l'administration des droits utilisateurs✗ l'intégration des méthodes d'utilisation et la réalisation de l'applet

Tout cela suivant le diagramme de classe suivant :

Figure 18 : Diagramme de classes pour l'étape d'administration et de gestion des droits

des utilisateurs

36

Applet

Classe ConversionJoomlaJPanel UserAdminJPanel PackAdminJPanel SoftwareAdminJPanel FunctionAccessManagement

ConversionJoomla

- Applet applet- List<Account> AccountsList

+loadJoomlaSqlFile()- addOrUpdateJoomlaAccounts()+ List<Compte> getListAccounts()

UserJPanel

SoftwareJPanel

PackJPanel

FunctionAccessManagementJPanel

SessionBean

Classe ConversionJoomlaJPanel UserAdminJPanel PackAdminJPanel SoftwareAdminJPanel FunctionAccessManagement

UserAdmin SoftwareAdmin PackAdmin FunctionAccessManagement

+ findallUsers()+ addUpdateUser()

+ findallSoftwares()+ addUpdateSoftware()

+ findallPacks()+ addUpdatePack()

+ findallFunctions()+ addUpdateFunction()

Côté serveur

Côté client

4.3 L'administration des utilisateurs

La figure 17 représente ce que l'administrateur voit s'afficher à l'écran au lancement de l'applet. Et comme dit précédemment, il faut charger le fichier « .sql » qui permet de lister tous les utilisateurs de Télévasc.Le fichier .sql a la structure suivante :

Un travail de parcours de fichier s'est avéré nécessaire afin de collecter les données sur les utilisateurs et leurs comptes.On vérifie donc si l'utilisateur existe ou non dans la base de données :

✗ Si l'utilisateur existe déjà dans la base de données, on parcours les champs et on vérifie s'il n'y a pas eu de changements, sinon on effectue la modification

✗ Si l'utilisateur n'existe pas, on crée une nouvelle entrée dans la base de données avec les informations qui apparaissent dans le fichier ci-dessus

A noter qu'avec la structure de la base de données mise en place, les informations du fichier « .sql » doivent être vérifiées dans deux tables, c'est à dire les tables : Utilisateur et Compte.

37

CREATE TABLE IF NOT EXISTS `jos_users` ( `id` int(11) NOT NULL auto_increment, `name` varchar(255) NOT NULL default '', `username` varchar(150) NOT NULL default '', `email` varchar(100) NOT NULL default '', `password` varchar(100) NOT NULL default '', `usertype` varchar(25) NOT NULL default '', `block` tinyint(4) NOT NULL default '0', `sendEmail` tinyint(4) default '0', `gid` tinyint(3) unsigned NOT NULL default '1', `registerDate` datetime NOT NULL default '0000-00-00 00:00:00', `lastvisitDate` datetime NOT NULL default '0000-00-00 00:00:00', `activation` varchar(100) NOT NULL default '', `params` text NOT NULL, PRIMARY KEY (`id`), KEY `usertype` (`usertype`), KEY `idx_name` (`name`), KEY `gid_block` (`gid`,`block`), KEY `username` (`username`), KEY `email` (`email`)) INSERT INTO `jos_users` (`id`, `name`, `username`, `email`, `password`, `usertype`, `block`, `sendEmail`, `gid`, `registerDate`, `lastvisitDate`, `activation`, `params`) VALUES(104, 'Demo', 'Victor', 'Demo@yahoo.fr', 'e896732555d9ed6115f8ffc983916b5:l6ugjzuse598fg1e7w0oiiusbeqpp1g1', 'Registered', 0, 0, 18, '2009-01-01 06:08:04', '2009-01-01 13:52:11', '', '\n'),(124, 'Philippe', 'Custaud', 'tc@gmail.com', '3b8d697e5d1236qsfd7e9eb06b507ecb4:HUGJHCklqkUoU4f5f6dNrOPR7lQ9CzcJ0', 'Registered', 0, 0, 18, '2009-04-23 12:08:42', '2009-12-15 13:52:11', '', '\n'),(171, 'mickaël laval', 'mickael', 'mick@gmail.com', '8f0efa51974720a812sdsq244b133c46:qKe7I8Y45qergh3YMQx77wXZ9GBJndBM', 'Registered', 0, 0, 18, '2010-01-04 11:20:37', '0000-00-00 00:00:00', '', 'language=\ntimezone=1\n\n');

Dans le schéma qui va suivre, seront expliquées les fonctionnalités du JTabbedPane qui permet la gestion des utilisateurs, ainsi que l'affectation des packs de logiciels.

Figure 19 : Copie écran de l'onglet d'administrationdes utilisateurs et de leurs souscriptions

aux différents packs de logiciels

L'élément encadré en jaune est un JFileChooser, ce composant permet de sélectionner un ou plusieurs fichier à partir du système de gestion des fichiers. Il est permet ici de trouver le fichier « .sql » et de l'ouvrir. Après ouverture, les noms des utilisateurs de Télévasc sont affichés dans le composants de type JList encadré en rouge. Le code qui permet ce traitement est le suivant :

38

/* * Méthode permettant de charger la liste des utilisateurs Joomla, * de les ajouter dans la base de données puis de les afficher dans le composant JList public void loadJoomlaSqlFile(){ //Variable de type JFileChooser JFileChooser fileChooser = new JFileChooser(); //Affichage de la fenêtre d'ouverture de fichier fileChooser.showDialog(administrationApplet, "Open file window"); int nb; //variable booléenne pour vérifier si la chaîne voulue est trouvée boolean founded = false; //Variable entière qui sert de compteur int count = 0; try { //On récupère le fichier séléctionné File f = fileChooser.getSelectedFile();

La partie encadrée en bleu représente un composant de type JComboBox dans lequel sont chargés les noms des packs auxquels l'utilisateur sélectionné a souscrit. Tandis que le JComboBox dans la partie encadrée en vert représente la liste des packs existants dans la base de données. L'administrateur peut donc y sélectionner un pack, et en cliquant sur le bouton , ce pack sera souscrit à l'utilisateur sélectionné et affiché dans la liste de ces packs.La partie encadrée en bleu représente un composant de type JList, à partir duquel les utilisateurs sont sélectionnés afin de réaliser les opérations citées précédemment. A noter que le login et la date de création du compte de l'utilisateur sélectionné sont également affichés.

39

try {if(f!=null){ //On enregistre se fichier dans le buffer BufferedReader in = new BufferedReader(new FileReader(f)); String str; //Tant qu'on n'a pas atteint la fin du fichier while ((str = in.readLine()) != null) { //on incrémente la valeur du compteur count = count + 1; //si la chaîne voulue est retrouvée if(founded) { try { // On effectue le traitement des utilisateurs administrationApplet.getListCompteJoomla().add(process(str)); } catch (ParseException ex) { Logger.getLogger(AdministrationApplet.class.getName()).log(Level.SEVERE, null, ex); } } //si la chaîne contient "INSERT INTO" if(str.contains("INSERT INTO")){ //On indique que la ligne a été trouvée founded = true; } } //on ferme le buffer in.close(); //On fait appel à la méthode d'ajout ou de mise à jour //Cette méthode charge les noms des utilisateurs de la base de données dans la liste addOrUpdateJoomlaAccounts(); administrationApplet.getPackJPanel().loadAllDataBasePacks(); administrationApplet.getSoftwareJPanel().loadAllDataBaseSoftwares(); administrationApplet.getFunctionJPanel().loadDataBaseFunctions(); }else{ fileChooser.cancelSelection(); } } catch (IOException e) { fileChooser.cancelSelection(); } } catch (ProtoSafeException ex) { throw new ProtoSafeException("An error occured while opening the \"Open file Window\"", 0); } }

4.4 L'administration des packs de logiciels

L'onglet qui permet l'administration des packs de logiciels fonctionnent suivant le même principe que celui de la gestion des utilisateurs. Ses composants sont remplis après chargement du fichier .sql. Cependant, cet onglet offre la possibilité d'ajouter un nouveau pack dans la base de données.

Figure 20 : Copie écran de l'onglet d'administration des Packs de Logiciels

On remarque la liste des packs existants dans la base de données encadrée en rouge, avec les informations du pack sélectionné. En Jaune se trouve la liste des logiciels à ajouter au pack sélectionné. Finalement en vert, et c'est ce qui fait la différence avec l'onglet d'administration des utilisateurs, un bouton « Add a Pack » affiche une fenêtre de type JDialog dans laquelle on remplis les champs « Nom de pack », « Période de validité » et « Prix du pack ». On enregistre le nouveau pack dans la base de données, sans oublier de rafraichir la liste des packs pour voir le nouveau pack apparaître.

A noter que dans cet onglet, les tables utilisées sont : ServicePack, Proposer et LogicielsUtilisateurs.

40

Voici un extrait du code qui permet l'ajout d'un nouveau pack dans la base de données, à partir des données saisies :

41

private void addNewServicePack(){ try{ String packName = jTextFieldPackName.getText(); String packValidity = jTextFieldPackValidity.getText(); String packPrice = jTextFieldPrice.getText(); pack = new ServicePack(null); pack.setDureeValidite(packValidity); pack.setNomService(packName); pack.setPrixht(packPrice); applet.getSession().addOrUpdateServicePack(pack); applet.getPackJPanel().getModelListPacksName().addElement(pack.getId() + " "

+pack.getNomService()); if(packName.equals("") || packPrice.equals("") || packValidity.equals("")){ JPanel pane = new JPanel(new GridLayout(1,0)); //on crée le JLabel avec le message souhaité JLabel l = new JLabel("An argument is empty!!"); //on ajoute le label dans le panel prédéfinis pane.add(l); //on affiche la fenetre avec le label contenant le message souhaité JoptionPane.showMessageDialog(pane, "<html><font color=black face=\"Purisa\">An argument is empty!!</font></html>"); }else{ JPanel pane = new JPanel(new GridLayout(1,0)); //on crée le JLabel avec le message souhaité JLabel l = new JLabel("Adding the new pack is correctly done"); //on ajoute le label dans le panel prédéfinis pane.add(l); //on affiche la fenetre avec le label contenant le message souhaité JOptionPane.showMessageDialog(pane,

"<html><font color=black face=\"Purisa\">Adding the new pack is correctly done</font></html>"); addingServicePackDialog.dispose(); } }catch(ProtoSafeException e){ throw new ProtoSafeException("Adding the new pack has failed", 0); } }

4.5 L'administration des logiciels utilisateurs

Cet onglet offre la possibilité d'ajouter un nouveau logiciel et une nouvelle fonctionnalité dans la base de données. Il permet aussi d'affecter une fonctionnalité à un logiciel et ceci selon l'interface graphique suivante :

Figure 21 : Copie écran de l'onglet d'administrationdes logiciels et de leurs fonctionnalités

On remarque deux composants de type JList, celui encadré en bleu affiche la liste des logiciels existants dans la base de données avec pour chacun le nombre d'utilisation. On voit aussi un bouton « Add a software » qui permet l'ajout d'un nouveau logiciel dans la base de données. Le composant JList encadré en rouge, affiche les fonctionnalités du logiciel sélectionné à gauche. Il y a aussi la possibilité d'ajouter une nouvelle fonctionnalité logiciel dans la base de données. Toutes les fonctionnalités logiciels existantes dans la base de données seront accessibles à partir du composant JComboBox encadré en jaune. On peut également affecter une fonctionnalité au logiciel sélectionné, en cliquant sur le bouton .

42

4.6 L'administration des droits d'utilisation des fonctionnalités des logiciels

Cet onglet consiste à afficher l'utilisateur sélectionné dans l'onglet « User ». Il affiche aussi le pack sélectionné dans l'onglet « Pack ». De même pour le logiciel sélectionné de l'onglet « Software ». Une fois ces données récupérées, on voit s'afficher dans un tableau la liste des fonctionnalités du logiciel sélectionné. A partir de là on peut autoriser ou non à l'utilisateur sélectionné l'accès à cette fonctionnalité. D'où la gestion des droits d'utilisation.

Figure 22 : Copie écran de l'onglet de gestion des droits d'utilisation de fonctionnalités logiciels

La gestion des accès au différentes fonctionnalités demande l'utilisation de la table « FonctionnalitésAttribuées », plus précisément la propriétés « AccèsOK ». Cette propriété est utilisée dans le module d'authentification, elle permet de gérer l'utilisation des fonctionnalités d'un logiciel selon les ressources de l'utilisateur.

43

5 Conclusion et perspectives

L'amélioration de la couche métier a été achevée avec succès. La solution proposée répond aux besoins de Télévasc. Des tests unitaires ont été réalisés pour vérifier la maintenabilité et la fiabilité du code réalisé. Il serait intéressant dans un futur sujet de stage d'approfondir ces tests.

Le module d'authentification réalisé lors de la seconde étape a également satisfait les besoins de Télévasc. Il a été intégré avec succès à l'application MedSpectrum. La dernière phase du projet de stage est de réaliser le déploiement distant de MedSpectrum équipée du module d'authentification. C'est cette étape qui va permettre de finaliser ma mission au sein de Télévasc. Le déploiement distant arrive en dernier pour des raisons de droits d'accès au serveur du CHU d'Angers.

L'applet qui permet l'administration des droits des utilisateurs a été réalisée et est en cours de finalisation. La suite du travail à réaliser est de définir des scénarios de tests afin de résoudre les bugs qui peuvent survenir.

Concernant l'administration des utilisateurs, il serait intéressant d'étendre la base de données réalisées, et de permettre une gestion des droits selon le statut de chaque utilisateur. Il serait également intéressant de réaliser un formulaire de saisie des données directement par l'utilisateur. Car aujourd'hui, la saisie se fait dans le formulaire PHP du site hébergeant « JOOMLA ». Cette action permettrai de remplir la majorité des propriétés des tables constituant la base de données réalisée, ce que « JOOMLA » ne propose pas.

Ce stage a été une expérience enrichissante car il m'a permis de travailler sur de nouvelles notions du développement Java. C'était aussi un « challenge » qui m'a permis de tester mon adaptabilité et ma familiarisation avec des notions informatique qui m'étaient méconnues. Cette expérience m'a été très formatrice, et m'a permis d'enrichir mon expérience en entreprise.

Les personnes que j'ai rencontrées lors de ce stage m'ont permis de confirmer ma vision sur le travail en équipe, et des connaissances que l'ont peut en tirer. J'ai donc pu mettre en pratique mes compétences informatiques mais aussi relationnelles en répondant à de nombreux problèmes.

Effectuer ce stage au sein de Télévasc m'a permis de côtoyer des personnes issues du domaine de la recherche médicale, ce qui m'a ouvert les yeux sur les moyens déployés pour guérir ou prévenir d'éventuelles maladies.

Le professeur Marc-Antoine Custaud ainsi que son équipe ont été satisfait du travail accomplie. J'ai donc eu une proposition pour effectuer mon stage de cinquième année au sein de leur équipe.

44

Bibliographie

1. TAHE, Serge. Persistance Java 5 par la pratique.

2. E. Roman, S. Ambler, T. Jewel : EJB Fondamental. Eyrolles Editions.

3. Cours d'initiation aux Design Pattern : www.design-patterns.fr

4. LEVRARD Thibaud. Réalisation d’applications pour le conditionnement et l’analyse de données médicales.

45

Gantt réel

46

Annexes 1 : Intégration du module d'authentification

« AuthenticationIHM »

Ce document a pour but d'expliquer comment s'intègre le module d'authentification dans les différents logiciels.

1. Il faut dans un premier temps, copier les packages « efvclientejb3.UiAppletTest.UI » et « efvclientejb3.UiPanels » dans le « Source Package » du logiciel dans lequel on souhaite gérer l'accès.

2. Il faut ensuite copier l'interface « IApplet » dans le même package que la classe « Main » qui lance le logiciel en question (uiHrv dans le cas de MedSpectrum).

3. Il faut implémenter cette interface dans la classe Main.

Maintenant que les packages nécessaires sont présents dans l'applet en question, il faut intégrer le fichier .jar du projet qui contient les différents EJB CRUD ainsi que les EJB avec ou sans état. Dans les propriétés du projet du logiciel en question, il faut ajouter dans l'onglet « Librairies » les fichier suivants :

✗ le projet : protoEjb1911-dist/protosafe-EJB.jar

✗ ../lib/appserv-deployment-client.jar

✗ ../lib/appserv-ext.jar

✗ ../lib/appserv-rt.jar

✗ ../lib/javaee.jar

Une fois la configuration terminée, il faut intégrer certaines lignes de codes pour finaliser cette implémentation.

✗ Dans la classe principale « Main », on ajoute en globale les variables suivantes :

47

//variable qui permet de définir le nom du logiciel en question.private String softwareName = "MedSpectrum" ; //variable qui sera utilisé pour référencer la classe// principale « UISecurityDialog » du module d'authentification.private UISecurityDialog uisec = new UISecurityDialog(new Frame("test"),true, this) ;//variable session qui fait référence à l'interface de l'EJB avec état //SessionBean qui contient toutes les méthodes d'utilisation prédéfinies.private ISessionLocal session = null ;

✗ Dans la méthode init() de la classe principale du logiciel, on définit le contexte de la session comme ceci :

✗ Après le initComponents() :

Après avoir ajouté ces différents codes, on passe à la classe contenant les différentes méthodes gérant les fonctionnalités. Dans le case de MedSpectrum, le prototype qui gère les actions sur les boutons « Run analysis » et « Report » se trouvent dans la classe « PanelSpectrum ».

48

//Avant le security ManagerInitialContext ctx = null; hash = new Hashtable(); this is a reference to the applethash.put(Context.APPLET, this) ;

//Après le security Manager try { ctx = new InitialContext(hash); } catch (NamingException ex) { Logger.getLogger(uiHrv.class.getName()).log(Level.SEVERE, null, ex); } try { setSession((ISessionLocal) ctx.lookup("service.session.SessionBean")); } catch (NamingException ex) { Logger.getLogger(uiHrv.class.getName()).log(Level.SEVERE, null, ex); } System.out.println("Initialisation du context de l'application ok"); //Toolkit permet de récupérer la taille de l'écran de l'utilisateur //et de pouvoir ainsi centrer le JDialog cet écran Toolkit tk = Toolkit.getDefaultToolkit(); Dimension dim = tk.getScreenSize(); //On définit le centre de l'écran uisec.setLocation( (dim.width - 570)/2 , (dim.height - 520)/2 ); uisec.setSize(570, 520); //On donne un titre au JDialog

uisec.setTitle("Authentication window") ;//On la rend visibleuisec.setVisible(true);//On verifie si la session a été bien chargéeif(this.getSession()==null){JLabel l = new JLabel("Loading session has failed, please try again!");uisec.getUIPanelAlerteMessage().setJLabelAlertMessage(l);

}

if(uisec.getUIJoinServicePack().getCompteurUseSelectedPack()==1 && uisec.getUIUserConnection().isConnected()){uisec.setVisible(false) ;//Différents composants…}

1. En global, on déclare une variable de type IApplet afin de pouvoir accéder aux différentes méthodes d'utilisation :

2. On ajoute comme paramètre dans le constructeur de la classe une variable de type « IApplet » et on l'instancie à l'objet en cours comme ceci :

Après cela, on repère « l'ActionListener » qui gère les actions du bouton qui applique la fonctionnalité voulue, et on y ajoute les tests suivants :

Après cela, le module est opérationnel, et l'accès au logiciel dans lequel il a été implémenté, est géré selon les contraintes définies dans le cahier des charges.

49

private IApplet iApplet= null;

public PanelSpectrum(final PanelRawSignals tmpPanelRawsSignals, final IApplet iApplet) { initComponents(); // Initialisation par défaut des composants graphiques this.iApplet = iApplet;

// Définition de l'élement graphique (bouton) permettant de lancer l'analyseactionRun.addActionListener(new ActionListener(){@Overridepublic void actionPerformed(ActionEvent arg0) {try{

//Au clique sur le bouton "Run analysis" //on définit le nom de la fonctionnalité que définit le bouton cliqué//si la fonctionnalité est autorisée en utilisation pour cet utilisateurif(iApplet.getSession().checkAndUseFunction("Run analysis")){//traitement du bouton…

//si la fonctionnalité n'est pas autorisée en utilisation on affiche un message d'erreur }else{ JOptionPane.showMessageDialog(jPanel1, "Access denied to this function!!!"); //throw new RuntimeException("Access denied to this function!!!"); }

} catch(Exception e) { JoptionPane.showMessageDialog(jPanel1,

"An error occur while signal spectrum extraction. \n(" + e + ")"); } } });

Annexes 2 : Diagramme de classe détaillé de la logique

métier d'administration des utilisateurs

50

Session Bean

AuthenticationAdmin

Compte compteUserAdmin useradminServicePackAdmin spAdminSoftwareAdmin softwareAdminFunctionAdmin funcionAdmin

UserAdmin

- List<Compte> allComptes+ addOrUpdateAccount(Compte c, Utilisateur u)- addAccount(Compte c) - updateAccount(Compte c)- findAllAccounts()- findAccount(Compte c)

ServicePackAdmin

- List<ServicePack> allServices+ addOrUpdateServicePack(ServicePack sp)- addServicePack(ServicePack sp)- updateServicePack(ServicePack sp) - findAllServices()- findServiceP(ServicePack sp)

SoftwareAdmin

- List<LogicielsUtilisateurs> allSoftwares+ addOrUpdateSoftware(LogicielsUtilisateurs software)- addSoftware(LogicielsUtilisateurs software)- uddateSoftware(LogicielsUtilisateurs software) - findAllSoftwares()- findSoftware(LogicielsUtilisateurs software)

FunctionAdmin

- List<FonctionnalitésLogiciels> allFunctions+ addOrUpdateFunction(FontionnalitésLogiciels function)- addFunction(FonctionnalitésLogiciels function)- updateFunction(FonctionnalitsLogiciels function) - findAllFunctions()- findFunction(FonctionnalitésLogiciels function)

Annexes 3 : Diagramme de séquence pour le module

d'authentification

51

MedSpectrum

Authentification

Charger la liste desServices Pack Message d'erreur

Sélection Service Pack

Affichage automatiqueDes logiciels

Sélection du logiciel À utiliser

Utiliser fonctionnalité

Message d'erreur

OK Pas OK

OK

Pas OK

OK

Pas OK