View
526
Download
55
Category
Preview:
Citation preview
Ministère de l’Enseignement Supérieur
et de la Recherche Scientifique
Université de Carthage
Institut National des Sciences Appliquées et de Technologie
Projet de Fin d’Etudes
Pour l’obtention du
Diplôme National de Licence Appliquée
Filière : Informatique et logiciels
Sujet :
Développement d’un Connecteur Alfresco
Réalisé par : BEN HAMOUDA Fares
Entreprise d’accueil :
MB2I Tunisie
Soutenu le
Responsable à l’entreprise:
Prénom et NOM : M.ABIDI Fethi
(Cachet & Signature obligatoires)
Responsable à l’INSAT:
Prénom et NOM : M.KHALGUI Mohamed
(Signature obligatoires)
Année Universitaire : 2012/2013
Dédicaces
En cette fin d’année je dédie ce projet
A toute personne m’ayant accompagné
Par une parole, un geste ou même une pensée,
A tous ceux ayant contribué
De prêt ou de loin à cette finalité ;
Merci pour tout
Ceci étant pour le général, vient maintenant le particulier
Avec une distinction bien méritée
Pour mes parents préférés
Sans qui, je n’y serai jamais arrivé.
MERCI
Remerciements
Avant d’entamer ce rapport de projet de fin d’études, nous tenons à exprimer
notre sincère gratitude envers tous ceux qui m’ont aidé ou ont participé au
bon déroulement de ce projet.
Tout d’abord, Nous voudrions remercier notre encadrant au MB2I, M. ABIDI
Fethi, pour son soutien et ses recommandations judicieuses. Aussi,
remercions-nous tout personnel de MB2I ayant contribué de près ou de loin
dans le bon déroulement du projet;
Nous devons chaque bribe de notre connaissance à nos enseignants à
l’INSAT qui ont si bien mené leur noble quête d’enseigner les bases de
l’informatique. Nous les remercions non seulement pour le savoir qu’ils nous
ont transmis, mais aussi pour la fierté et l’ambition que leurs personnes nous
aspirent.
Nous sommes reconnaissants également à M. KHALGUI Mohamed, notre
encadreur durant le déroulement du projet pour son suivi, sa disponibilité,
son aide précieuse et ses conseils qui m’ont été d’une utilité indéniable ;
Non loin de tout projet ambitieux, il existe des gens qui partagent sans jamais
se lasser ses meilleurs et ses pires moments. Ce sont des personnes qui nous
ont soutenus dans chacun de nos instants de faiblesse, et qui, sans leurs
extrême attention et gentillesse, nous ne serions pas ce que nous sommes
devenus aujourd’hui. En tête de liste de ces gens nous placerons nos familles
bien aimées qui n’ont jamais hésité à nous offrir le meilleur qu’elles
pouvaient. Viennent alors tous nos camarades de promotion ainsi que tous
nos amis qui nous ont aidés de façon directe ou tout simplement par leur
présence et leur soutien moral.
Table des matières Dédicaces ................................................................................................................................................. 1
Remerciements ........................................................................................................................................... 2
Listes des figures : ............................................................................................................................. 5
Introduction générale ...................................................................................................... 1
Cadre général : ................................................................................................................ 3
Cadre du projet : ............................................................................................................................... 3
Entreprise d’accueil : ........................................................................................................................ 3
Services Offertes :............................................................................................................................ 4
Chapitre 1: Etude de l’existant ................................................................................... 7
1.1 Introduction : ............................................................................................................................... 7
1.2 Les systèmes GED : ..................................................................................................................... 7
1.2.1 Définition: .............................................................................................................................. 7
1.2.2 Avantages : ............................................................................................................................. 8
1.2.3 Etapes de la GED : ................................................................................................................. 8
1.3 Présentation de la problématique : ............................................................................................ 9
1.4 Présentation d’Alfresco : ............................................................................................................ 9
1.4.1 Définition : ............................................................................................................................. 9
1.4.2 Historique : ............................................................................................................................. 9
1.4.3 Les versions d’Alfresco : ........................................................................................................ 9
1.4.4 Avantages Alfresco : ............................................................................................................ 10
1.5 Installation et Utilisation: ......................................................................................................... 12
1.5.1 Introduction : ........................................................................................................................ 12
1.5.2 Installation : .......................................................................................................................... 13
1.5.3 Manuel d’utilisation : ........................................................................................................... 15
1.5.3 Administration : .................................................................................................................... 19
1.6 Personnalisation Alfresco : ....................................................................................................... 20
1.6.1 Méthodologie et technologie adoptées : ............................................................................... 20
1.6.2 Architecture Alfresco: .......................................................................................................... 21
1.7 Solution adoptée : ...................................................................................................................... 24
Conclusion: ...................................................................................................................................... 24
Chapitre 2 : Analyse et Spécifications des Besoins ......................................................... 26
2.1 Introduction : ............................................................................................................................. 26
2.2 Objectifs : ................................................................................................................................... 26
2.3 Spécifications fonctionnelles: .................................................................................................... 26
2.3.1 Contexte : ............................................................................................................................. 26
2.3.2 Besoins fonctionnels : ......................................................................................................... 27
2.4 Spécifications non fonctionnelles: ............................................................................................ 27
2.5 Modélisation du Contenu : ....................................................................................................... 28
2.5.1 Moyens de classification : .................................................................................................... 28
2.5.1 Modèle de données personnalisé : ...................................................................................... 28
2.6 Le diagramme de packages des cas d’utilisation : .................................................................. 30
2.7 Le diagramme des cas d’utilisation : ....................................................................................... 31
2.7.1 : Paquetage Gestion des règles de Classement : ................................................................... 31
2.7.2 : Paquetage Gestion des index: ............................................................................................. 32
2.7.3 : Paquetage Gestion de compte : .......................................................................................... 32
2.7.4 : Paquetage Administration des serveurs : ............................................................................ 33
2.7.5 : Paquetage Classification des documents : .......................................................................... 33
2.8 Description des cas d’utilisation : ............................................................................................ 34
2.8.1 Description textuelles : ......................................................................................................... 34
2.8.2 Les diagrammes de séquences : ............................................................................................ 36
2.8.3 Les diagrammes d’activités : ................................................................................................ 38
2.9 Conclusion : ............................................................................................................................... 40
Chapitre 3 : Conception ................................................................................................. 42
3.1 Introduction : ............................................................................................................................. 42
3.2 Conception globale : .................................................................................................................. 42
3.2.1 Schéma d’architecture: ......................................................................................................... 42
3.2.2 Développement du modèle de déploiement : ....................................................................... 43
3.2.2 Développement du modèle logique : .................................................................................... 44
3.3 Conception détaillée : ................................................................................................................ 47
3.3.1 Diagramme de navigation : .................................................................................................. 48
3.3.3 Diagramme de classe : .......................................................................................................... 49
3.3.4 Comportement du système : ................................................................................................. 51
3.4 Architecture de la base de données :........................................................................................ 54
3.5 Conclusion : ............................................................................................................................... 55
Chapitre 4 : Réalisation .................................................................................................................. 57
4.1 Introduction : ............................................................................................................................. 57
4.2 Environnement de travail : ....................................................................................................... 57
4.2.1 Environnement de développement : ..................................................................................... 57
4.2.2 Environnement logiciel : ...................................................................................................... 57
4.3 Interfaces de l’application : ...................................................................................................... 58
4.3 Chronogramme : ....................................................................................................................... 64
4.4 Conclusion : ............................................................................................................................... 64
Conclusion générale ....................................................................................................... 65
Bibliographie .................................................................................................................. 65
Listes des figures :
Figure 1: Logo MB2I …………………………………………………………………......3
Figure 2: carte d’identité MB2I…………………………………………………………...4
Figure 3: Logo Nuxeo……………………………………………………………………...4
Figure 4: Logo Knowledge Tree …………………………………………………………...4
Figure 5: Logo Exo……………………………………………………………………………….....4
Figure 6: Logo Alfresco …………………………………………………………………...4
Figure 7: Choix du type d’installation……………………………………………………………10
Figure 8 : Choix du type d’installation7
Figure 9 :
Figure 10 :
Figure 11 :
Figure 12 :
1
Introduction générale
De nos jours, on constate une croissance exponentielle de la masse des documents et la
quantité de l’information partagée, au sein des entreprises.
La gestion de ces documents, leur classement fastidieux et pénible, la dépense
d’énergie qui en découle, tout ceci demeure un problème persistant au quotidien. De même, la
recherche de l’information dans ce cas, devient une tache indispensable à la performance et au
développement des organisations quelles que soient leurs tailles, leurs missions, et leurs
sphères d’activité.
Dans ce contexte, l´archivage revêt désormais un caractère particulier et requiert une
méthodologie rigoureuse pour confronter ces problèmes, et d’organiser, d’une manière
systématique et efficace, tous les documents ou données dans une entreprise. Cette méthode
d’archivage a pour objectifs d’identifier les différents types de documents, les classer selon
des critères bien définis, les conserver et garder une trace tout le long de leur cycle de vie.
Pour faire face aux besoins d’archivage, une nécessité exige le déploiement d’un système de
gestion électronique des documents, introduisant le travail collaboratif et le partage des
fichiers.
La société MB2I Tunisie, filiale du groupe MB2I français, spécialisée dans
l’ingénierie informatique et les services relatifs aux entreprises, cherche à promouvoir une
solution de système de GED répondant aux besoins de ses clients et simplifiant les taches
liées aux documents, et en s’assurant d’une qualité de travail souhaitable en terme de coût ,
temps et maintenance.
C’est dans ce cadre que s’inscrit notre projet de fin d’études qui consiste à déployer un
système GED open-source traduisant les besoins de l’entreprise en terme de gestion des
documents et de développer un connecteur , facilitant l’archivage et le classement des
documents numériques au sein de de ce système .
Nos Principaux défis sont :
Perte de productivité : 45 minutes par semaine et par employé sont aujourd'hui
perdues pour classer et rechercher des documents papiers.
Explosion des coûts de stockage.
Cloisonnement des services dus à l'impossibilité de partager, en temps réel, les
informations stockées dans les classeurs papiers et sur les postes de travail
2
Le présent rapport décrit le travail réalisé. Il s’articule autour d’une introduction
générale suivie de quatre chapitres. L’introduction générale donne un aperçu sur l’organisme
d’accueil et explique quelques notions liées au contexte général du projet .Le premier
chapitre est consacré à une étude de l’existant, ce qui permet de mieux définir et cerner les
besoins. Le deuxième chapitre intitulé ; Analyse et spécification des besoins ; introduit la
problématique et donne un aspect aux besoins. Il définit également le processus de
développement et la méthodologie à suivre. De même, il fait l’objet d’une description du
projet à travers une capture des besoins fonctionnels et une analyse de ces derniers. Le
troisième chapitre spécifie les besoins techniques et décrit l’architecture adoptée. Il concerne
aussi la conception préliminaire et détaillée des fonctionnalités attendues de cette application.
Le quatrième chapitre porte sur l’implémentation et l’intégration de la solution logicielle en
présentant les interfaces utilisateur. Il comporte de même une description des outils de travail
et les tests des cas d’utilisation. Enfin, nous concluons ce rapport en présentant des
perspectives futures pour notre travail.
3
Cadre général :
Cadre du projet :
Les documents occupent une importance capitale dans les entreprises, d’où leur
gestion doit être suivie minutieusement et prudemment. Ces derniers contiennent des
informations généralement de grande valeur. Donc une première étape nécessite de garder une
version électronique de ces documents et par la suite ceux-ci doivent être intégrer dans un
système de GED.
Mais, avec toutes les informations et les fonctionnalités intégrées dans les GED actuels
il faudra, impérativement, trouver un moyen efficace afin de classer les documents
numériques, suivant des méthodes bien définis et structurés.
Dans cette optique, la société MB2I, nous a proposé comme stage de fin d’études la
conception et le développement d’un connecteur Alfresco afin d’obtenir une méthode de
classement et d’archivage qui pourrait mettre fin aux problèmes quotidiens de gestion des
documents, faciliter la recherche et l’exploitation et être commercialisé auprès de ses clients.
Entreprise d’accueil :
Créée en 1992, MB2I est une Société de Conseils et de Services Informatiques qui a
acquis au cours de son développement une expertise de multi-spécialiste avec une capacité à
gérer et faire évoluer l’ensemble des systèmes d'information d’une entreprise.
La société MB2I a pour objectif de fournir des solutions informatiques simples et
performantes, afin de réduire les coûts et augmenter la productivité de ses collaborateurs.
Figure 1 : Logo MB2I
4
MB2I dispose d’un siège social situé à Annecy Le Vieux – France et cinq filiales
situées dans l’Ile de France, Allemagne, Belgique, Italie et en Tunisie précisément à
Hammamet lieu d’exercice de notre stage de fin d d’études.
Figure 2 : carte d’identité MB2I
Services Offertes :
Les services de MB2I s’articulent autour de ces cinq fonctions :
les services en ingénierie Informatique :
MB2I accompagne ses clients depuis les phases de conseil et de conception, jusqu'à
l'implémentation et la maintenance de leur Système d'Information. Elle détend toutes les
certifications nécessaires pour la maitrise complète de ses actions, sans faire appel à la sous-
traitance.
l’hébergement et infogérance :
L'offre ASP, proposée par MB2I donne la possibilité d'externaliser tout ou une partie du
système d'information et de bénéficier des nombreux avantages de l’hébergement applicatif
(mobilité, maitrise des coûts, sécurité, sérénité, ...).
5
la virtualisation, l’intégration des solutions de GED :
MB2I propose des solutions de Gestion Electronique de Documents (G.E.D.) qui vont être
directement intégrées aux applications métiers, Lignes Productions, etc…auprès de ses
clients.
Télécommunications.
S’appuyant sur les technologies satellitaires développées par des acteurs majeurs, MB2I est
votre interlocuteur privilégié pour la mise en œuvre et la sécurisation de vos nouvelles
infrastructures de communication :
Interconnexion de sites distants : ministères, administrations, universités, filiales,
agences, ...
Transport de tous types de données : WAN/LAN (intranets, extranets, ...),
visioconférence, télésurveillance, diffusion de médias, formation à distance,
business TV, géo localisation, ...
Défense, Éducation, Finance, Santé, Sécurité, Aéronautique, ...
6
Chapitre 1
Etude de l’existant
7
Chapitre 1: Etude de l’existant
1.1 Introduction :
Ce chapitre va présenter, en premier lieu le contexte du projet. Une deuxième partie
sera consacrée pour l’étude de l’existant. Cette partie effectuera une étude sur les systèmes
GED open-source actuels, pour aboutir à la problématique qui a suscité le besoin de notre
projet et à la solution proposée.
Une autre partie sera consacrée à la présentation du système de GED Alfresco choisi et ses
avantages par rapport aux concurrents.
Une dernière partie de ce chapitre à la justification du choix de la solution adoptée pour
mettre en place notre application.
1.2 Les systèmes GED :
1.2.1 Définition:
La gestion électronique des documents (GED) :
La gestion électronique des documents désigne un procédé informatisé visant à organiser et
gérer des informations et des documents électroniques au sein d'une organisation. Le terme
GED désigne également les logiciels permettant la gestion de ces contenus documentaires.
Quatre étapes majeures dans une technique de GED : acquisition, classement, stockage et
diffusion.
Système de gestion de Contenu dans l’entreprise (ECM) :
La gestion de contenu d’entreprise (Entreprise Content Management) désigne également la
structuration de l’ensemble des informations numériques dans l’entreprise. Parmi les
fonctionnalités d’un ECM on trouve, l’intégration d’une démarche de GED, le suivi des
documents numérique et l’indexation, le travail collaboratif (groupware), le workflow.
Il existe plusieurs ECM dont on cite : Nuxeo, Alfresco, SharePoint.
8
1.2.2 Avantages :
Un système de GED est bénéfique pour l’entreprise. Il permet d’archiver la masse
d’informations papiers et la mettre en consultation avec, souvent, un outil de versionning.
En plus, il permet une diffusion plus rapide et plus large, et par conséquent l’entreprise va
économiser en matière de cout d’impression et d’espaces de stockages et augmenter la
productivité des employés.
1.2.3 Etapes de la GED :
- Acquisition :
C’est la première étape pour la mise en route de GED. Elle permet de transformer les
documents en papiers en une version numérique. En fonction du débit adéquate (scanner,
carte d’acquisition,…) .A l’issue de cette phase de numérisation, l’entreprise définira une
charte de nommage des documents pour que les atouts de la GED puissent profiter au grand
nombre.
- Classement :
L’indexation constitue un élément clé pour la description d’un document numérique .Ainsi,
elle rend le document plus facile à exploiter. Il existe deux types d’indexations :
indexation par type (formats du document), indexation par mots clés (vise le contenu du
document pour optimiser la recherche).L’entreprise doit saisir des index relatifs à ses besoins,
ceci est très important pour organiser et classer les documents dans le système GED.
- Stockage :
Il faut percevoir un support de stockage adapté au volume des documents. En plus,
l’entreprise doit prendre des mesures de sécurité en cas de panne, de perte ou d’incendie.
Il est primordial ainsi de planifier des sauvegardes automatiques et de différer les lieux des
supports de stockages.
- Diffusion des documents :
La diffusion des documents se fait par plusieurs moyens : internet ou intranet, dossier partagé
protocole FTP, CMIS, …
Certains éditeurs des outils GED proposent une consultation client-léger, de l’entrepôt de
données, via un navigateur web.
9
1.3 Présentation de la problématique :
Suite à la présentation des systèmes de GED et leurs phases d’intégration, une
intervention s’avère importante entre l’étape de classement et celle du stockage ,pour
automatiser ces taches et obtenir un meilleur résultat.
L’absence d’une stratégie fiable et d’un outil de classement et d’organisation vers
l’entrepôt du serveur GED déployé, permet à MB2I d’investir pour développer un connecteur
qui s’occupe de classer les documents en deux modes (Automatique et Semi-Automatique).
1.4 Présentation d’Alfresco :
1.4.1 Définition :
Alfresco est un système de gestion de contenu (ECM), open source en langage JAVA,
crée en 2005 par John Newton et John Powell, les co-fondateurs de Alfresco software, situé
en Grande-Bretagne.
1.4.2 Historique :
Alfresco est le produit d’une équipe composée du co-fondateur de Documentum et
d’anciens d’Intervowen (2 entreprises leaders dans le domaine de gestion des documents et
ont comme but à trouver des solutions pour les documents non structurés, depuis 1990). En
effet, Alfresco n’est pas né pour répliquer une solution open source vis-à-vis des solutions
propriétaire comme Microsoft SharePoint, FileNet d’IBM ou Documentum, mais de le
surpasser.
1.4.3 Les versions d’Alfresco :
Alfresco Community Edition :
Version téléchargeable, modifiable et utilisable, distribuée en licence libre (LGPL)
Alfresco Enterprise Edition:
Version commerciale, démarque essentiellement de la version Community, et elle ajoute le
support technique et les autres fonctionnalités complétant une solution GED. Ainsi on peut
tester cette version, Alfresco offre 30 jours gratuits puis obligation de payer.
10
Version sur le Cloud :
Cette version permet de partager le contenu tout en centralisant les données sur les serveurs
Cloud (Amazon Web Services aux états unis). Elle offre une gestion complète et un niveau de
sécurité performant.
1.4.4 Avantages Alfresco :
Alfresco est la GED par excellence. Une large gamme de produits, une version
payante, une version gratuite, une application iPad, iPhone et Android gratuite pour pouvoir
même gérer à distance. Aussi, grâce à « Alfresco Share », créer un site n'en est que plus
simple.
Alfresco vis-à-vis de ses concurrents :
1) Nuxeo :
C’est une plateforme open source de gestion de contenu qui permet aux architectes et
développeurs de faciliter, concevoir, déployer et exploiter des applications métier. Sur le
Cloud ou sur site, la technologie d'Enterprise Content Management (ECM) de Nuxeo permet
d'offrir des solutions intégrées de gestion de documents.
Points forts :
Basée sur Java et dotée d'une architecture logicielle moderne, la plateforme Nuxeo est conçue
pour être modulaire et extensible, se démarquant ainsi des solutions d'ECM traditionnelles.
Points Faibles :
L’utilisation semble très compliquée pour un utilisateur simple.
La configuration est compliquée car nous devons modifier des fichiers XML.
Figure 3 : Logo Nuxeo
11
2) Knowledge Tree:
Knowledgetree est une solution de GED open-source, disponible également en version
gratuite et payante.
Elle utilise les classiques PHP MySQL, ainsi elle propose les fonctionnalités qu’on doit
attendre de ce type de logiciel.
Points forts :
Facile à utiliser avec une interface agréable avec des fonctionnalités suffisantes.
Points faibles :
Pas d’intégration à Microsoft Office ou de signature électronique, dans la version gratuite.
Figure 4 : Logo Knowledge Tree
3) Exo-Dms (Document Management System)
Exo est un éditeur français fondé en 2003 par le français Benjamin Mestralet, notamment
via un financement du DoD (ministère de la défense américain). La société est aujourd’hui
présente en France, au Vietnam, en Ukraine et en Tunisie.
Exo-Platform fournit une suite des logiciels citons ainsi : eXo Portal, la gestion de
contenu web (eXo WCM), la gestion documentaire (eXo DMS).
Au sein de cette suite, eXo DMS, qui est écrit en Java, occupe une place centrale,
puisqu’il s’agit de la brique destinée à stocker l’ensemble des fichiers.
Points forts :
Une interface standard qui intègre nativement les facilités de l’explorateur Windows : cliquer-
glisser, raccourci clavier, affichage selon plusieurs modes.
L’intégration bureautique assez poussée, avec un plug-in spécifique pour MS Office et une
intégration Open Office.
12
La possibilité d’adapter les interfaces utilisateurs en fonction de leurs profils.
Points faibles :
Attacher directement à exo-Platform qui est un portail d’entreprise présentant beaucoup de
fonctionnalités, et il ne peut pas être pris en compte hors de cette suite.
Figure 5 : Logo Exo
Choix d’Alfresco :
Après cette étude sur les principaux systèmes GED open-source, nous avons choisi
Alfresco pour sa mise en valeur sur le travail collaboratif, et ses fonctionnalités complètes de
la GED. Il supporte des différentes plateformes : Windows, Mac et Linux.
Nouveautés de La version 4.0 d’Alfresco que nous allons utiliser :
Interactions sociales via des chaines de publications sur les réseaux sociaux
(Facebook, Tweeter).
De nouvelles options de sociabilité.
Accès via mobile ou tablette et modification, consultation de contenu.
Collaboration avec des utilisateurs via Alfresco Cloud.
Figure 6 : Logo Alfresco
1.5 Installation et Utilisation:
1.5.1 Introduction :
Dans cette étape nous allons installer la version gratuite d’Alfresco (Community Edition),
puis nous allons découvrir les fonctionnalités offertes et ses services.
13
Téléchargement de la version gratuite Community Edition :
Lien pour le téléchargement : http://wiki.alfresco.com/wiki/Download_Community_Edition
1.5.2 Installation :
Lors de l’installation à partir du fichier exécutable, on se trouve avec deux options :
Installation facile :
Permet une configuration par défauts des serveurs, nous n’avons qu’introduire le mot de
passe du compte administrateur.
Installation avancées (que nous allons suivre) :
Permet de configurer manuellement les serveurs (port et les services associés). Encore, nous
avons la possibilité d’ajouter des composants supplémentaires lors de l’installation.
Figure 7 : Choix du type d’installation
Alfresco permet de choisir les composants axillaires pour un fonctionnement
souhaité:
Java
PostegreSQL
SharePoint
Web Quick Start
Open Office
14
Configuration des serveurs :
A cette étape, l’assistant d’installation nous demande d’indiquer le port du serveur
postegreSQL (par défaut c’est 5432) et les paramètres du serveur web TomCat comme
l’indique la figure ci-dessous.
Figure 6 : Configuration du serveur Tomcat
Autres paramètres à mentionner :
Après la configuration de Tomcat et postegreSQL, nous allons configurer des autres
services relatifs au fonctionnement d’Alfresco :
Port du serveur FTP (par défaut 21).
Port du service RMI (par défaut 50500).
Mot de passe administrateur.
Port du protocole SharePoint et OpenOffice si on a choisi d’installer ces modules
auxiliaires. (port SharePoint par défaut 7070, OpenOffice 8100).
Note : toutes configurations écrites précédemment peuvent être modifiées par le fichier
alfresco-global.properties dont son emplacement est :
$(Dossier d’installation)\Alfresco\tomcat\shared\classes
15
1.5.3 Manuel d’utilisation :
Alfresco peut être accédé par deux moyens différents :
L’interface web : par le biais d’un navigateur web (Internet Explorer, Firefox,…)
L’interface WebDAV: par un logiciel spécifique WebDAV (Web-based
Distributed Authoring and Versioning).
WebDAV : C’est une extension du protocole http, sa mission est de rendre possible l’écriture
à travers le web et non seulement la lecture (semblable au protocole FTP).
L’interface web est celle qui offre le plus de possibilités : il est possible d’importer des
fichiers, de créer des espaces, de partager des documents, d’interagir avec d’autres
utilisateurs, etc.
L’interface WebDAV est plus limitée puisqu’elle se présente sous la forme
d’explorateur de fichier.
1) Authentification :
En saisissant l’url suivant : http://127.0.0.1:8080/alfresco/ dans le navigateur, une fenêtre
d’identification apparaisse. Pa défaut, on a qu’un seul utilisateur, c’est l‘administrateur.
Figure 7 : Page d’authentification
2) Tableau de bord :
Le tableau de bord présente beaucoup de fonctionnalités que nous allons découvrir. Ainsi il
peut être configuré et l’utilisateur peut afficher à son tableau juste les vues qu’il veut tels
que : les taches à réaliser, liste des espaces, guide de démarrage …
16
Figure 8 : Tableau de bord
Figure 8 : Configuration du tableau de bord
3) Espaces de travail :
Un espace de travail est constitué d’un ensemble des sous-espaces (dossiers) ou des
documents. Un simple clic sur le titre d’un contenu ou d’un espace permet d’y accéder
directement. Dans le cas d’un contenu, cela permet de télécharger le document.
On peut gérer la vue, ajouter un contenu, créer un espace, avec le menu au-dessus de
l’espace principal. Les actions disponibles sur les contenus et les sous-espaces varient en
fonction du rôle qui nous est attribué (voir rôles pages 17).
17
Figure 9 : Espaces de travail
L’icône permet de donner des informations complémentaires sur le sous-espace ou le
contenu.
Par exemple, pour un fichier PDF, nous pouvons visualiser les premières lignes du fichier, titre,
description, crée le, modificateur, auteur, taille.
4) Les rôles :
Les rôles procurent des droits particuliers à l’utilisateur pour un espace ou contenu donné.
Dans Alfresco, il existe 5 rôles dont les droits sont résumés dans le tableau suivant :
Tableau 1 : Listes des rôles
Le rôle du coordinateur qui a, tous les droits, est généralement donné au gestionnaire des
espaces .Le gestionnaire affecte ensuite les rôles aux autres utilisateurs en fonction des droits
qu’il souhaite leur attribuer.
18
Dans chaque espace ou contenu, nous trouvons une barre à droite précisant les actions
disponibles selon le rôle accordé sur l’espace en cours. (En appuyant sur l’icône ‘visualiser
les détails ‘ au-dessous de chaque contenu ou espace ).
5) La gestion des versions :
Le Versionning n’est pas activé par défaut. Il faut l’activer sur chaque document en
cliquant sur « Activer la gestion des versions» sur le vue « Détails » de chaque contenu.
Lors de l’activation du Versionning, la version 0.1 s’affecte au document. Ainsi, chaque
modification ou édition du contenu par les utilisateurs, une fenêtre s’affiche pour affecter une
nouvelle version.
Figure 10 : Versionning d’un document
6) Les actions :
Les actions dans Alfresco sont des actions basiques réalisables par l’utilisateur, telle que
copier, coller un document, envoyer un courriel, gérer les droits sur un espace, ajouter un
aspect à un document, etc. En outre, nous trouvons un assistant de création des actions
avancées lors de l’appui sur ’ Lancer une action’ depuis la vue des actions.
Les actions avancées les plus notables sont :
- Copier l’élément vers une destination.
- Déplacer l’élément vers une destination.
- Envoyer un courriel à des utilisateurs.
19
1.5.3 Administration :
L’administration dans Alfresco peut se faire à plusieurs niveaux, nous allons aborder
une administration basique.
Via la barre de menu, nous accédons à la console d’administration en cliquant sur
Figure 11 : Console d’administration
1) Gestion des utilisateurs :
En cliquant sur ‘Gérer les utilisateurs ‘ une page d’affiche en indiquant les utilisateurs
avec leur login et des actions spécifiques comme :
Modifier (changer les paramètres personnels, mail Alfresco, nom de l’utilisateur)
Changer le mot de passe.
Supprimer le compte de l’utilisateur.
Figure 12 : Page de gestion des utilisateurs
20
2) Gestion des groupes :
En cliquant sur ‘Gérer les groupes ‘, nous trouvons les différents groupes existants dans le
système Alfresco. Ainsi, on peut Créer un nouveau groupe, supprimer, gérer les membres.
3) Sauvegarde et restauration :
Dans tous les cas échéants, nous avons besoin d’une copie du système Alfresco, ainsi de la
base de données (par défaut c’est PostgreSQL, mais on peut la modifier et utiliser par
exemple MySQL).
Pour faire une sauvegarde du système, on doit copier tout le contenu du dossier alf_data
($(Dossier d’installation)\Alfresco\alf_data), en première étape, puis se connecter a
PostgreSQL via l’utilitaire graphique Pgadmin3 et faire une sauvegarde de la base de données
nommée Alfresco .Ensuite, un fichier .backup est généré.
Dans le cas inverse où nous voulons restaurer le système, nous n’avons que remplacer le
dossier alf_data et restaurer la base de données depuis le fichier .backup .
1.6 Personnalisation Alfresco :
1.6.1 Méthodologie et technologie adoptées :
Alfresco est un projet open-source, utilisant des standards ouverts, et basé sur la
technologie J2EE.
Alfresco a développé une architecture moderne qui utilise les derniers outils open-source
pour optimiser les performances, et de la programmation orientée aspects (AOP), notamment
dans le Framework Spring, facilitant ainsi la modularité et l’adaptabilité de l’application.
Spring en quelques mots :
Spring est effectivement un conteneur dit « léger », c'est-à-dire une infrastructure similaire
à un serveur d'application J2EE. Il prend donc en charge la création d'objets et leur mise en
relation par l'intermédiaire d'un fichier de configuration qui décrit les objets à fabriquer et les
relations de dépendance entre eux.
Le gros avantage par rapport aux serveurs d'application est qu'avec Spring, les classes
n'ont pas besoin d'implémenter une quelconque interface pour être prises en charge par le
21
Framework (au contraire des serveurs d'applications J2EE et des EJBs). C'est en ce sens que
Spring est qualifié de conteneur « léger ».
1.6.2 Architecture Alfresco:
L’architecture d’Alfresco, se repose sur quartes couches dont nous les détaillons comme
suit :
Figure 12 : Architecture Alfresco
1) Couche de stockage (Storage Layer) :
- Composée d’un SGBD relationnelle (par défaut c’est PostgreSQL) et un système de fichiers.
- Un contenu dans Alfresco, est composé d’un document plus des métadonnées. Il utilise un
système de fichier binaire (.bin) pour être indexé dans les moteurs de recherche open-sources
Solr ou Lucene (ça dépend de la version installée).
Modèle de données :
Les modèles de données dans Alfresco sont souples, extensibles et personnalisables.
Composants d’un modèle :
Type de contenu : spécifie le contenu (un contenu ne peut avoir qu’un seul type)
Exemple : Facture, rapport
Aspect : Qualifie un contenu (un contenu peut avoir plusieurs aspects), donc la
définition est réutilisable dans d’autres types.
Exemple : Clients, Fournisseurs.
Propriété et association : peuvent être affectées pour définir un type ou un aspect.
22
2) Couche d’entrepôt de données (Alfresco Repository) :
Figure 13 : Alfresco Repository
Cette couche est composée d’un moteur de gestion de contenu et des services associés. Les
services reposent sur le Framework Spring .Ils sont exposés par des interfaces publics
(Repository Foundation Services) et des composants qui les implémentent (Repository
Implementation). Parmi les services qui permettent le pilotage de contenu stockés dans
l’entrepôt Alfresco, nous trouvons principalement :
Les Actions et les règles :
Les règles de contenu s’appliquent aux espaces .Elles les ajoutent de l’intelligence. On peut
les Classer suivant trois aspects :
- un évènement déclencheur
- un ensemble de conditions
- une action à appliquer
23
Audit :
Permet la traçabilité des contenus et le suivi.
WorkFlow :
Alfresco intègre un moteur de WorkFlow BPM (Bussiness process management)
il comprend une étape (acceptation ou refus) et deux utilisateurs (celui qui dépose le
document et celui qui valide).
Sécurité :
Les permissions définissent les droits d’accès et d’opérations sur les contenus. Ils se basent
sur le système ACEGI de Spring et conçus pour définir des rôles (Lecteur, éditeur,
contributeur, collaborateur, coordinateur).
Parmi les apports en sécurité, le verrouillage pendant l’édition d’un document pour limiter les
risques de conflit.
3) Couche d’APIs et protocoles :
Les applications clientes communiquent avec Alfresco par les APIs et les protocoles.
L’exposition de ces protocoles et APIs permettent l’interopérabilité d’Alfresco vis-à-vis les
différentes applications du système d’information.
L’entrepôt d’Alfresco est accessible par différents protocoles, sans aucune installation sur
les postes clients.
Les protocoles : FTP, webDAV, CIFS, LDAP, NFS, CMIS.
Les APIs : web scripts, SOAP, java API.
4) Couche des applications Clients :
Deux applications web sont déployées dans le serveur d’applications :
alfresco.war : l’explorateur Alfresco
share.war : Espace collaboratif d’Alfresco
24
Figure 14 : Interface d’Alfresco Share
1.7 Solution adoptée :
D’après cette étude théorique et pratique sur Alfresco, il était primordial de choisir la
solution la plus adéquate pour implémenter notre connecteur .Pour y parvenir il faut faire des
personnalisations dans le code source du système et ajouter de nouveaux modèles de données
qui vont nous aider à mieux élaborer l’application connecteur et atteindre les objectifs fixés.
Conclusion:
Dans ce chapitre nous avons décrit le fonctionnement d’un système de gestion
électronique de documents et leurs apports à l’entreprise. Nous avons également essayé de
présenter Alfresco comme une solution à adopter, ainsi de découvrir quelques fonctionnalités
utiles.
Le chapitre 2 présentera l’aspect fonctionnel, le contexte et les objectifs du projet.
25
Chapitre 2
Analyse et Spécifications des
Besoins
26
Chapitre 2 : Analyse et Spécifications des Besoins
2.1 Introduction :
Cette étape permet d’élaborer une typologie de documents produits dans l’entreprise et
viser les différentes contraintes techniques et fonctionnelles. Notre travail a pour objectif de
concevoir une application connecteur à un serveur de GED Alfresco facilite la gestion des
documents (recherche, indexation, extraction des métadonnées, acquisition, règles de
classement).
2.2 Objectifs :
Nous devons préciser les attentes particulières des utilisateurs, concernant l’outil à
mettre en place. Pour y parvenir, les objectifs ci-dessous ont été fixés :
Etudier l’existant en matière d’organisation des documents, analyser les problèmes
vécus, et attribuer des modèles de données propres à l’entreprise.
Proposer une solution optimale qui facilite les différentes tâches de gestion des
documents et précisément la tâche d’archivage et de classification.
Automatiser la gestion des documents et faire apparaitre un aspect d’intelligence à
l’application connecteur, par l’affectation des index personnalisés (des listes, des
métadonnées).
2.3 Spécifications fonctionnelles:
2.3.1 Contexte :
Le projet consiste à la mise en place d’un connecteur Alfresco .En premier lieu, il doit
permettre aux utilisateurs de classer les documents suivant des règles de classement qui
s’exécutent en deux modes (Automatique, Semi-Automatique).En deuxième lieu, il doit gérer
l’indexation pour retrouver facilement les documents classés.
27
2.3.2 Besoins fonctionnels :
2.3.2.1 : Besoins relatifs aux utilisateurs :
- S’authentifier par compte invité (Guest) sans avoir recours à posséder un compte au
serveur Alfresco.
- Si l’utilisateur possède déjà un compte Alfresco, il doit contacter l’administrateur pour
lui permet de se connecter au connecteur avec son propre compte.
- Lister les règles de classement et leurs propriétés.
- Démarrer / Stopper une ou plusieurs règles de classements.
- Manipuler les documents (ajout, modification des index et des métadonnées).
- Consulter l’espace personnel via le navigateur web.
- Attribuer des index aux documents en mode semi-automatique
2.3.2.2 : Besoins relatifs aux administrateurs :
- Gérer les règles de classement (Création, Modification, Suppression).
- Gérer les index et leur type de données (Liste, un simple texte, des métadonnées).
- Administrer modifier les paramètres de la connexion (Serveur Alfresco et SGBD).
- Affecter des types de comptes aux utilisateurs du connecteur (Administrator, Guest,
Utilisateur existant).
2.4 Spécifications non fonctionnelles:
En plus des besoins fonctionnels, plusieurs considérations et contraintes additionnelles
doivent être prises en compte lors de la réalisation de notre projet. Ces se résument dans ce
qui suit :
- Interface simple et facile à utiliser montrant proprement les fonctionnalités du
système.
- Charte graphique : insertion du logo de la société MB2I.
- La montée en charge en particulier dans le nombre d’utilisateurs (Scalabilité du
système).
- Sécurisation de la base de données externe et protection des données.
- La fourniture d’un manuel d’utilisation décrivant les fonctionnalités de l’application.
- Portabilité du connecteur avec les différentes plateformes (Windows, Linux, Mac).
28
2.5 Modélisation du Contenu :
2.5.1 Moyens de classification :
Alfresco est capable de gérer de multiples moyens de classification de documents tout
en permettant une organisation adaptée à la nature des documents archivés (factures, contrats,
rapports …)
Nous pouvons classer les documents soit par une simple arborescence des espaces, Tags, ou
par des catégories.
Ci- dessous un tableau qui nous aide à identifier les moyens de classification dans
Alfresco :
Arborescence
Tags
Catégories
Contrôle d’accès x - -
Console d’administration - x x
Hiérarchisable x - x
Multicritères - x x
Accès rapide - x -
Tableau 2 : Moyens de classification Alfresco
2.5.1 Modèle de données personnalisé :
Figure 15 : Conception du modèle de données
Contenu
-
-
-
-
créateur
date de création
modificateur
date de modification
: String
: Date
: int
: String
Devis
-
-
-
code devis
montant devis
date devis
: int
: double
: Date
Commande
-
-
-
code commande
montant commande
date commande
: int
: double
: Date
Facture
-
-
-
-
code facture
montant facture
date facture
état facture
: int
: double
: Date
: boolean
29
Dictionnaire de données :
Il faut décrire les entités écrites précédemment, dans un dictionnaire de données pour
qu’elles soient gérées par Alfresco.
Le dictionnaire de données Alfresco est un ensemble de modèles de base simple
(Double, Float, Integer) et complexe (Content, Folder, Person) qui permettent de décrire la
structure des contenus à traiter.
Module Complémentaire « Editeur de modèles » :
Nous allons définir les nouvelles entités à partir des modèles de base (évidemment
‘content’) dans un fichier CustomModel.xml.
A l’aide d’alfresco-mmt.jar, nous pouvons déployer et installer de nouveaux modèles
AMP (Alfresco Module Package).
Figure 16 : Interface du module Editeur de modèle
Cette extension permet de produire des fichiers XML graphiquement, sans avoir
besoin de coder.
Il génère deux fichiers XML qu’on les trouve par défaut, sous le répertoire
dictionnaire de données
Fichier de Configuration : extForm.xml
Fichier de Modèle : extModel.xml
30
2.6 Le diagramme de packages des cas d’utilisation :
Figure 16 : Diagramme de package
Identification des acteurs :
- Utilisateur
- Administrateur
Description du diagramme
Ce diagramme décrit exhaustivement les exigences fonctionnelles du système.
Il se compose de 5 paquetages et englobe les fonctionnalités essentielles du système.
Gestion des Comptes
Classfication des documents
Gestion des index
Gestion des règles de Classement
Administration des Serveurs
Util isateur
Administrateur
31
Liste des Paquetages :
- Package 1 : Gestion Des règles de classement
- Package 2: Gestion des index
- Package 3: Gestion des comptes
- Package 4: Administration des serveurs
- Package 5: Classification des documents
2.7 Le diagramme des cas d’utilisation :
2.7.1 : Paquetage Gestion des règles de Classement :
Figure 17: Diagramme de cas d’utilisation «Gestion des règles de classement »
Use Cases (Utilisateur) :
- S’authentifier
- Démarrer une règle
- Stopper une règle
- Lister les règles
- Choisir une règle
Use Cases (Administrateur) :
- S’authentifier
- Ajouter une règle
- Supprimer une règle
- Modifier une règle
32
2.7.2 : Paquetage Gestion des index:
Figure 18: Diagramme de cas d’utilisation «Gestion des règles de index »
Use Cases (Utilisateur) :
- S’authentifier
- Lister les index
Use Cases (Administrateur) :
- S’authentifier
- Créer un index
- Supprimer un index
- Modifier un index
2.7.3 : Paquetage Gestion de compte :
Figure 17: Diagramme de cas d’utilisation «Gestion de compte»
33
Use Cases (Utilisateur) :
- S’authentifier
- Consulter l’espace Alfresco
- Se déconnecter
2.7.4 : Paquetage Administration des serveurs :
Figure 17: Diagramme de cas d’utilisation «Administration des serveurs »
Use Cases (Administrateur) :
- S’authentifier
- Paramétrer le serveur Alfresco
- Paramétrer le serveur BD
2.7.5 : Paquetage Classification des documents :
Figure 18: Diagramme de cas d’utilisation «Classification des documents»
Use Cases (Utilisateur) : archiver
34
2.8 Description des cas d’utilisation :
Dans cette section nous allons présenter les différents scénarios d'utilisation et les
interactions système-utilisateur, à l’aide des diagrammes de séquences pour décrire les
différents cas d’utilisations cités auparavant.
2.8.1 Description textuelles :
o Cas 1 : S’authentifier :
Nom : s’authentifier
Objectif : Permet d’établir une connexion au serveur Alfresco et de s’identifier (Utilisateur
simple / Administrateur) pour récupérer l’espace personnel ou l’historique (Base de donnée
externe à Alfresco)
Acteurs : utilisateur, administrateur
Précondition : ---
Scénario :
1) L’utilisateur doit posséder un compte Alfresco.
2) L’utilisateur doit entrer un login et un mot de passe.
Exception : Un message d’erreur est affiché si les informations de connexion ne sont pas
valides.
Post-Condition : Une session est ouverte, l’utilisateur peut ainsi choisir parmi les
fonctionnalités visibles pour lui dans l’interface de l’application.
o Cas 2 : Ajouter une règle :
Nom : Ajouter une règle de classement
Objectif : Permet d’ajouter une nouvelle règle de classement, et de définir ses propriétés et
son mode de classement (automatique/semi-automatique).
Acteurs : administrateur
Précondition : L’utilisateur se connecte en tant qu’administrateur.
35
Scénario :
1) L’utilisateur se connecte avec un compte administrateur.
2) L’administrateur accède à l’interface de gestion des règles de classement.
3) En cliquant sur le bouton ‘Ajouter une règle ‘, un formulaire s’affiche pour saisir
les propriétés d’une règle (Nom de la règle, Mode de classement, Répertoire de
numérisation, Format des documents numérisés, Format de documents classés, Charte de
nommage à travers des index).
4) Après avoir entré les propriétés de la nouvelle règle, l’administrateur l’enregistre,
et donc peut être visualisée dans l’ensemble des règles disponibles.
Exception :
1) Un message d’erreur est affiché si on clique sur ‘ enregistrer règle ‘ avant de remplir
correctement les propriétés de la règle.
2) Les paramètres de la base de données doivent être corrects et la connexion existe
pour ajouter une nouvelle règle.
Post-Condition : Une nouvelle règle de classement est créée.
o Cas 3 : Ajouter un index :
Nom : Ajouter un index.
Objectif : Permet d’ajouter un nouvel index qui s’introduit dans la charte de nommage
d’une règle de classement. Il peut être une liste, un simple texte, une date, un ensemble de
métadonnées
Acteurs : administrateur
Précondition : L’utilisateur se connecte en tant qu’administrateur.
Scénario :
1) L’utilisateur se connecte avec un compte administrateur.
2) L’administrateur accède à l’interface de gestion des index.
3) En cliquant sur le bouton ‘Ajouter un index ‘, un formulaire s’affiche pour saisir
les propriétés d’un index (Nom de l’index, Choix du type d’index : liste, texte, date).
36
4) Si l’administrateur choisit une liste comme type d’index, une fenêtre s’affiche
indiquant les listes disponibles et leurs données, ainsi un bouton pour créer une nouvelle
liste (Nom de la liste, valeur et type du champ).
5) Après avoir entré les propriétés du nouveau index, l’administrateur l’enregistre, et
donc peut être visualisé dans l’ensemble des index disponibles.
Exception :
1) Un message d’erreur est affiché si on clique sur ‘ enregistrer index ‘ avant de
remplir correctement ses propriétés.
2) Les paramètres de la base de données doivent être corrects et la connexion existe
pour ajouter un nouvel index.
Post-Condition : Un nouvel index est créé.
o Cas 4 : Paramétrer le serveur Alfresco :
Principalement, en précisant l’URL de l’application web Alfresco ( ip , port , et nom
d’application ). Exemple : url : http://127.0.0.1:8080/alfresco/
o Cas 5 : Paramétrer le serveur de la base de données.
Le rôle de cette base de données est d’enregistrer les règles de classement, les index, les
informations pour chaque compte. L’administrateur doit établir une connexion vers cette
base pour bénéficier d’un fonctionnement correct de l’application.
Les paramètres de la base de données à saisir :
- Nom de la base de données.
- url de la base de données.
- Nom utilisateur et mot de passe.
2.8.2 Les diagrammes de séquences :
o Cas 1 : Démarrer une règle de classement :
37
Figure 19: Diagramme de séquence «Démarrer une règle de classement »
démarrer règle de classement
saisir login et mot de passe
message d'erreur
archiver
ouvrir viewer
archiver
veiller répertoire
démarrer la règle de classement choisi
choisir une règle de classement
liste des règle de classement
lister les règles de classement
message
vérification
util isateur système
login et mot de passe valides
sinon
alt
mode classement = automatique
mode classement = semi-automatique
alt
saisir login et mot de passe
message d'erreur
archiver
ouvrir viewer
archiver
veiller répertoire
démarrer la règle de classement choisi
choisir une règle de classement
liste des règle de classement
lister les règles de classement
message
vérification
38
o Cas 2 : Consulter son espace Alfresco :
Figure 19: Diagramme de séquence «Consulter son espace Alfresco »
2.8.3 Les diagrammes d’activités :
o Cas 1 : Stopper une règle de classement :
consulter espace Alfresco
message d'erreur
ouvrir le tableau de bord Alfresco via le navigateur
vérifier les paramètres de connexion
accéder à l 'espace Alfresco
sasir login et mot de passe
util isateur système
login et mot de passe valides
sinon
alt
message d'erreur
ouvrir le tableau de bord Alfresco via le navigateur
vérifier les paramètres de connexion
accéder à l 'espace Alfresco
sasir login et mot de passe
39
Figure 19: Diagramme d’activités «Stopper une règle de classement »
o Cas 2 : archiver les documents:
Figure 20: Diagramme d’activités «archiver les documents »
40
2.9 Conclusion :
Tout au long de ce chapitre nous avons présenté les besoins auxquels le système doit
répondre .Nous avons également décrit les différents cas d'utilisation du système et nous les
avons formellement illustrés par des diagrammes de cas d'utilisation UML.
Nous avons aussi achevé la partie spécification et analyse de ce projet. Dans le
chapitre suivant nous allons passer à la partie de conception.
Le chapitre suivant nous mettra dans le cadre de la conception détaillée du projet.
41
Chapitre 3
Conception
42
Chapitre 3 : Conception
3.1 Introduction :
Afin d'atteindre les résultats escomptes, nous avons dû organiser nos besoins,
exprimés dans le chapitre spécification, selon une méthodologie de conception qui a le mérite
de faciliter la phase de réalisation.
Après la mention de l'architecture adoptée pour concevoir notre application, nous
présenterons le diagramme de classes relatif à notre application ainsi que la structure de notre
base de données.
3.2 Conception globale :
A cette étape nous allons traiter la conception préliminaire qui consiste à intégrer le
modèle d’analyse fonctionnelle dans l’architecture technique. Ensuite, nous allons aborder la
conception détaillé qui étudie comment réaliser chaque objet du système à développer.
3.2.1 Schéma d’architecture:
Nous allons adopter une architecture en deux tiers car ce type d’architecture est
parfaitement bien adapté aux systèmes départementaux, dans la mesure où les concepts et les
processus manipulés n’existent qu’une seule fois au sein d’un département de l’entreprise.
Figure 17: Architecture 2 tiers
43
Cette architecture s’articule autour d’une architecture en client-serveur dans sa
configuration la plus simple, c’est une architecture traditionnelle dans laquelle le client
demande une ressource et le serveur la lui fournit. Cela signifie que le serveur ne fait pas
appel à une autre application afin de fournir le service.
Dans ce cas la base de données est installée une seule fois dans un serveur (appelé
serveur de base de données) mais l’application doit être installé dans tous les clients. Les
clients accèdent au serveur via le réseau. Le schéma suivant donne un aperçu de cette
architecture.
Avantages de la solution
- Pas de duplication de données sur les postes.
- Gain de temps au niveau des transactions de données grâce à l’inexistence d’un
serveur de traitement.
- Les mises à jour sont faites en temps réel.
- Assurer la disponibilité d’une information fiable en temps voulu pour tous les acteurs
du système.
- Assurer la répartition des tâches entre les acteurs du système.
- Diminution des retards dans l’élaboration des documents.
- Centralisation des données.
Inconvénients
- Importance de la charge du poste client due aux traitements applicatifs.
- Le contrôle permanant est nécessaire pour éviter les pannes et pour sécuriser les
données.
3.2.2 Développement du modèle de déploiement :
Le modèle de déploiement est le premier niveau de conception car c’est lui qui permet
d’organiser les environnements de travail. En effet le diagramme de déploiement décrit la
disposition physique des ressources matérielles qui composent le système et montre la
répartition des composants sur ces matériels. Pour cela nous allons modéliser notre
architechture par un diagramme de déploiement :
44
Figure 17: Modèle de déploiement
3.2.2 Développement du modèle logique :
Nous allons organiser le développement de l’application en 3 couches, comme ci-
dessous :
- Couche 1 (Présentation) : décrit la vue statique des composantes de L’IHM.
- Couche 2 (Métiers ou control) : décrit le fonctionnement technique de
l’interface et l’implémentation de différentes fonctionnalités. C’est une
intermédiaire entre la couche de présentation et de la persistance.
- Couche 3(Persistance) : C’est la couche qui permet de sauvegarder et faire
appel aux données persistantes de l’application.
Figure 17: paquetage de l’application
Présentation<<layer>>
Métiers<<layer>>
Persistance<<layer>>
45
3.2.2.1 Couche présentation :
La couche présentation assure la logique de navigation entre les différentes
fonctionnalités offertes par l’application, mais aussi la gestion des droits d'utilisateur.
Cette couche est implémentée à l’aide de la bibliothèque Swing du Java.
- La bibliothèque Swing:
Swing est une bibliothèque graphique pour le langage de programmation Java, faisant
partie du package Java Foundation Classes (JFC), inclus dans J2SE. Swing constitue l'une des
principales évolutions apportées par Java 2 par rapport aux versions antérieures.
Swing offre la possibilité de créer des interfaces graphiques identiques quel que soit le
système d'exploitation sous-jacent, au prix de performances moindres qu'en utilisant Abstract
Window Toolkit (AWT). Il utilise le principe Modèle-Vue-Contrôleur (MVC, les composants
Swing jouent en fait le rôle du contrôleur au sens du MVC) et dispose de plusieurs choix
d'apparence (de vue) pour chacun des composants standards.
Swing est très simple à utiliser, et contient tous les composants attendus dans une
interface utilisateur moderne, depuis des boutons contenant des images jusqu'à des
arborescences et des tables. C'est une bibliothèque géante conçue pour avoir la
complexité appropriée, proportionnellement à la tâche à effectuer.
Existent également les gestionnaires d’interface graphique SWT et JFace, créés par
Eclipse pour pallier les manques des gestionnaires de Sun pour le propre usage d'Eclipse.
SWT se veut plus léger qu’AWT et Swing réunis, tout en fournissant un large jeu de widgets
et bibliothèques graphiques. Ce Framework est indépendant du système tout en étant capable
d'utiliser des éléments natifs.
JFace, de son côté, est une boîte à outils qui permet de simplifier la plupart des tâches
graphiques. Il est construit à partir de SWT. Ces deux Frameworks graphiques sont
accessibles à tous ceux ayant installé le SDK d'Eclipse…
3.2.2.2 Couche métiers:
C'est dans cette couche que nous allons retrouver dans tous les traitements métiers de
l'application. Ces traitements seront implémentés sous forme de consommation des web
services CMIS Alfresco.
46
- Le protocole CMIS :
Figure 17: Logo CMIS
Content Management Interoperability Services est un protocole ouvert géré par
OASIS. Son but est d'augmenter l'interopérabilité entre les ECM (Alfresco, Exo Platform,
IBM filenet, Microsoft SharePoint, Nuxeo.
CMIS fournit un modèle de données commun couvrant les types de fichiers et
répertoires avec des propriétés génériques pouvant être lues ou écrites. CMIS décrit aussi un
système de gestion des droits d'accès, de contrôle de version et offre la possibilité de définir
des relations génériques. Il dispose d'un ensemble de services pour modifier ou interroger le
modèle de données et peut être utilisé par plusieurs protocoles comme SOAP et REST à l'aide
de la convention Atom2. Le modèle est basé sur des architectures communes de systèmes de
gestion de documents.
Architecture CMIS :
Figure 17: Architecture CMIS
47
3.2.2.3 Couche de la persistance:
La partie du code responsable de l'accès aux données l’application doit être
encapsulée dans cette couche .Elle implémente la notion de CRUD qui représentent un
ensemble des 4 opérations de bases réalisables sur les données (create, read, update, delete).
Celle-ci permet notamment :
- d'ajouter un niveau d'abstraction entre la base de données et l'utilisation qui en
est faite.
- de simplifier la couche métier qui utilise les traitements de cette couche.
- de masquer les traitements réalisés pour mapper les objets dans la base de
données et vice versa.
- de faciliter le remplacement de la base de données utilisée.
Nous allons mettre en œuvre le design pattern DAO (Data Access Object) proposé par
Sun, afin de regrouper la logique d'accès aux données dans un objet séparé auquel les clients
délègueront la responsabilité de l'accès aux données. Cette logique offre les primitives de base
CRUD.
Utilisation du JDBC :
La solution standard se nomme JDBC : c'est une API qui fait partie intégrante de la
plate-forme Java, et qui est constituée de classes permettant l'accès depuis une application
Java à des données rangées dans une base de données. Les actions rendues possibles par cette
API sont :
- la connexion avec le SGBD ;
- l'envoi de requêtes SQL au SGBD depuis une application Java ;
- le traitement des données et éventuelles erreurs retournées par le SGBD lors
des différentes étapes du dialogue (connexion, requête, exécution, etc.).
3.3 Conception détaillée :
Dans cette section nous allons décrire les trois couches de l’application. Tout d’abord,
nous allons décrire la structure de l’interface GUI, puis présenter les diagrammes de classes
relatifs aux métiers et persistance de notre application.
48
3.3.1 Diagramme de navigation :
Figure 17: Digramme de navigation de l’interface
Description de l’interface :
Barre d’outils :
- Démarrer : pour choisir une règle et la démarrer (accès rapide).
- Stopper : pour stopper la dernière règle démarrée en cas de plusieurs.
- Serveurs : configuration des serveurs et administration.
Barre de menu :
- Fichier : Ajout d’un document dans l’espace personnel d’Alfresco.
- Outils :
- A propos : détail sur l’application (résumé, version, auteur).
Boutons de fonctionnalités :
- Accueil : pour retourner sur l’interface primaire de l’application.
- Listes : gérer les listes qui vont être comme des index lors du saisi des
métadonnées.
- Règles de classement : démarrer, stopper et gérer les règles de classement.
- Mes documents : accéder à l’espace personnel d’Alfresco via le navigateur.
- Administration : Configuration des serveurs Alfresco et la base de données
propre à l’application.
49
3.3.3 Diagramme de classe :
Figure 17: Digramme de classe
0..1
0..*
0..1
0..*
0..1
0..*
0..1
0..*
0..1
0..*
0..1
0..*
util isateur
-
-
-
-
id_util isateur
nom_util isateur
pass_util isateur
droit_util isateur
: int
: String
: String
: String
+
+
+
+
+
+
+
+
+
+
+
+
+
+
util isateur ()
set_id ()
get_id ()
set_nom_util isateur ()
get_nom_util isateur ()
set_pass_util isateur ()
get_pass_util isateur ()
set_droit_util isateur ()
get_droit_util isateur ()
démarrer_regle_classement ()
stopper_regle_classement ()
l ister_regle_classement ()
l ister_listes ()
l ister_index ()...
administrateur
+
+
+
+
+
+
+
+
+
+
ajouter_index ()
modifier_index ()
supprimer_index ()
ajouter_liste ()
modifier_liste ()
supprimer_liste ()
ajouter_regle_classement ()
modifier_regle_classemen ()
supprimer_regle_classemen ()
paramètrer_serveur ()...
espace d'acceuil
-
-
nom_espace_acceuil
racine_espace_acceuil
: String
: String
+
+
get_nom_espace_acceuil ()
get_racine_espace_acceuil ()...
contenu alfresco
{abstract}
-
-
nom
description
: String
: String
+
+
+
+
set_nom ()
get_nom ()
set_description ()
get_description ()...
espaces
- catégorie : String
+ ajouter_espace ()...
documents
+ ajouter_document ()...
devis
-
-
-
code_devis
date_devis
montant_devis
: String
: Date
: double
+
+
+
+
+
+
+
+
+
set_code_devis ()
get_code_devis ()
set_date_devis ()
get_date_devis ()
set_montant_devis ()
get_montant_devis ()
ajouter_devis ()
modifier_devis ()
supprimer_devis ()...
commande
-
-
-
code_commande
date_commande
montant_commande
: String
: Date
: double
+
+
+
+
+
+
+
+
+
set_code_commande ()
get_code_commande ()
set_date_commande ()
get_date_commande ()
set_montant_commande ()
get_montant_commande ()
ajouter_commande ()
modifier_commande ()
supprimer_commande ()...
facture
-
-
-
-
code_facture
date_facture
etat_facture
montant_facture
: String
: Date
: String
: double
+
+
+
+
+
+
+
+
+
+
+
set_code_facture ()
get_code_facture ()
set_date_facture ()
get_date_facture ()
set_montant_facture ()
get_montant_facture ()
set_etat_facture ()
get_etat_facture ()
ajouter_facture ()
modifier_facture ()
supprimer_facture ()...
espace commande
+ ajouter_espace_commande ()...
espace devis
+ ajouter_espace_devis ()...
espace facture
+ ajouter_espace_facture ()...
<<control>>
gestion règle de classement
+
+
+
+
+
+
ajouter_regle_classement ()
modifier_regle_classement ()
supprimer_regle_classement ()
l ister_regle_classement ()
démarrer_regle_classement ()
stopper_regle_classement ()...
<<control>>
gestion compte
+ ajouter_contenu ()...
<<control>>
gestion index
+
+
+
+
ajouter_index ()
modifier_index ()
supprimer_index ()
l ister_index ()...
<<control>>
gestion des listes
+
+
+
+
ajouter_liste ()
supprimer_liste ()
modifier_liste ()
l ister_listes ()...
règle de classement
-
-
-
-
-
-
-
id_regle_classement
nom_regle_classement
format_doc_numerise
format_doc_class
mode_classement
repertoire_num
repertoire_classement
: int
: int
: int
: int
: int
: int
: int
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
regle_classement ()
set_id_regle ()
get_id_regle ()
set_nom_regle ()
get_nom_regle ()
set_format_num ()
get_format_num ()
set_format_cl ()
get_format_cl ()
set_mode_classement ()
get_mode_classement ()
set_rep_num ()
get_rep_num ()
set_rep_cl ()
get_rep_cl ()...
l iste
-
-
id_liste
nom_liste
: int
: int
+
+
+
+
+
liste ()
set_id_liste ()
get_id_liste ()
set_nom_liste ()
get_nom_liste ()...
champ
-
-
id_champ
champ_texte
: int
: String
+
+
+
+
+
champ ()
set_id_champ ()
get_id_champ ()
set_champ_texte ()
get_champ_texte ()...
index
-
-
id_index
nom_index
: int
: int
+
+
+
+
+
index ()
set_id_index ()
get_id_index ()
set_nom_index ()
get_nom_index ()...
type index
- format_type : String
serveur
{abstract}
-
-
-
-
nom_serveur
url_serveur
nom_util isateur
pass_util isateur
: String
: String
: String
: String
+
+
+
+
+
+
+
+
set_nom_serveur ()
get_nom_serveur ()
set_url_serveur ()
get_url_serveur ()
set_nom_util isateur ()
get_nom_util isateur ()
set_pass_util isateur ()
get_pass_util isateur ()...
serveur Alfresco
serveur base de données
- nom_bd : String
+
+
set_nom_bd ()
get_nom_bd ()...
<<control>>
administration des serveurs
+ paramètrer_serveur ()...
l iste regles classement
liste des liste
liste des index
50
Description des Classes importantes:
Classe Utilisateur : Cette classe représente un utilisateur qui n'a accès qu'aux fonctionnalités
de base du système. En effet, elle représente l'utilisateur dans son cadre le plus général. Les
principales méthodes de cette classe sont :
- Lister les règles de classement
- Lister les listes
- Lister les index
- Démarrer une règle de classement
- Stopper une règle de classement
- Ajouter un contenu (document, espace)
Classe Administrateur : Cette Classe représente un administrateur qui a le privilège de gérer
les données relatives au système, outre que les fonctionnalités relatives à un simple utilisateur.
Les méthodes principales de cette classe sont :
- Paramétrer serveur (Alfresco et BD)
- Créer une règle de classement
- Modifier une règle de classement
- Créer un index
- Créer une liste
.
Les classe de la partie « control » interagissent et exposent des méthodes pour fournir
les fonctions de l’application, et faisons appel à des objets d’accès à la base de données
(DAO) en cas de besoin.
Les cas d'utilisation décrits dans le chapitre précédent décrivent les interactions entre
le système et les acteurs (utilisateur et administrateur). Lors de ces interactions, les acteurs
génèrent des services en envoyant des requêtes au sein du système, qui répond à son tour en
envoyant des réponses. Ainsi, le système est vu comme étant une boite noire. Maintenant, à
partir du diagramme de classes (Modèle de données) nous pouvons découper le système et
découvrir son fonctionnement interne à l’aide des diagrammes comportementaux.
51
3.3.4 Comportement du système :
1) Diagramme de séquence « Démarrer une règle de classement» :
Figure 17: Digramme de séquence « démarrer règle de classement »
DiagrammeSequence démarrer règle de classement
archiver ()
saisir métadonnées ()
ouvrir PDF viewer ()
actualiser ()
archiver ()
get répertoire classement ()
veil ler répertoire numérisation ()
démarrer règle de classement ()
sélectionner règle de classement ()
l iste des règle de classement
lister règles de classement ()
util isateur
l iste règle de classement règle de classement contenu Alfresco
[while true]loop
[document trouvé]opt
mode classement = automatique
mode classement = semi_automatique
alt
archiver ()
saisir métadonnées ()
ouvrir PDF viewer ()
actualiser ()
archiver ()
get répertoire classement ()
veil ler répertoire numérisation ()
démarrer règle de classement ()
sélectionner règle de classement ()
l iste des règle de classement
lister règles de classement ()
52
2) Diagramme de séquence « Ajouter un document à son espace personnel Alfresco » :
Figure 17: Digramme de séquence « ajouter document »
DiagrammeSequence Ajouter document
message
actualiser ()
ajouter document ()
ajouter contenu ()
set chemin répertoire
spécifier la répertoire Alfresco
ajouter document ()
util isateur
contenu Alfrescogestion compte document
message
actualiser ()
ajouter document ()
ajouter contenu ()
set chemin répertoire
spécifier la répertoire Alfresco
ajouter document ()
53
3) Diagramme de séquence « Affecter un index au charte de nommage» :
Figure 17: Digramme de séquence « affecter index au charte de nommage»
DiagrammeSequence affecter index
affecter ()
saisir valeur
affecter ()
sélectionner l iste
l iste des listes
set type index
spécifier le type d'index ()
formulaire de définition du charte de nommage
définir charte de nommage ()
forulaire de modification
modifier règle de classement ()
séléctionner règle de classement ()
l iste des règles de classement
lister règle de classement ()
administrateur
saisir valeur () règle de classement type index liste des liste
type index = liste
type index = date OU type index = texte
alt
affecter ()
saisir valeur
affecter ()
sélectionner l iste
l iste des listes
set type index
spécifier le type d'index ()
formulaire de définition du charte de nommage
définir charte de nommage ()
forulaire de modification
modifier règle de classement ()
séléctionner règle de classement ()
l iste des règles de classement
lister règle de classement ()
54
3.4 Architecture de la base de données :
Cette partie est consacrée à la conception de la base de données .En tenant compte des
diverses fonctionnalités que doit assurer l’application. Nous avons choisi d’adapter un modèle
relationnelle pour une base de données de type MySQL dont l’architecture ci-dessous :
Figure 17: Architecture de la base de données
Description des tables :
- Table utilisateur :
Cette table est responsable de gérer la liste des utilisateurs de l’application et de différencier
leur type à l’aide de l’attribut ‘droit’ qui avoir comme valeur soit « administrator » soit
« guest ».
- Table règle de classement :
Cette table sert à persister les règle de classement et leur propriétés.
55
- Table liste index :
Son rôle est d’attribuer un ou plusieurs index à une règle de classement afin d’être utilisé par
la suite dans la charte de nommage ou la saisi des métadonnées des documents.
- Table index :
Cette table a été défini pour la mise en place des index et les différencier par type.
- Table type index :
Le type d’index peut être une liste, un texte ou une date. L’attribut format est conçu pour
spécifier le format de la date, le séparateur pour les listes, la longueur de la chaine pour les
textes. Il peut être spécialisé par l’attribut type (texte, liste, date).
- Table Liste :
C’est un type d’index permet d’enregistrer les listes qui sont enfaite un ensemble des champs.
Par exemple liste des clients (client1, client2,…).
- Table champ :
Un champ c’est une valeur texte affecté à une liste.
3.5 Conclusion :
Tout au long de ce chapitre, nous avons décrit les différentes parties de l'architecture
utilisée grâce aux diagrammes de classes ainsi que la structure de la base de données et les
relations entre les tables.
Dans le chapitre suivant nous décrivons de façon détaillée la réalisation de notre
application et nous exposons le travail réalisé.
56
Chapitre 4
Réalisation
57
Chapitre 4 : Réalisation
4.1 Introduction :
Ce chapitre traite la réalisation de notre application. Il sera composé de trois parties : la
première partie s’intéresse à l’environnement matériel et logiciel et les choix technique de
développement de notre travail, la deuxième partie est une description des différentes
interfaces de l’application connecteur et la dernière partie sera le chronogramme du travail.
4.2 Environnement de travail :
Dans cette partie, nous allons justifier notre choix des différents outils de
programmation pour réaliser les différentes parties de notre application selon l’architecture
adoptée client/serveur.
4.2.1 Environnement de développement :
Nous avions le choix entre différents langages de programmation orientée objets car
ils nous apportent les possibilités suivantes :
- Il permet de développer simplement des interfaces graphiques.
- Il permet d’utiliser l’héritage et le polymorphisme.
- Il permet de modéliser informatiquement des objets du monde réel tel que des
documents ou des archives.
Parmi tous les langages objets proposé, notamment java et C# nous avons décidé d’utiliser
JAVA pour les raisons suivants :
- C’est un langage multiplateforme offrant une grande portabilité à l’application
(Windows, Linux, Mac).
- Il possède un nombre important des classes implémentant les interfaces
graphiques, ainsi que l’intégration facile des builders qui génère un code
proportionnellement compréhensible.
4.2.2 Environnement logiciel :
Eclipse Indigo: Pour l’environnement de développement nous avons adopté l’IDE
Eclipse Indigo puisqu’il est le plus convenable pour réaliser l’application. Nous avons intégré
58
le module windowBuilder pour la génération des interfaces graphiques ce qui facilite les
taches et rendre l’application plus souple à manipuler.
PowerAMC : Pour la phase de conception de notre projet, nous avons recourt à ce
logiciel pour mettre en place les différents diagrammes UML utiles pour concevoir les
différentes parties de conception de l’application.
MySQL : C’est un extensible, moteur de base de données, open source. Il est utilisé
plus souvent dans les PME et les bases de données de petites tailles. Aussi, s'intègre
parfaitement au langage de programmation JAVA.
Nous avons utilisé SQLyog pour créer et manipuler les données de la base de données.
4.3 Interfaces de l’application : Dans cette partie, nous entamions les interfaces de l’application.
La figure suivante montrera l’interface de connexion de l’application :
1) Interface de connexion :
Figure 17: interface de connexion
Pour des raisons de sécurité, chaque utilisateur doit passer par une étape d’authentification
pour pouvoir accéder aux services. Une vérification sur l’état du serveur Alfresco, ainsi le serveur
de la base de données pour contribuer à l’interface de navigation qui contient les services de
l’application selon des droits accordés.
59
Après authentification, l’interface accessible à l’utilisateur est celle de la figure xx ou xx.
2) Interface de navigation relative à l’administrateur :
Figure 17: interface de navigation relative à un administrateur
3) Interface de navigation relative à un utilisateur :
Figure 17: interface de navigation relative à un utilisateur
60
4) Interface des règles de classement :
a) Interface principale des règles de classement relative à un administrateur :
Figure 17: interface d’accueil des règles de classement (administrateur)
b) Interface principale des règles de classement relative à un utilisateur :
Figure 17: interface d’accueil des règles de classement (utilisateur)
61
Nous remarquons l’absence des boutons des gestions des règles de classement pour un
utilisateur simple .Ainsi, il peut que démarrer / stopper une ou plusieurs règles et lister leur
propriétés.
c) Interface de création d’une règle de classement :
Figure 17: interface de création d’une règle de classement
d) Interface de modification d’une règle de classement :
Figure 17: interface de modification d’une règle de classement
62
e) Interface de suppression d’une règle de classement :
Figure 17: interface de suppression d’une règle de classement
5) Interface des listes :
Figure 17: interface de gestion des listes
63
Pour un utilisateur simple les boutons nouvelle , enregistrer supprimer et modifier ne sont pas
accessibles .Il peut que lister les champs des listes.
6) Interface d’administration des serveurs :
Figure 17: interface d’administration
64
4.3 Chronogramme :
La réalisation de l’application a nécessité beaucoup de temps surtout en ce qui concerne
la partie de développement, il fallait mettre une démarche de travail et la suivre en se basant
sur la partie relative à la conception pour aboutir à un système sûr et fiable.
Nous avons ainsi développé les module des règles de classement et les listes ainsi que
la coordination entre l’utilisation de l’application comme étant un administrateur ou
utilisateur. Nous voulons introduire un module pour gérer l’historique mais il n’était pas
développé par contrainte de temps.
Le chronogramme de la figure xx expose la partition temporelle des différentes étapes
du projet tout au long de la période de réalisation.
Février Mars Avril Mai
Etude de
documentation
Analyse et
conception
Réalisation
Rédaction du
rapport
Figure 17: chronogramme
4.4 Conclusion :
Dans ce chapitre, après une étude sur le choix technique et le choix de
l’environnement de travail, nous avons essayé de présenter les aspects de réalisation de notre
application à travers les aperçus d’écrans témoignant les différentes facettes de l’application.
65
Conclusion générale
Bibliographie
Recommended