Issuu on Google+

Application Intranet permettant la gestion d’un système d’information

Page de garde   

Année Universitaire  2007 – 2008   

 

 

Page 1 sur 59                            


Application Intranet permettant la gestion d’un système d’information

Pas imprimé   

Année Universitaire  2007 – 2008   

 

 

Page 2 sur 59                            


Application Intranet permettant la gestion d’un système d’information

Page de garde sans couleur   

Année Universitaire  2007 – 2008   

 

 

Page 3 sur 59                            


Application Intranet permettant la gestion d’un système d’information

Remerciements   

Mes remerciements vont en premier lieu à mon tuteur de projet, Christophe Charlon ainsi que son père  Jean‐Luc Charlon sans qui ce stage n’aurait pu voir le jour. J’ai bénéficié d’un suivi régulier, enthousiaste  et efficace de la part de l’ensemble de l’équipe et plus particulièrement François Lesage  à qui le logiciel  est destiné. J’ai pu trouver au sein de l’entreprise Charlon un confort  inestimable grâce notamment à  une équipe exceptionnelle et  toujours disponible. Je tiens aussi à féliciter Cathy, notre cher Grand père  Alain ainsi que le reste de l’équipe pour m’avoir supporté 10 semaines !   Je tiens aussi à remercier M. Mahé pour m’avoir éclairé sur certains points du projet mais aussi pour  s’être déplacé jusqu’à Sète.   

   

Année Universitaire  2007 – 2008   

 

 

Page 4 sur 59                            


Application Intranet permettant la gestion d’un système d’information

      ‐12‐  Figure 2‐1 : Certification AFAQ à la norme ISO 9001 : 2000                                                                   Figure 2‐2 : Cas d’utilisations du logiciel  ‐13‐  Figure 2‐3 : Dialogue client – serveur avec utilisation de PHP/MySQL  ‐16‐  Figure 2‐4 : Différentes étapes du fonctionnement de PDO  ‐18‐  Figure 3‐1 : Illustration de Microsoft Works 4.5  ‐20‐  Figure 3‐2 : Capture d’écran de la base de données sous Works DB  ‐20‐  Figure 3‐3 : Modèle relationnel des données  ‐23‐  Figure 3‐4 : Vulgarisation du fonctionnement d’un Framework  ‐24‐  Figure 3‐5 : Fonctionnement du modèle MVC  ‐25‐  Figure 3‐6 : Modèle MVC avec l’utilisation d’un Front Controller  ‐26‐  Figure 3‐7 : Arborescence de l’application  ‐27‐  Figure 3‐8 : Extrait du diagramme des classes concernant le modèle MVC  ‐29‐  Figure 3‐9 : Différents modes d’appels du Front Controller  ‐30‐  ‐32‐  Figure 3‐10 : Mise en page de l’interface graphique avec système de pseudo frames  Figure 3‐11 : Capture d’écran du gestionnaire des utilisateurs  ‐34‐  Figure 3‐12 : Diagramme des séquences de l’affichage des pages  ‐34‐  Figure 3‐13 : Capture d’écran du gestionnaire des varibles prédéfinies  ‐35‐  ‐36‐  Figure 3‐14 : Capture d’écran d’un champ utilisant l’autocomplétion  Figure 3‐15 : Diagramme des séquences de la validation des formulaires  ‐37‐  Figure 3‐16 : Mise en page de la page permettant la création de requête  ‐39‐  ‐39‐  Figure 3‐17 : Variable calculée correspondant à la moyenne des infractions disques par an  Figure 3‐18 : Aperçu de la Classe Requete_creator  ‐40‐  Figure 3‐19 : Le créateur de requêtes de Works DB à droite et celui de phpmyadmin à gauche  ‐41‐  Figure 3‐20 : Capture d’écran du formulaire de création de requêtes  ‐42‐  Figure 3‐21 : Capture d’écran  de l’affichage du résultat de la requête  ‐44‐  Figure 3‐22 : A gauche le gabarit et à droite le document produit  ‐45‐  Figure 3‐23 : Capture d’écran du créateur d’état  ‐46‐  Figure 3‐24 : Aperçu de la Classe Etat  ‐47‐  ‐48‐  Figure 3‐25 : Diagramme des séquences de la génération d’états  Figure 3‐26 : Logo de JpGraph  ‐49‐  Figure 3‐27 : Graphique crée à partir de la librairie JpGraph  ‐50‐  Figure 4‐1 : Capture d’écran de la page d’identification  ‐52‐  Figure 4‐2 : Capture d’écran montrant la zone d’administration de l’application  ‐52‐  Figure 4‐3 : Capture d’écran du formulaire de création d’utilisateur                                                         ‐53‐  Figure 4‐4 : Capture d’écran montrant le gestionnaire des infractions disques  ‐53‐  Figure 4‐5 : Capture d’écran du créateur d’états  ‐54‐  ‐54‐  Figure 4‐6 : Capture d’écran d’un des formulaires d’ajout  Figure 4‐7 : Capture d’écran du créateur de requête  ‐55‐  Figure 4‐8 : Capture d’écran du formulaire de modification d’une personne  ‐55‐ 

Liste des figures 

Année Universitaire  2007 – 2008   

 

Page 5 sur 59                            


Application Intranet permettant la gestion d’un système d’information

Sommaire    1 

Introduction ........................................................................................................................................ 10  1.1 L’entreprise ....................................................................................................................................... 10  1.2 Présentation du projet ...................................................................................................................... 10 

Analyse ................................................................................................................................................ 11  2.1 Données traitées ............................................................................................................................... 11  2.2 Normes ISO 9001 : 2000 et audits ..................................................................................................... 12  2.3 Cahier des charges ............................................................................................................................ 12  2.3.1  Objectifs .................................................................................................................................... 12  2.3.2 Cas d’utilisations......................................................................................................................... 13  2.4 Processus de développements .......................................................................................................... 14  2.5 Outils ................................................................................................................................................. 15  2.5.1 Langage de programmation ....................................................................................................... 15  2.5.2 Matériels et fonctionnement ..................................................................................................... 15  2.5.3 Utilisation de bases de données avec PDO ................................................................................ 17  2.5.4 Programmes utilisés ................................................................................................................... 19 

Travail effectué et difficultés rencontrées ......................................................................................... 19  3.1 Refonte de la base de données ......................................................................................................... 20  3.1.1 Works DB et ses problématiques ............................................................................................... 20  3.1.2 Cheminement de la refonte de la base de données .................................................................. 21  3.1.3 Nouvelle base de données sous MySQL ..................................................................................... 21  3.2 Le Framework (NATUREL MVC) ......................................................................................................... 24  3.2.1 Qu’est‐ce qu’un Framework ....................................................................................................... 24  3.2.2 Le modèle MVC (Modèles, Vues et Contrôleurs) ....................................................................... 24  3.2.3 Fonctionnement de NATUREL MVC ........................................................................................... 26  3.3 L’interface .......................................................................................................................................... 32  3.3.1 Les pseudos frames .................................................................................................................... 33  3.3.2 La sécurité et les droits utilisateurs............................................................................................ 33  3.3.3 Fonctionnement de l’interface ................................................................................................... 34  3.4 Formulaires ....................................................................................................................................... 35  3.4.1 Définition et méthodes .............................................................................................................. 35  3.4.2 Variables prédéfinies .................................................................................................................. 35 

Année Universitaire  2007 – 2008   

 

Page 6 sur 59                            


Application Intranet permettant la gestion d’un système d’information

3.4.3 Autocomplétion ......................................................................................................................... 36  3.4.4 Fonctionnement des formulaires ............................................................................................... 36  3.5 Créateur de requêtes ........................................................................................................................ 38  3.5.1 Fonctionnalités et mises en page ............................................................................................... 38  3.5.2  Classe requête_creator ............................................................................................................. 39  3.5.3 Création de la requête ............................................................................................................... 41  3.5.4 Affichage du résultat .................................................................................................................. 44  3.6 Créateur d’états ................................................................................................................................ 45  3.6.1 Définition .................................................................................................................................... 45  3.6.2 Utilité .......................................................................................................................................... 45  3.6.3 Création et modification d’états ................................................................................................ 46  3.6.4 Développement d’un pseudo langage ....................................................................................... 46  3.6.5 Fonctionnement du Parsage et de l’affichage ........................................................................... 47  3.7 Création de graphiques ..................................................................................................................... 49  3.7.1 JpGraph ...................................................................................................................................... 49  3.7.2 Utilisation de JpGraph ................................................................................................................ 49  4 

Résultats ............................................................................................................................................. 51 

5       Discussion ........................................................................................................................................... 56  6       Conclusion .......................................................................................................................................... 57   

   

Année Universitaire  2007 – 2008   

 

 

Page 7 sur 59                            


Application Intranet permettant la gestion d’un système d’information

Glossaire de mots  A  L’autocomplétion (complètement automatique) est une fonctionnalité permettant à l'utilisateur  de limiter la saisie d'informations avec son clavier. Fonction particulièrement utilisée sur certains  champs de formulaires, comme ceux des moteurs de recherche. 

  C   

Class, permet de définir un objet en décrivant ses propriétés et en implémentant ses méthodes. 

CSS  (acronyme  de  Cascading  Style  Sheets)  sont  des  feuilles  de  style  en  cascade  contenant  l'ensemble des règles de présentation s'appliquant aux différents blocs d'une page Web: elles donnent  au navigateur les instructions nécessaires à l'affichage des différents éléments d'une page. 

  G  GD (gif draw) est le nom d'une bibliothèque pour PHP servant à manipuler dynamiquement  plusieurs types d’images. 

  H  HTML, abréviation de l'anglais HyperText Markup Language, est le langage informatique utilisant  un système de balisage, permettant la création de pages Web. 

  J  Java est un langage de programmation orienté objet, indépendant de l’architecture. Il a été créé  par la société  Sun Microsystems. 

  M  MERISE est  une méthode de conception, de développement et de réalisation de projets  informatiques permettant de concevoir un système informatique. Née à la fin des années 70, elle est  désormais supplantée par le standard UML. MERISE a longtemps été la méthode la plus utilisée en  France. 

Année Universitaire  2007 – 2008   

 

Page 8 sur 59                            


Application Intranet permettant la gestion d’un système d’information

Mysql est un système de base de données en Open source (issu du monde du libre). C'est le plus  utilisé des systèmes de bases de données, notamment grâce au duo dynamique PHP/MySQL.  

  O    Objet : Un objet  est l'instanciation d'une classe au sens de la programmation orientée objet. Un  objet est une définition de caractéristiques propres à un élément. 

  P  PHP  (acronyme  récursif  pour  PHP:  Hypertext  Preprocessor),  est  un  langage  de  scripts  libres,  principalement utilisé pour produire des pages web dynamiques via un serveur HTTP (comme Apache).  PHP  est  un  langage  impératif  disposant  depuis  sa  version  5  de  fonctionnalités  telles  qu’une  Programmation Orientée Objet complète.  La  Programmation  Orientée  Objet  (POO)  est  une  technique  de  programmation  consistant  à  encapsuler dans un objet ses propriétés et les méthodes que l'on peut lui appliquer. Cette méthode est  opposée à la programmation procédurale. 

  S  SQL  (Structured  Query  Language)  ou  langage  structuré  de  requêtes,  est  un  pseudo‐langage  informatique (de type requête) standard et normalisé, destiné à interroger ou à manipuler une base de  données. 

  U    UML:  Unified  Modeling  Language,  langage  de  modélisation  objet  unifié.  Méthode  de  modélisation née de la fusion des 3 anciennes méthodes qui ont le plus influencé la modélisation objet  dans  les  années  90.  Issu  du  travail  d'un  large  consensus  d'experts  reconnus.  Il  est  utilisé  dans  les  entreprises pour modéliser les systèmes et applications à mettre en place. En quelques années, UML est  devenu un standard incontournable.   

W  Le  W3C (World  Wide  Web  Consortium),  est  un  consortium  fondé  en  octobre  1994  pour  promouvoir la compatibilité et recommander des technologies du Web.  

Année Universitaire  2007 – 2008   

 

Page 9 sur 59                            


Application Intranet permettant la gestion d’un système d’information

1 Introduction   

1.1 L’entreprise  Historique :  ‐1947 : Création de l’Entreprise par Georges CHARLON.  ‐1957 : Implantation à Sète et création des Transports LLIEDO et CHARLON.  ‐1970 : Jean‐Luc CHARLON (2° génération) rejoint la société.  ‐1980 : Création de la Société d’Exploitation des Transports Charlon.  ‐1991 : Achat des Transports Peysson.  ‐1992 : Création d’Environnement Transports Services.  ‐1994 : Certification ISO 9001 : 2000.  ‐1997 : Corinne et Christophe CHARLON (3°génération) s’investissent dans le groupe familial.  ‐2007 : Achat des transports PUECH par Peysson et certification ISO 9001 : 2000 de Peysson en cours.  Effectifs :  Effectif global de 130 personnes réparti sur les différents sites.  Moyens Matériels:  L’ensemble du parc est composé de 70 Véhicules Moteurs et 160 Semi‐remorques.  Infrastructures (en M2) :  Sète‐34 : 20.000 M² comprenant un parc, des bureaux, un atelier et un entrepôt de stockage.  Port St Louis du Rhône‐13 : 6.000 M² comprenant un parc et des bureaux.   Courcelles Les Lens‐62 : 7000M² comprenant un parc, des bureaux et un atelier.  Principaux Clients :  ‐Groupes pétroliers  ‐Sociétés viticoles  ‐Compagnies maritimes  ‐Sociétés de matériaux  ‐Transitaires  ‐ Etc… 

1.2 Présentation du projet  A l'heure actuelle, la société Transports Charlon possède un système d’information très rigoureux et  structuré grâce notamment à la Norme ISO 9001 : 2000. Or ce système d’information est implémenté  depuis maintenant  15 ans sur Works DB 4.5. Dès lors l’utilisateur se retrouve souvent noyé sous les  informations superflues et redondantes. Il existe des problèmes de mise à jour car les bases de données  ne sont pas interconnectées. Les utilisateurs sont dans l’impossibilité de pouvoir travailler en même 

Année Universitaire  2007 – 2008   

 

Page 10 sur 59                            


Application Intranet permettant la gestion d’un système d’information

temps sur ces bases de donnée ; de plus le Responsable Qualité est obligé de passer par de longs et  fastidieux calculs intermédiaires avant de pouvoir générer des graphiques.     L'enjeu de ce projet est de créer une application permettant de saisir, contrôler, visualiser  les données  dans une seule base de données. Mais aussi l’application devra permettre l’impression d’états et la  génération de graphiques.  Ce projet est destiné à être utilisé par des non informaticiens, il se devra  donc d’être simple.    C’est dans ce souci de simplifier l’accès à l’information qu’il nous a été demandé de travailler  sur  l’implémentation d’une plateforme de visualisation de données, facilitant l’accès à l’information et le  croisement des données.  Afin de comprendre la démarche que nous avons utilisée pour mener ce projet à son terme, notre  rapport se structure de la façon suivante :   Tout d'abord, dans une première partie je vous présente le travail d'étude et de recherche que j’ai   effectué, en commençant par définir le cahier des charges et les spécificités du sujet. Ensuite dans une  deuxième partie, j’explique comment j’ai développé l’application, puis dans une troisième partie je  décrie les résultats obtenus. Enfin, dans la dernière partie, je discuterai de la concordance des  résultats  par rapport aux objectifs initiaux. 

  2 Analyse  Dans cette partie sera détaillée l’analyse conceptuelle, qui m’a permis de mettre au point le cahier des  charges,  de  choisir  les  technologies  et  les  programmes  nécessaires  au  projet  dans  le  but  de  pouvoir  effectuer un développement serein et réfléchi.   Pour cela et  afin de  modéliser avec un  maximum de précision, d'exhaustivité,  mais aussi de simplicité  l'intégralité du système, j’ai eu en partie recours à la méthode UML.   

2.1 Données traitées  Les données que j’ai eu à traiter sont diverses et parfois techniques. La plupart sont des données  permettant de qualifier quelqu’un ou quelque chose. Des  dates de naissances, les diverses dates de  validités (FCOS, permis, extincteur…), mais aussi des données propres à la gestion: les enregistrements  de l’entreprises, les PV, les réclamations clients, ….  J’ai eu besoin de me familiariser avec tout le vocabulaire et  les termes propres au monde du transport  routier. Ce fut une chose simple grâce notamment au Responsable Qualité, qui a pris plusieurs heures à  m’expliquer tout ce « charabia ».  

 

Année Universitaire  2007 – 2008   

 

Page 11 sur 59                            


Application Intranet permettant la gestion d’un système d’information

2.2 Normes ISO 9001 : 2000 et audits  Les exigences à la norme ISO 9001 : 2000 sont relatives à quatre grands domaines :  1. Responsabilité de la Direction : exigences d'actes de la part de la Direction en tant que premier  acteur et permanent de la démarche.  2. Système Qualité : exigences administratives permettant la sauvegarde des acquis. Exigence de  prise en compte de la notion de système.  3. Processus : exigences relatives à l'identification et à la gestion des processus contribuant à la  satisfaction des parties intéressées.  4. Amélioration continue : exigences de mesure et enregistrement de la performance à tous les  niveaux utiles ainsi que d'engagement d'actions de progrès efficaces.  Il s’agit en fait de définir un niveau qualitatif que l’on devra atteindre à la fin de l’année. Pour cela  l’entreprise est auditée tous les ans et repasse la certification ISO tous les 4 ans. 

  Figure 2‐1 : Certification AFAQ à la norme ISO 9001 : 2000 

2.3 Cahier des charges    2.3.1  Objectifs    L’objectif du projet était d’implémenter une application permettant la restructuration de la base de  données de l’entreprise. Ceci afin de faciliter  le partage de l’information entre les différents services et  le croisement des données.  Au final, le projet est destiné à améliorer la qualité de la gestion de l’entreprise, afin de répondre au  mieux aux attentes du client et aux normes ISO. Il permet aussi de connaître l’état de l’entreprise en 

Année Universitaire  2007 – 2008   

 

Page 12 sur 59                            


Application Intranet permettant la gestion d’un système d’information

temps réel, ce qui donne la possibilité à chacun des services de réagir immédiatement. Enfin  l’application doit permettre à chaque personne de pouvoir accéder aux informations concernant son  service (Cela permet une gestion service par service).  Etant donné que l’entreprise Transports Charlon possède depuis 14 ans la norme ISO 9001/2000, le  projet devra lui aussi respecter une structuration de la Qualité (ISO).   

2.3.2 Cas d’utilisations  identification Utilisateur insertions de données propres au poste

Création de requête

modifications des données propres au poste

affichages des données propres au poste

affichages de graphiques Utilisateur

Modification du mot de passe personnel

identification administrateur gestion des infractions disques

création et impression d'états

Administrateur

Gestion des utilisateurs

afficher les logs

  Figure 2‐2 : Cas d’utilisations du logiciel   

Année Universitaire  2007 – 2008   

 

Page 13 sur 59                            


Application Intranet permettant la gestion d’un système d’information

Nous pouvons voir 2 types d’utilisateurs pour cette application :  ‐ ‐

Les Administrateurs qui ont tous les droits. Ils sont les seuls à pouvoir gérer les utilisateurs c'est‐ à‐dire en ajouter, modifier ou supprimer.   Les différents Postes  d’utilisateurs, sont définis par une fiche métier permettant de définir  leurs droits. 

Les différentes fonctionnalités de l’application sont :  ‐ ‐ ‐ ‐ ‐ ‐

L’insertion, l’édition et la suppression d’informations présentes dans la base de données.  La création et l’exécution de requêtes SQL à partir d’un formulaire permettant de faciliter leur  création et leur impression.  La génération d’états (sortes de Templates) qui seront complétés par les résultats des requêtes.  La création de graphiques.  La gestion d’utilisateurs et la spécification de droits (seulement pour les administrateurs)  L’affichage des logs  (seulement pour les administrateurs)   

L’interface est protégée par un mot de passe et régie par des droits spécifiques aux utilisateurs. 

2.4 Processus de développements  Dès le début du projet, j’ai dû m’intéresser de près  au fonctionnement de la norme ISO. Pour cela  j’ai eu à disposition le manuel Qualité de l’entreprise. Et par la suite, J’ai eu la chance de pouvoir  participer à un audit. Etant donné que mon programme concerne directement les exigences de  qualités de l’entreprise,  s’inscrivant directement dans les domaines de la Norme ISO 9001/2000.  Pour construire le projet mon attention se portera plus particulièrement sur la base de données et  les termes techniques du métier. Puis une fois que la nouvelle base de données sera validée, je  m’attaquerai à la création d’une interface sécurisée.  Ensuite il faudra créer une multitude de  formulaires pour rentrer les informations dans la base de données. Enfin, il me faudra implémenter  des outils comme :  ‐ 

La création de requêtes assistées 

‐ 

La création d’états 

‐   La création de graphiques  Enfin la dernière étape sera une étape de validation faite par l’utilisateur, qui se constituera de  critiques et demandes. Notons qu’une formation sera aussi  apportée à l’équipe d’administration,  afin d’utiliser le logiciel de façon correcte et optimale.   

 

Année Universitaire  2007 – 2008   

 

Page 14 sur 59                            


Application Intranet permettant la gestion d’un système d’information

2.5 Outils    2.5.1 Langage de programmation    Solutions possibles :  Plusieurs solutions se sont présentées :  ‐ ‐ ‐ ‐

Une application machine en Visual Basic, en C, Java, Etc.…  Une application Serveur en ASP, PHP, python, Perl, Ruby, Etc.…  L’utilisation d’une base de données relationnelle : MySQL, Oracle, Etc.…  L’utilisation d’une base de données telle qu’Access (ou d’autres produits y ressemblant). 

Solution Choisie :  La première solution fut vite écartée pour une utilisation réseau, car cette solution est trop gourmande  en ressources machine. Pour exemple un programme Java lancera une machine virtuelle pour chaque  utilisateur de l’application, ce qui pourrait faire chuter les performances du serveur ou même le rendre  instable.    La solution adoptée fut l’utilisation d’une application orientée serveur avec un langage orienté lui aussi  serveur. Dès lors j’avais le choix entre différents langages tel qu’ASP, PHP, python, Perl, Ruby, Etc.…   J’ai préféré choisir PHP, pour sa maturité, ses fonctionnalités et enfin parce que c’est un langage que je  maîtrise depuis déjà plusieurs années.     La base de données choisie est de type relationnel afin de permettre l’utilisation de requêtes SQL. Pour  le développement j’ai préféré déployer MySQL, mais par la suite une autre base de données pourra être  utilisée (voir partie sur la PDO).  Note sur Microsoft Access : Il m’a été proposé de développer l’application avec Access. Le problème est  qu'Access en tant que format de stockage de données n'est pas un SGBD client/serveur mais seulement  un SGBD fichier. Le trafic qu'il génère sur le réseau en utilisation réseau multiposte (tel est le cas dans  l’entreprise) peut fortement perturber ses performances. Les performances chutent rapidement lorsque  plusieurs utilisateurs sont connectés à la base de données. De plus si celle‐ci dépasse 10000 tuples, ses  performances ont tendance à s’effondrer.  

  2.5.2 Matériels et fonctionnement    Etant donné, que l’entreprise Transports Charlon possède plusieurs serveurs de capacité considérable,  je pourrai compter sur l’un d’entre eux pour héberger mon application. (Ou au pire des cas en installer  un supplémentaire). 

Année Universitaire  2007 – 2008   

 

Page 15 sur 59                            


Application Intranet permettant la gestion d’un système d’information

Je vais maintenant vous décrire succinctement le fonctionnement client ‐ serveur avec pour exemple  l’exécution d’un script PHP. 

  Figure 2‐3 : Dialogue client – serveur avec utilisation de PHP/MySQL  Lorsqu’un visiteur demande à consulter une page web, le navigateur envoie une requête http à un  serveur, qui va entamer un processus de traitement plus ou moins complexe :  Sur ce serveur on trouve Apache, logiciel apte à traiter les requêtes HTTP que vous envoyez lorsque vous  demandez une page web. Apache va donc chercher le fichier demandé dans son arborescence et  renvoie à votre navigateur une page HTML ou lance un traitement s’il s’agit d’une page PHP.  S’il s’agit d’un fichier PHP, le fichier est parsé ; c'est‐à‐dire que le code PHP est compilé puis exécuté. Si  ce code contient des requêtes vers une base de données par exemple MySQL,  PHP ouvre une  connexion avec MySQL pour  envoyer des requêtes SQL. La base de données exécute les requêtes et  renvoie les tuples au script PHP.    Le Parseur de PHP finit d’interpréter le code PHP pour le transformer entièrement en HTML. Une fois le

Année Universitaire  2007 – 2008   

 

Page 16 sur 59                            


Application Intranet permettant la gestion d’un système d’information

code entièrement traduit en HTML, ou tout autre langage lisible par le navigateur, Apache retourne une page au navigateur qui va pouvoir l’interpréter et l’afficher.

2.5.3 Utilisation de bases de données avec PDO    Il existe plusieurs méthodes pour utiliser une base de données avec PHP. Nous pouvons utiliser les  extensions natives dédiées à chaque type Base de données ( Mysql_*,Mysqli_*, oci8_*, … ).  L’application sera dès lors prisonnière d’un seul type de base de données et ne pourra utiliser que  certaines fonctionnalités développées   pour chaque base de données.  Pour remédier à ce problème les développeurs de PHP ont développé un outil appelé PDO (PHP Data  Object) utilisable depuis PHP 5.1, qui est entièrement tourné vers la programmation objet.  La PDO apporte un confort d’utilisation aux développeurs, car elle homogénéise les fonctionnalités des  différents SGBD. Si une fonctionnalité n’existe pas dans le moteur d’une base de données, alors PDO va  créer une des fonctions qui vont mimer ces fonctionnalités.    Les exécutions des requêtes PDO sont nettement plus rapides que les méthodes natives, car la  Bibliothèque de PDO est entièrement écrite en C.   PDO apporte un socle commun de traitement des requêtes SQL :  ‐ ‐ ‐ ‐ ‐

Connexion à la base de données par la création d’un objet PDO  Prépare la requête (application de fonctions de sécurités et formatage des données à traiter)  Exécute la requête  Traite le résultat  Destruction automatique de l’objet PDO 

De plus l’extension PDO permet d’améliorer la sécurité et la génération des requêtes SQL. Elle permet  de détecter les injections SQL et ainsi de les empêcher. Elle permet aussi « d’apostropher » (en tenant  compte des magic_quotes) les guillemets qui  peuvent empêcher l’éxécution de  certaines requêtes SQL. 

Année Universitaire  2007 – 2008   

 

Page 17 sur 59                            


Application Intranet permettant la gestion d’un système d’information

2 3

    PDO

  PHP 

PDO MySQL

PDO ORACLE 

MySQL PDO SQLite

PDO …

 Figure 2‐4 : Différentes étapes du fonctionnement de PDO    // function de formatage des données function formatage_sql($sql) { if(is_numeric($sql)) return $sql if (get_magic_quotes_gpc $sql = stripslashes($sql); return mysql_real_escape_string($sql); } //connection à la base de données et selection de la base $link = mysql_connect('localhost', 'root', ''); $db_selected = mysql_select_db('charlon', $link); // formatage de la requête et exécution $sql = formatage_sql("INSERT INTO etat (id_etat, nom_etat, contenu_etat) VALUES ('', $nom_etat, $contenu_etat)"); $req = mysql_query($sql);

Exemple de requête MySQL  classique  

// creation de l’objet PDO et selection du driver PDO (Etape 1 et 2) $db = new PDO("mysql:host=localhost; dbname=charlon","root");   // Préparation de la requête $stmt = $db->prepare("INSERT INTO etat (id_etat, nom_etat, contenu_etat) VALUES ('', :nom_etat, :contenu_etat)") ; // éxécution de la requête grâce au driver PDO Mysql (Etape 3) $result = $stmt->execute(array(':nom_etat' => $this->var[nom_etat], ':contenu_etat' => $this->var[contenu_etat));

Exemple de requête PDO MySQL 

Année Universitaire  2007 – 2008   

 

Page 18 sur 59                            


Application Intranet permettant la gestion d’un système d’information

Si l’on doit appliquer des vérifications de sécurité, l’exécution de la requête PDO se veut plus claire et  moins hasardeuse par rapport à la requête classique. De plus la préparation de la requête PDO  déclenche une multitude de traitements de vérifications. (Si nous avions dû ajouter ces vérifications à la  fonction ‘formatage_sql()’, il nous aurait fallu écrire plusieurs pages.)    En conclusion PDO est la solution ultime pour interroger vos bases de données. Il vous suffira d’utiliser  des requêtes compatibles SQL92, c'est‐à‐dire interprétables par n’importe quel SGBD, pour pouvoir  utiliser n’importe quelle base de données sans même changer une ligne de code. De plus cette  extension remporte un si grand succès, que le Groupe PHP parle de supprimer les méthodes classiques  d’accès aux bases de données au profit de PDO. 

  2.5.4 Programmes utilisés    Afin  de  pouvoir  développer  l’application  sur  ma  machine,  j’ai  dû  installer  une  plate‐forme  de  développement Web sous Windows. Le logiciel que j’ai choisi est WampServer2 concurrent d’EasyPHP  (qui  n’est  plus  réellement  développé).  WampServer2,  permet  de  développer  des  applications  Web  dynamiques à l'aide du serveur Apache2, du langage de scripts PHP et d'une base de données MySQL  sur une plateforme Windows. En somme, il émule les fonctionnalités d’un serveur sur un simple poste  de travail.  Pour programmer, j’ai utilisé le logiciel Zend Studio 5.5.1, qui est un environnement de développement  PHP. Ce logiciel est édité par ZEND, l’entreprise qui s’occupe de la maintenance et l’évolution de PHP.  Afin  de  visualiser  l’application,  j’ai  eu  besoin  d’un  navigateur  Internet.  FireFox2  m’a  semblé  le  plus  adapté,  car  respectant  au  mieux  les  normes  du  W3C  et  ainsi  facilitant  l’intégration  du  CSS  et  l’interprétation de tout autre langage client.  Lors de la création des uses cases et du diagramme des classes, j’ai eu recours au logiciel AMC Power.   Adobe  Photoshop  CS3  m’a  été  utile  pour  le  développement  de  la  partie  graphique  de  l’interface  de  l’application. 

  3 Travail effectué et difficultés rencontrées  Maintenant que j’ai  clairement défini le travail à effectuer, je vais vous détailler les différentes   fonctionnalités que j’ai développées : base de données, Framework, interface, formulaire, créateur de  requêtes, créateur d’états et graphiques.     

Année Universitaire  2007 – 2008   

 

Page 19 sur 59                            


Application Intranet permettant la gestion d’un système d’information

3.1 Refonte de la base de données     

3.1.1 Works DB et ses problématiques 

Ma première surprise fût de voir qu’une entreprise utilise encore un programme âgé de bientôt plus de  10 ans. Nous allons nous attarder sur la présentation de ce fameux programme nommé Works.  Microsoft Works 4.5, est une suite bureautique à la base payante mais le plus souvent offerte à l’achat  d’une licence Windows.  

  Figure 3‐1 : Illustration de Microsoft Works 4.5    Cette suite comprend:  ‐ ‐ ‐ ‐

un tableur capable de créer des feuilles de calculs au format d'Excel  une base de données   un agenda   un carnet d'adresses. 

  Figure 3‐2 : Capture d’écran de la base de données sous Works DB 

Année Universitaire  2007 – 2008   

 

Page 20 sur 59                            


Application Intranet permettant la gestion d’un système d’information

Le problème des bases de données sous Works DB  c’est qu’elles ne sont pas des bases de données  relationnelles. Ce problème rend toutes interactions difficiles, voir impossibles. Ceci oblige l’utilisateur à  créer de multiples fichiers, pour pouvoir posséder une base de données correcte. Dès lors cette  organisation va poser une foultitude de problèmes :  ‐ ‐ ‐ ‐ ‐ ‐ ‐

Croisement des données impossible (sauf en créant des fichiers intermédiaires pour représenter  les associations).  redondance des données.  Problèmes de mises à jour des données.  Contraintes d’intégrités non respectées ou inexistantes  Risques de contamination de la base de données par des données incorrectes, car il n’existe pas  de moteur de vérification.  Impossibilité de faire marcher le programme en parallèle sur diverses machines.  Modèle conceptuel inexistant ou peu utilisé. 

Comme vous pouvez vous rendre compte l’outil Works DB est totalement dépassé. Il peut poser  de gros  problèmes et même se montrer dangereux pour le système d’information, car il ne contrôle pas les  données.  C’est pour cela qu’il fallait y remédier tout de suite afin d’avoir un système d’information plus  performant !       

3.1.2 Cheminement de la refonte de la base de données 

  Pour arriver à refondre cette base de données,  j’ai dû d’abord comprendre l’utilité de chaque table et  chaque attribut qui la composent. Puis déterminer les liens qu’il pouvait y avoir entre toutes les tables  et tous les attributs, afin de pouvoir déterminer les clefs primaires et étrangères ainsi que les  associations.   Une fois ce travail effectué en étroite collaboration avec le Responsable Qualité de l’entreprise, j’ai pu  m’atteler à ma création du modèle MCD. Notons que cette phase de création du modèle MCD est  passée par différentes phases de validations, afin d’avoir une base qui correspond aux attentes du client   mais aussi qui soit techniquement correcte. 

  3.1.3 Nouvelle base de données sous MySQL   Une fois ce travail effectué, nous sommes enfin arrivés  d’une base de données opaque à une nouvelle  base de données Structurée et performante.  Nous pouvons ainsi dégager clairement les différentes entités telles que : Personne, Véhicule, PV,  Enregistrement,… . Nous pouvons distinguer les clefs primaires qui caractérisent les différentes tables.  Mais le plus intéressant c’est que nous pouvons voir les liens entre les diverses bases de données et que 

Année Universitaire  2007 – 2008   

 

Page 21 sur 59                            


Application Intranet permettant la gestion d’un système d’information

nous possédons un support, qui nous permet de faire évoluer la base de données d’un point de vue  logique.   Nous  noterons que j’ai suvi un mode de développement de type Merise, mais que je ne l’ai pas appliqué  en permanance. Par exemple la table enregistrement possède plusieurs champs  « suivi*_enregistrement ». Dans un dévelopement Merise classique il aurrait fallu créer une nouvelle  table « suivi_enregistrement » en association avec la « table enregistrement ». Ce genre d’entorse ne  met en rien la structure de la base de données en danger et me permet par la suite de gagner un temps  de programmation considérable.  Notons que certainnes valeurs ne sont plus directement stockées dans la base de données comme par  exemple l’âge des personnes, les jours restant de certains documents administratifs. Elles seront  calculées à partir des valeurs déjà inscrites dans la base de données (Ex : nous utiliseront la date de  naissance pour calculer l’âge d’une personne). 

Année Universitaire  2007 – 2008   

 

Page 22 sur 59                            


Application Intranet permettant la gestion d’un système d’information

accidentCirculation

AccidentMarchandise code_accident_marchandise ordre_enregistrement date_accident_marchandise motcle_accident_marchandise lieu_accident_marchandise rappel_accident_marchandise ouverture_dossier_accident_marchandise donneur_ordre_accident_marchandise reserves_accident_marchandise causes_accident_marchandise prejudice_accident_marchandise rbt_assurance_accident_marchandise date_encaissement_accident_marchandise responsabilité_accident_marchandise observations_accident_marchandise action_accident_marchandise declaration_accident_marchandise moteur_accident_marchandise semi_accident_marchandise ref_assurance_accident_marchandise

varchar(256) <pk> vachar(256) <fk> date varchar(256) varchar(256) text date varchar(256) varchar(256) text decimal(10,4) decimal(10,4) date varchar(3) text text text varchar(256) varchar(256) varchar(256)

FK_REFERENCE_46

code_accident_circulation ordre_enregistrement date_accident_circulation motcle_accident_circulation rappel_accident_circulation circonstances_charlon_accident_circulation croix_charlon_accident_circulation circonstance_adversaire_accident_circulation croix_adversaire_accident_circulation responsabilite_accident_circulation cout_accident_circulation actions_accident_circulation causes_accident_circulation degats_charlon_accident_circulation materiel_charlon_accident_circulation lieu_accident_accident_circulation contre_qui_accident_circulation imat_adversaire_accident_circulation declaration_accident_circulation ref_assurance_accident_circulation cout_encaisement_accident_circulation date_encaissement_accident_circulation objet_encaissement_accident_circulation

varchar(256) <pk> vachar(256) <fk> date varchar(256) text text varchar(256) text varchar(256) varchar(3) decimal(10,4) text text varchar(256) text varchar(256) text varchar(256) text varchar(256) decimal(10,4) date varchar(256)

Enregistrement ordre_enregistrement dossier_enregistrement date_enregistrement code_site_enregistrement secteur_enregistrement concerne_enregistrement processus_enregistrement theme_enregistrement motif_enregistrement salarie_enregistrement materiel_enregistrement responsable_service_enregistrement constat_charlon_enregistrement facture_conforme_enregistrement correspondance_enregistrement correspondance_suite_enregistrement réaction_enregistrement proposition_enregistrement indicateur_enregistrement action_corr_enregistrement action_prev_enregistrement visa_verif_enregistrement act_clos_le_enregistrement reclamant_enregistrement Adresse_enregistrement Adresse2_enregistrement CP_enregistrement Ville_enregistrement telephone_enregistrement fax_enregistrement interlocuteur_enregistrement email_enregistrement position_charlon_enregistrement position_autre_enregistrement id_personne_enregistrement suivi1_enregistrement suivi2_enregistrement suivi3_enregistrement suivi4_enregistrement suivi5_enregistrement suivi6_enregistrement suivi7_enregistrement suivi8_enregistrement suivi9_enregistrement suivi10_enregistrement

vachar(256) <pk> varchar(256) date int(11) <fk2> varchar(256) varchar(256) varchar(256) varchar(256) varchar(256) varchar(256) varchar(256) varchar(256) text varchar(3) text text varchar(256) varchar(256) varchar(256) varchar(256) varchar(256) varchar(256) varchar(256) varchar(256) varchar(256) varchar(256) int(5) varchar(256) int(20) int(20) varchar(256) varchar(256) varchar(256) varchar(256) varchar(256) <fk1> text text text text text text text text text text

FK_REFERENCE_48

Flexible

refer_flexible imat_vehicule code_site_flexible validite_flexible HS_flexible date_mise_service_flexible longeur_flexible etat_flexible date_destruction_flexible remplace_flexible personne1_controle1_flexible personne2_controle1_flexible date_controle1_flexible fiche_remplie_controle1_flexible decision_controle1_flexible personne1_controle2_flexible personne2_controle2_flexible FK_REFERENCE_11 date_controle2_flexible fiche_remplie_controle2_flexible decision_controle2_flexible personne1_controle3_flexible personne2_controle3_flexible date_controle3_flexible fiche_remplie_controle3_flexible decision_controle3_flexible personne1_controle4_flexible personne2_controle4_flexible date_controle4_flexible fiche_remplie_controle4_flexible decision_controle4_flexible personne1_controle5_flexible personne2_controle5_flexible date_controle5_flexible fiche_remplie_controle5_flexible decision_controle5_flexible personne1_controle6_flexible personne2_controle6_flexible date_controle6_flexible fiche_remplie_controle6_flexible decision_controle6_flexible

varchar(256) <pk> varchar(256) <fk2> int(11) date varchar(3) date decimal(10,2) varchar(256) date varchar(256) <fk1> varchar(256) varchar(256) date varchar(3) text varchar(256) varchar(256) date varchar(3) text varchar(256) varchar(256) date varchar(3) text varchar(256) varchar(256) date varchar(3) text varchar(256) varchar(256) date varchar(3) text varchar(256) varchar(256) date varchar(3) text

FK_REFERENCE_49 FK_REFERENCE_55 FK_REFERENCE_25

Personne

id_personne nom_personne prenom_personne date_entree Site : 1 date_sortie_personne code_site int(11) <pk> FK_REFERENCE_51 secu_personne nom_site varchar(256) type_personne secteur_activite place_num_personne mobile_prof Formation badge carte_gasol_personne int(11) <pk> id_formation num_chauff id_personne int(11) <fk> date_naiss heures previsionnelles_formation varchar(256) nationnalite cout_previsionnel_formation decimal(10,4) email_personne type_formation varchar(256) FK_REFERENCE_16 diplome date_formation date date_control_vehicule heures_reels_formation int(10) Maj_livret count_reel_formation decimal(10,4) code_site_personne organisme_financement_formation varchar(256) observations_personne organisme_participation_formation decimal(10,4) observations_EPI observations_formation text gants_hydro_plus gants_hydro gants_plus ArretTravail gants int(11) <pk> id_arret chaussure_plus id_personne int(11) <fk> chaussure FK_REFERENCE_15 date_arret date casque_lun_masque reprise_arret date boudrier ordre_arret varchar(256) taille_pointure type_arret varchar(256) observations_adresse_personne2 causes_arret text ville_personne2 informations_arret text CP_personne2 equipe_securite_arret varchar(3) adr_personne2 secteur_accident_arret varchar(256) observations_adresse_personne1 deces_arret varchar(3) ville_personne1 CP_personne1 adr_personne1 num_telephone_personne1 Gasol observations_telephone_personne1 int(11) <pk> id_gasol observations_telephone_personne2 id_personne int(11) <fk> num_telephone_personne2 FK_REFERENCE_14 num_gasol int(4) validite_FCOS litrage int(11) num_FCOS Delta int(11) observations_CACES denomination_CACES validite_CACES num_CACES validite_citerne validite_base plomb_valise CarteAcces verif_valise_adr int(11) <pk> id_carte_acces num_valise_adr id_personne int(11) <fk> FK_REFERENCE_3 num_MD nom_carte_acces varchar(256 validite_petrol validite_carte_acces date num_permis num_carte_acces varchar(256) validite_permis delivre_date_permis delivre_par_permis EC_date num_carte_conducteur date_emission_carte_conducteur date_expiration_carte_conducteur

ReparationChronotach num_fiche_reparation_chrono imat_vehicule date_reparation_chrono par_reparation_chrono

varchar(256) <pk> varchar(256) <fk> date varchar(256) FK_REFERENCE_29 Vehicule

imat_vehicule genre_vehicule int(11) <pk> id_APAVE crit1_vehicule imat_vehicule varchar(256) <fk> crit2_vehicule date_controle_APAVE date marque_vehicule observation_APAVE text attention_vehicule audit_vehicule logo_vehicule FK_REFERENCE_30 place_num_vehicule date_sortie_vehicule date_mise en service_vehicule validite_visitetech_vehicule date_valide_extincteur_cabine_vehicule suspension_pneumatique_vehicule TVR1 assurance_vehicule FK_REFERENCE_43 double_cle_vehicule Visitetech code_site_vehicule int(11) <pk> id_visite_tech id_personne imat_vehicule varchar(256) <fk> validite_manometre_vehicule date_visite_tech date endoscope_vehicule premier_coup_visite_tech varchar(3) sabre_vehicule accepte_visite_tech varchar(3) moy_conso_vehicule sursis_visite_tech varchar(3) date_conso_vehicule refuse_visite_tech varchar(3) validite_limiteur_vehicule cout_visite_tech decimal(10,4) observations_limiteur_vehicule observation_visite_tech text validite_extincteurADR_vehicule validite_visite_tech date num_carte_grise md_visite_tech varchar(3) date_mise_en_circulation date_convocation_visite_tech date date_carte_grise heure_convocation_visite varchar(256) date_precedente_carte_grise lieu_convocation_visite_tech varchar(256) imat_precedente_vehicule num_licence_ce validite_licence_ce numerique_chronotach validite_chronotach FK_REFERENCE_32 date_releve_chronotach date_rdv_chronotech PV APAVE

id_PV ordre_enregistrement imat_vehicule imat_semi ouverture_PV date_PV secteur_PV type_PV motif_PV motclef_PV cause_PV Action_PV declaration_PV controleur_PV charge_PV suite_qualité_PV observations_PV suivi_PV tribunal_PV honoraire_texte_PV

<pk> int(11) vachar(256) <fk> varchar(256) varchar(256) date date varchar(256) varchar(256) varchar(256) varchar(256) varchar(256) varchar(256) varchar(256) varchar(256) varchar(3) varchar(256) text text text text

varchar(256) <pk> varchar(256) varchar(256) varchar(256) varchar(256) text date varchar(256) int(10) date date date date varchar(3) int(25) varchar(256) date int(11) <fk1> int(11) <fk2> date int(20) int(20) decimal date date text date varchar(256) date date date varchar(256) int(20) date varchar(3) date date date

FK_REFERENCE_54

Site : 2 code_site int(11) <pk> nom_site varchar(256) FK_REFERENCE_27

int(11) <pk> varchar(256) varchar(256) FK_REFERENCE_34 date date SuiviPneumatique int(35) FK_REFERENCE_41 int(11) <pk> id_suivi_pneumatique varchar(256) id_personne int(11) <fk2> varchar(256) imat_vehicule varchar(256) <fk1> int(11) exercice_suivi_pneumatique int(4) int(10) panne_suivi_pneumatique varchar(3) int(3) FK_REFERENCE_42 date_suivi_pneumatique date ControleCiterne varchar(3) site_suivi_pneumatique varchar(256) int(11) int(11) <pk> id_controle_citerne lieu_suivi_pneumatique varchar(256) date imat_vehicule varchar(256) <fk> operation_suivi_pneumatique varchar(256) varchar(256) certificat_epreuve varchar(256) cout_suivi_pneumatique decimal(10,4) varchar(256) certificat_jaugage varchar(256) ref_intervenant_suivi_pneumatique varchar(256) varchar(256) nb_compartiments_jaugage int(2) num_fiche_inter_euromaster varchar(256) date validite_jaugage date bon_livraison_euromaster varchar(256) date cout_prestation_jaugage decimal(10,4) facture_euromaster decimal(10,4) int(11) <fk> observations_jaugage text date_euromaster varchar(256) text validite_hydrolique date observations_suivi_pneumatique text text validite_etancheite date date cout_prestation_etancheite decimal(10,4) date date date date Type date date id_type int(11) <pk> InfractionDisque requete date nom_type varchar(256) exercice_infraction_disque int(4) <pk> varchar(256) int(11) <pk> id_requete id_personne int(11) <pk,fk> text table_liste text mois1_infraction_disque int(3) varchar(256) type_requete varchar(256) mois2_infraction_disque int(3) FK_REFERENCE_39 int(5) nom_requete varchar(256) mois3_infraction_disque int(3) varchar(256) condition1 varchar(256) log mois4_infraction_disque int(3) text condition2 varchar(256) mois5_infraction_disque int(3) varchar(256) condition3 varchar(256) int(11) <pk> id_log mois6_infraction_disque int(3) int(5) condition4 varchar(256) date_log datetime mois7_infraction_disque int(3) varchar(256) condition5 varchar(256) nom_log varchar(256) mois8_infraction_disque int(3) int(10) attribut1 varchar(256) type_log text mois9_infraction_disque int(3) text attribut2 varchar(256) mois10_infraction_disque int(3) text attribut3 varchar(256) mois11_infraction_disque int(3) int(10) attribut4 varchar(256) mois12_infraction_disque int(3) date Diplome attribut5 varchar(256) varchar(256) comparaison1 varchar(256) id_diplome int(11) <pk> text comparaison2 varchar(256) nom_diplome varchar(256) varchar(256) comparaison3 varchar(256) utilisateur date comparaison4 varchar(256) varchar(256) <pk> id_utilisateur int(11) comparaison5 varchar(256) date login varchar(256) element_comparaison1 varchar(256) Secteur date passe varchar(256) element_comparaison2 varchar(256) id_secteur int(11) <pk> varchar(256) statut varchar(256) element_comparaison3 varchar(256) nom_secteur varchar(256) date bloc_notes text element_comparaison4 varchar(256) varchar(256) nom varchar(256) element_comparaison5 varchar(256) varchar(256) prenom varchar(256) date int date ordre_attributs etat date varchar(256) type_ordre_attributs varchar(256) <pk> int(11) <pk> id_etat date liste_ordre_attributs text nom_etat varchar(256) varchar(256) type_etat varchar(256) date contenu_etat text date

 Figure 3‐3 : Modèle relationnel des données 

Année Universitaire  2007 – 2008   

 

Page 23 sur 59                            


Application Intranet permettant la gestion d’un système d’information

3.2 Le Framework (NATUREL MVC)  Le fait de développer un Framework, me fut une évidence dès le début du projet.  Car l’architecture  d’un tel cadre de travail permet de sécuriser et structurer son application. Sachant que la sécurité et la  structuration sont les principales faiblesses de PHP, le Framework permet tout simplement de les  gommer.  J’ai décidé de nommer mon Framework NATUREL MVC, NATUREL est un jeu d’anagramme de mon  prénom et MVC car il utilise une architecture MVC.    

3.2.1 Qu’est‐ce qu’un Framework    Nous allons déjà commencer par nous intéresser à la signification du mot Framework. La traduction  littérale de ce mot est : cadre de travail.  En fait à la base un Framework est une idée abstraite, d’organisation des données et des processus  d’une application. Il s’agit de  préparer une structuration de données qui devra soutenir une application.  Cette structuration  ne constitue en rien le programme développé mais sera le moteur même de celui‐ci.  Si l’on prend tel quel le Framework, celui‐ci pourra être utilisé pour d’autres projets n’ayant aucun point  commun au programme développé.  L’utilisation d’un Framework permet d’éviter la répétition de lignes de codes, de cloisonner les  différentes parties du programme et de mettre en place une architecture solide.  Ce type de développement accélère ainsi l’implémentation d’une application et permet aussi  d’en  assurer une meilleure maintenance.   Un  Framework peut être vu comme une sorte de boîte noire, qui analyse une requête d’entrée pour  fournir une solution.  

Question ? 

Framework

Réponse ! 

Figure 3‐4 : Vulgarisation du fonctionnement d’un Framework Notons que, le développement de ce genre d’architecture implique une longue réflexion avant d’arriver  à un résultat probant et efficace.   

3.2.2 Le modèle MVC (Modèles, Vues et Contrôleurs)    Tout au long du cycle de vie de l'application, un code classique devient impossible à maintenir car le  client continue de demander des modifications, qui seront codées à plusieurs endroits du programme.  C’est pour cela que j’ai préféré utiliser un modèle MVC appliqué au Framework.  Il s’agit de diviser le code en 3 couches logiques : Modèles, vues et contrôleurs. 

Année Universitaire  2007 – 2008   

 

Page 24 sur 59                            


Application Intranet permettant la gestion d’un système d’information

Retourne données   Modèles 

Vues 

Interroge

Récupère 

Sélectionne  Actions  utilisateur Contrôleurs 

  Figure 3‐5 : Fonctionnement du modèle MVC  ‐

‐ ‐

Modèles ou Métiers : Ce sont en général des bibliothèques de fonctions spécialisées, et  destinées uniquement à l’application développée. Par exemple, ils peuvent se connecter  à une  base de données pour tester des données, en sélectionner ou les modifier.  Les Vues contiennent des morceaux de l'application qui seront affichées  à l'utilisateur. On peut  assister à ce niveau à l’utilisation d’un moteur de Templates.  Les Contrôleurs permettent de sélectionner les vues et de contrôler les données à l’aide des  modèles, afin de s'assurer que les informations soient correctement  affichées. Ils sont en  quelque sorte les « dirigeants » de l’application et sont spécialisés pour une seule et unique  action.  

Le plus grand avantage de l'utilisation de MVC consiste à séparer complètement les données et les  règles qui les gèrent.  Le Framework que j’ai  développé, en plus d’être orienté MVC, utilise une fonctionnalité  supplémentaire : Le FrontController qui se traduit en français par « Contrôleur principal ». 

Année Universitaire  2007 – 2008   

 

Page 25 sur 59                            


Application Intranet permettant la gestion d’un système d’information

HTTP requête 

1

HTTP Réponse 

Front Controller  Gère

Connexion

Charge 

3

2

Sélectionne Librairies  externes

MySQL 

Contrôleur  1 

Contrôleur  2

Contrôleur  3

Utilise Gestion  des  droits 

Métier 1 

Métier 2

Sélectionne 

4  4 Métier 3

Vue  1 Utilise 

Vue  2  

Figure 3‐6 : Modèle MVC avec l’utilisation d’un Front Controller  Le Front Controller, se comporte comme une sorte de routeur,  car toutes les actions passeront  obligatoirement par lui.   Ainsi la première étape représente la requête envoyée par le navigateur  du client.  Dès lors le Front  Controller va se connecter à la base de données, charger tous les fichiers et librairies nécessaires au  fonctionnement de l’application. La troisième étape consiste à sélectionner le contrôleur propre à  l’action demandée, qui utilisera les métiers et sélectionnera les vues à utiliser.  Enfin une fois la page construite, la page est retournée au client.     Notons, que si nous essayons d’accéder directement à une vue, la page obtenue sera inexploitable, car  elle ne possèdera aucune donnée significative (elle n’a  aucune connexion directe à la base de données).  En gros, le Front Controller est très pratique car il facilite considérablement la gestion et la sécurité de   l’application. Le Front Controller sera notre bouclier de sécurité. 

  3.2.3 Fonctionnement de NATUREL MVC     Après avoir vu le fonctionnement général du Framework couplé au modèle MVC, nous allons voir  comment Fonctionne Le  NATUREL MVC.  NATUREL MVC n’est pas entièrement compatible MVC  mais s’en approche énormément. La seule  différence c’est que le Front Controller et non le Contrôleur choisit  la vue. J’ai dû me résoudre à cette  méthode à cause de l’utilisation des pseudo‐frames (Voir plus loin pour les explications sur les pseudos  frames).   De plus certaines vues utilisent des méthodes qui pourraient être externalisées vers les métiers.   Année Universitaire  2007 – 2008   

 

Page 26 sur 59                            


Application Intranet permettant la gestion d’un système d’information

A part ces quelques problèmes le Framework NATUREL MVC est entièrement tourné vers le modèle  MVC. 

  Figure 3‐7 : Arborescence de l’application   Vous pouvez voir le dossier Config, qui contient toutes les constantes et les chemins d’accès. Le dossier  Docs quant à lui contient tous les fichiers et les scans de l’utilisateur. Userfiles sont en fait les images  utilisées par l’éditeur de texte FCKeditor (voir partie sur les états pour plus d’informations sur  FCKeditor).  Puis nous arrivons au dossier le plus conséquent : libs. Ce dossier contient, le Front  controller, la connexion à la base de données, les classes,  les contrôleurs, les templates (vues, images et  CSS), les librairies externes et les sources JavaScripts.  Comme vous pouvez le voir, j’ai adopté un préfixe spécifique pour chaque type de fichier :  ‐ ‐ ‐

Les classes seront préfixées de cl. (exemple cl.formulaire.php)  Les contrôleurs quant à eux porteront co. (exemple co.controller.php)  Les templates utiliseront tp. (exemple tp.createur_requete.php) 

Ce système d’appellation permet de connaître clairement et à tout moment le type de fichier que l’on  traite. 

Année Universitaire  2007 – 2008   

 

Page 27 sur 59                            


Application Intranet permettant la gestion d’un système d’information

Nous allons vous présenter un extrait d’un fichier « vue » (tp.ajouter_apave.php). Nous ne nous  attarderons  pas dessus car vous verrez qu’il ne s’agit que de code HTML mélangé au PHP  < ?php if ($_POST[envoyer] == 'Ajouter') { $front_controller = new FrontController('co','apave',$_POST); } ?> <p><strong>Ajouter un APAVE</strong></p> <form name="form1" method="post" action="">

… <?php Cl_Formulaire::champs_autocompletion('imat_vehicule','Véhicule','vehicule',$_ POST['imat_vehicule'],1); ?> </p> <p>Date controle APAVE <input name="date_controle_apave" type="text" id="date_controle_apave" value="<?php echo $_POST['date_controle_apave']; ?>" size="10" maxlength="10" />

… <input type="submit" name="envoyer" id="Ajouter" value="Ajouter" /> </p> </form>

Extrait de code d’un fichier « vue »  Nous allons maintenant nous intéresser au diagramme des classes de NATUREL Framework. Et plus  exactement celui des classes et des contrôleurs.  

Année Universitaire  2007 – 2008   

 

Page 28 sur 59                            


Application Intranet permettant la gestion d’un système d’information

Controller {abstract} tp.controller.php

# erreur : char # var : indefini + + + + +

__construct () legitime () action () defaut () affiche_erreur () : null

FrontController + var : indefini + co : char + type : char + __construct ()

Co_accidentmarchandise Co_Personne

+ + + +

+ + + +

__construct () legitime () : boolean action () : null : null defaut ()

__construct () : boolean legitime () : null action () : null defaut ()

Cl_personne Cl_accidentmarchandise + nom_prenom_existe () + nom_prenom2id_personne () + id_personne2nom_prenom ()

+ accidentmarchandise_existe ()

  

  Figure 3‐8 : Extrait du diagramme des classes concernant le modèle MVC  Comme vous pouvez le voir, le diagramme des classes est vraiment très simple. Mais pourtant derrière  cette simplicité se cache une puissance toute autre.  J’ai préféré vous montrer seulement un extrait du diagramme des classes car il existe plus d’une  trentaine de contrôleurs, cela aurait inutilement chargé le rapport.  Tous les contrôleurs spécialisés héritent d’une seule et unique classe nommée Controller, qui est une  classe abstraite. Cette classe abstraite permet de définir un moule pour définir un objet de type  Controller spécialisé.  Elle possède 2 attributs qui seront :    ‐ ‐

$erreur : cette variable contient le code ou le texte de l’erreur retournée par la méthode  legitime()  .  $var : à cet endroit sera stocké l’ensemble des données à tester, elles seront la plupart du temps  retournées sous forme de tableaux, mais peuvent aussi prendre la forme de variables ou même  d’objets. 

   

Année Universitaire  2007 – 2008   

 

Page 29 sur 59                            


Application Intranet permettant la gestion d’un système d’information

Elle possède aussi  4 méthodes  dont 3 abstraites:  ‐

‐ ‐

Legitime()  (abstraite) : cette opération permet de déterminer si les données testées sont  légitimes, c'est‐à‐dire si elles sont correctes. Par exemple nous retrouverons ici tous les tests de   validation des formulaires (champs vide, données numériques, etc.…).  Action()(abstraite) : C’est l’action, pour laquelle le contrôleur existe (exemple Insérer ou  Modifier une personne dans la base de données).  Defaut()(abstraite) : méthode qui permet d’afficher le message d’erreur.  Dans ce cas elle  utilisera le plus souvent la méthode affiche_erreur() plus riche. (Car elle utilise le fichier  tp.controller.php pour afficher l’erreur). Mais cette opération est parfois l’anti‐Action.  Si on le  lui demande, elle peut aussi supprimer des tuples dans la base de données. 

Donc, pour qu’un objet soit un contrôleur il doit hériter de la classe Controller et remplacer les 3  fonctions  abstraites par ses comportements spécifiques. Un contrôleur peut aussi posséder de zéro à  plusieurs métiers (exemple : CL_personne, CL_accidentmarchandise), qui lui permettront de l’assister  dans l’exécution de ses méthodes.     Mais il ne suffit pas de posséder des contrôleurs, il faut aussi posséder un horloger pour contrôler tout   le système ; C’est le Front Controller.  Voici les caractéristiques du Front Controller, 3 variables et un constructeur :  ‐ ‐

$var : stock temporairement les variables à tester, avant de les envoyer au contrôleur  sélectionné.  $type : Permet de définir le comportement du Front Controller. Soit il charge un contrôleur soit  il charge une vue. (c’est à cause de cette variable que NATUREL MVC n’est pas totalement  orienté MVC)  $co : dans cette variable, l’on transmet le nom du contrôleur ou de la vue à charger. 

Nous allons maintenant nous attarder sur le fonctionnement en détail  de la méthode __construct(), qui  permet de sélectionner les vues et les contrôleurs.  // Affichage de la page APAVE et prise d’informations grâce à la variable globale $_REQUEST $front_controller = new FrontController('', 'apave',$_REQUEST); // Demande un contrôle de type APAVE aux données venant de la variable globale $_POST $front_controller = new FrontController('co','apave',$_POST);

  Figure 3‐9 : Différents modes d’appels du Front Controller  Il existe deux façons de provoquer son déclanchement : la première c’est demander le déclanchement  d’une action de contrôle. La seconde c’est  demander l’affichage d’une page.  Intéressons nous maintenant à l’algorithme qui permet d’interpréter mes différents modes d’appels de  la classe Front Controller.  

Année Universitaire  2007 – 2008   

 

Page 30 sur 59                            


Application Intranet permettant la gestion d’un système d’information

  Inclusion des bibliothèques et de la connexion à la base de données    Si On demande un contrôleur      Si Le fichier contrôleur existe        On crée un objet de contrôle ($controller = new $co_classe($this‐>var);        SI  $controller‐>legitime() = VRAI                $controller‐>action();                SINON                 $controller‐>defaut();    SINON        Arrêt du script et affichage d’une exception    SINON SI On demande l’affichage d’un fichier Template    On détermine le chemin de la page              Si Le fichier Template existe        On affiche le fichier Template            SINON        Arrêt du script et affichage d’une exception          SINON      Arrêt du script et affichage d’une exception, si aucune action n’est demandée au Front    Controller.      Donc le Front Controller est l’épine dorsale de notre application, il se doit de posséder un  comportement simple et efficace, étant donné qu’il sera utilisé en permanence.   

     

Année Universitaire  2007 – 2008   

 

Page 31 sur 59                            


Application Intranet permettant la gestion d’un système d’information

3.3 L’interface  La présentation graphique de l’application est découpée en 3 parties :   ‐ ‐ ‐

le haut de page contenant le nom de notre application et un lien direct vers la page d’accueil  Une zone de traitements, qui varie selon les actions demandées. C’est dans cette zone que se  passent réellement tous les traitements.  le pied de page comprenant les droits d’auteurs.   

Après avoir créé ce squelette, j’ai travaillé et fait des tests pour trouver les couleurs les plus appropriées  pour l’interface. Le choix retenu se portait sur des couleurs de bases, simples et non agressives, idéales  d’un point de vue IHM (Interface Homme Machine) et approuvées par le Responsable Qualité. 

Haut de page  Tp.Header.php 

Zone de traitements       Tp.*.php 

Pied de page  Tp.Footer.php    Figure 3‐10 : Mise en page de l’interface graphique avec système de pseudo frames  Après avoir effectué toute la phase de conception qui consiste à l’élaboration d’une charte graphique  basique et de la mise en place d’un fichier CSS basique qui m’a permis de réaliser des effets de styles  (couleur des liens, liens cliquables, etc...) agréables. Par la suite je me suis attelé à la mise en place du  Framework au sein de l’interface.  Note sur la validation du W3C : j’ai essayé de rendre l’application le plus valide possible, mais cela ne fait  pas partie des priorités du développement car c’est une application intranet et parce que la durée de  mon stage est trop courte ! La seule chose qui m’importe c’est que l’interface s’affiche correctement  dans Internet Explorer et FireFox. 

Année Universitaire  2007 – 2008   

 

Page 32 sur 59                            


Application Intranet permettant la gestion d’un système d’information

 3.3.1 Les pseudos frames 

  Au niveau de la programmation de cette interface, j’ai décidé d’utiliser un système de pseudo‐frames  qui se substitue aux frames HTML. Le but principal d'une mise en page en pseudo‐frames est d’assurer  une intégrité totale de l’ensemble du site, grâce à la facilité de maintenance qu’elles apportent.  Une page unique est créée pour chaque partie graphique de notre interface. Exemple, pour le haut de  page, j’ai un fichier tp.header.php qui est unique et un fichier tp.footer.php pour le pied de page. Il est  appelé pour les différentes pages de l’application et grâce à une variable passée par URL, il détermine la  page à afficher dans la zone de traitements. Ceci implique, que lorsqu’on veut apporter une  modification au haut ou pied de page, un seul fichier doit être modifié.  Ces « pseudo‐frames » sont gérées à partir du fichier tp.index.php qui inclura les pages de façon  dynamique grâce à la classe cl.pseudo_frames.php.   

3.3.2 La sécurité et les droits utilisateurs    L’interface du programme est entièrement sécurisée, car elle demande une identification pour pouvoir  accéder à n’importe quelle fonctionnalité. Une fois l’identification effectuée, un objet Utilisateur est  créé et stocké sur le serveur sous forme de session.  Notons que l’utilisateur a la possibilité de se déconnecter afin d’éviter que son identifiant soit utilisé par  une autre personne utilisant le même ordinateur.    Outre ce système d’identification, nous pouvons distinguer 2 statuts d’utilisateurs :   ‐

Administrateurs : Les personnes possédant ce statut peuvent effectuer toutes les opérations  que permet le programme, elles ne peuvent pas être bridées. De plus les Administrateurs sont  les seuls à pouvoir créer et modifier d’autres comptes utilisateurs.  Utilisateurs : Les utilisateurs possèdent des droits spécifiques, qui sont définis au cas par cas. Ils  pourront effectuer jusqu’à trois actions (Ajouter, Afficher, Modifier) par type de données. En  revanche des actions restent interdites aux utilisateurs comme : la gestion et l’impression  d’état, la suppression de données, l’affichage des logs et la gestion des variables prédéfinies. 

Comme dit précédemment, la vérification des  « droits utilisateurs » s’effectue au niveau du front  Controller ; qui va vérifier si l’utilisateur a le droit de déclencher un contrôleur ou d’afficher une  Template demandée.    

Année Universitaire  2007 – 2008   

 

Page 33 sur 59                            


Application Intranet permettant la gestion d’un système d’information

  Figure 3‐11 : Capture d’écran du gestionnaire des utilisateurs 

  3.3.3 Fonctionnement de l’interface    Fonctionnement interface

index.php

front_controller

tp.admin.php

cl.pseudo_frames.php

tp.*.php

cl.securite.php

BDD

utilisateur demande affichage page création front_controller

Connexion base de données message de retour

Si erreur affichage message Vérification utilisateur et droits message de retour Si erreur affichage message

liaison au template sélection des pages à inclure inclusion de la page

affichage page

inclusion des pages

page construite

inclusion

affichage page ou erreur

Figure 3‐12 : Diagramme des séquences de l’affichage des pages 

Année Universitaire  2007 – 2008   

 

Page 34 sur 59                            


Application Intranet permettant la gestion d’un système d’information

3.4 Formulaires  La mise en place des formulaires fut une opération très longue et répétitive, mais pourtant nécessaire.  J’ai dû ainsi prendre «mon courage à deux mains » et mettre en place autant de formulaires que de  tables présentes dans la base de données.   

3.4.1 Définition et méthodes    Un formulaire est un espace de saisie dans l'interface utilisateur, pouvant comporter plusieurs zones,  appelées « champs » : où l’on peut y saisir du texte, cocher des cases, effectuer un choix dans une liste  de termes prédéfinis.   Ces zones de saisie assurent l'interactivité entre le client (par exemple, le navigateur) et le serveur. Ces  champs permettent par ailleurs d’envoyer des données au serveur qui les traitera pour les stocker ou en  afficher un résultat.  La création des formulaires fût une étape très longue, car il fallait mettre au point une page pour chaque  table, permettant la vérification, la validation et l’insertion des données dans les différentes tables de la  base.    

3.4.2 Variables prédéfinies     Les variables prédéfinies sont en fait des variables gérées par les administrateurs. Elles sont en générale  proposées dans des champs de formulaires tels que des menus déroulants, par exemple : diplômes,  sites, secteurs, etc...    Ce sont des champs susceptibles de changer à court terme, cette intervention aurait nécessitée   l’intervention d’un technicien. 

  Figure 3‐13 : Capture d’écran du gestionnaire des varibles prédéfinies 

Année Universitaire  2007 – 2008   

 

Page 35 sur 59                            


Application Intranet permettant la gestion d’un système d’information

3.4.3 Autocomplétion  Cette fonctionnalité est directement liée à l’amélioration IHM (Interface Homme Machine), elle permet  d’aider l’utilisateur à compléter ses débuts de saisies.  Pour ce genre de choses, il est bien entendu impensable de  recharger en permanence la page, car  rappelons le, nous sommes dans une architecture client ‐ serveur. Le volume que cela représenterait  saturerait le serveur rapidement   C'est là qu'intervient la technologie AJAX très à la mode et  pourtant ancienne.  Ajax va aller chercher l'information sur le serveur et l'intégrer au client sans que celui‐ci ait à subir un  rechargement complet de la page.     Les champs de formulaires que j’ai équipés de cette fonctionnalité d’autocomplétion, correspondent  aux attributs qui permettront par la suite les jointures entres les différentes tables de la base de  données. Les avantages sont triples :    ‐ Afficher la liste des enregistrements déjà présents pour éviter les erreurs.  ‐ Proposer une information exacte.  ‐ Faciliter la « vie » de l’utilisateur.   

  Figure 3‐14 : Capture d’écran d’un champ utilisant l’autocomplétion     

3.4.4 Fonctionnement des formulaires  Le chargement d’un formulaire est une action simple, car il se comporte comme une page classique,  « emprisonnée » par des pseudo‐frames. Je vous invite à vous référer à la partie précédente.  En revanche le système de vérification utilise pleinement les fonctionnalités de Naturel MVC, que je vais  vous détailler. (vous pouvez là aussi vous référer à la partie de Naturel MVC)   

Année Universitaire  2007 – 2008   

 

Page 36 sur 59                            


Application Intranet permettant la gestion d’un système d’information

  Chaque formulaire possède plusieurs fichiers :  ‐ ‐ ‐ ‐

Un fichier de création tp.ajouter_*.php ( exemple : tp.ajouter_personne.php )  Un fichier de modification tp.modifier_*.php  Un Controller co.*.php, qui permet d’effectuer les actions de vérifications des données et de les  insérer dans la base de données.  Il peut être amené à utiliser la classe cl.formulaire.php, qui permet entre autre l’affichage des  champs d’autocomplétions et des listes déroulantes qui permettent l’affichage des variables  prédéfinies.  Et si nécessaire une classe comportant des méthodes propre à un type de formulaire( par   exemple une méthode qui vérifie si une personne existe déjà). 

Fonctionnement Formulaire

index.php

front_controller

co.*.php

co.controller.php

BDD

cl.naviguation.php

utilisateur valide formulaire création front_controller

Connexion base de données message de retour

Si erreur affichage message Charge le controleur du formulaire

hérite du controller

message de retour

.

Si is legitime()? non Si non déclanche defaut() oui Si oui déclanche action()

ajoute à la Base de données ok message_alerte()

ok affiche erreur

message erreur affiche que l'action c'est bien passé

  Figure 3‐15 : Diagramme des séquences de la validation des formulaires 

 

Année Universitaire  2007 – 2008   

 

Page 37 sur 59                            


Application Intranet permettant la gestion d’un système d’information

3.5 Créateur de requêtes  Après avoir généré les formulaires  qui permettent de saisir les informations dans la base de données, il  m’a fallu créer un module, qui permet de trier et d’afficher les requêtes. Pour cela je me suis inspiré de  l’interface de Works DB afin de ne pas trop dévarier l’utilisateur.    

3.5.1 Fonctionnalités et mises en page    Il m’a semblé intéressant de reprendre, d’ajouter et de supprimer certaines fonctionnalités  de Works  DB.  Fonctionnalités reprises :  ‐ ‐ ‐

Un créateur de requêtes logiques, composé de conditions (contient, égale, pas égale,  inférieur,…) mais aussi de connecteurs (et, ou).  Un affichage des résultats des requêtes sous forme de tableau.  Sauvegarder certaines requêtes. 

Fonctionnalités ajoutées :  ‐ ‐ ‐ ‐ ‐ ‐

Il m’a semblé nécessaire d’améliorer le créateur de requête en y ajoutant d’autres actions  comme, l’ordre et le nombre de résultats maximum demandé.  La possibilité de pouvoir intervenir sur les attributs à afficher, en déterminant leur ordre et en  choisissant s’ils seront affichés.  Pouvoir définir une requête par défaut qui sera chargée à l’ouverture de la page.  Trier les attributs en temps réel en un seul clic grâce au JavaScript.  Définir une requête qui sera chargée par défaut lors de l’ouverture de la page.  Mise en place de variables calculés par la base de données (âges, jours restants, …). 

Fonctionnalité supprimée :  ‐

Il était dangereux à l’heure actuelle de permettre l’édition des cellules comme sur un tableur à  l’aide de la technologie AJAX. Avec le mode de fonctionnement actuel, il m’est impossible de  pouvoir contrôler l’intégrité des données champ par champ, car nous sommes obligés de passer  par un contrôleur. Cette fonctionnalité pourrait faciliter l’introduction d’erreurs dans la base de  données. 

Après le choix des fonctionnalités j’ai travaillé la mise en page, dans le but et de pouvoir insérer et sans  surcharger toutes ces fonctionnalités, dans une seule page. 

Année Universitaire  2007 – 2008   

 

Page 38 sur 59                            


Application Intranet permettant la gestion d’un système d’information

Choix des attributs   à afficher 

Ordre des attributs

Gestion des requêtes enregistrées 

Formulaire de création de la requête 

Affichage du résultat de la requête

Figure 3‐16 : Mise en page de la page permettant la création de requête   Ainsi nous pouvons voir clairement 5 zones clairement démarquées, Chacune d’entre elle spécialisée  dans un seul domaine. 

  3.5.2  Classe requête_creator    Pour arriver à sérialiser la création de requêtes,  j’ai dû  mettre au point un objet, qui puisse à partir d’un  type donné (ex : personne, véhicule, …), former une requête SQL et permettre l’affichage de son  résultat.  Cette classe ne sera pas une statique comme la plupart des classes que j’ai développées mais se  comportera comme un objet.  C’est dans cette classe que seront toutes les formules qui permettront à la base de données d’effectuer  les calculs et opérations nécessaires aux variables calculées.    (`mois1_infraction_disque`+`mois2_infraction_disque`+ `mois3_infraction_disque` + `mois4_infraction_disque` +  `mois5_infraction_disque`+`mois6_infraction_disque` +  `mois7_infraction_disque`+`mois8_infraction_disque`+`mois9_infraction_disque`+`mois10_infraction_disque`+`mo is11_infraction_disque`+`mois12_infraction_disque`) /(IF(`mois1_infraction_disque` = "", 0 , 1) +  IF(`mois2_infraction_disque` = "", 0 , 1) + IF(`mois3_infraction_disque` = "", 0 , 1)  + IF(`mois4_infraction_disque` =  "", 0 , 1) + IF(`mois5_infraction_disque` = "", 0 , 1)  + IF(`mois6_infraction_disque` = "", 0 , 1)  +  IF(`mois7_infraction_disque` = "", 0 , 1) + IF(`mois8_infraction_disque` = "", 0 , 1) + IF(`mois9_infraction_disque` =  "", 0 , 1) + IF(`mois10_infraction_disque` = "", 0 , 1) + IF(`mois11_infraction_disque` = "", 0 , 1) +  F(`mois12_infraction_disque` = "", 0 , 1)) as moy_infraction_disque'; 

Figure 3‐17 : Aperçu d’une variable calculée qui correspond à la moyenne des infractions disques par an 

Année Universitaire  2007 – 2008   

 

Page 39 sur 59                            


Application Intranet permettant la gestion d’un système d’information

  Figure 3‐18 : Aperçu de la Classe Requete_creator 

Je vais maintenant vous décrire les attributs :  ‐ ‐ ‐ ‐ ‐ ‐

$Attributs_defaut : Contient la liste des attributs disponibles pour ce type de requête.  $nb_tuples : retourne le nombre de tuples affectés par la requête.  $post : contient les conditions définies par l’utilisateur   $sql : contient la requête sql une fois construite.  $table_attributs : liste des attributs demandés par l’utilisateur  $type_requête : contient le type de requête à construire ( ex : véhicule, personne, …) 

Puis les méthodes de cet objet :  ‐ ‐ ‐

Action() : Retourne le contenu de la colonne action qui sera affiché dans la partie  résultat.  Ajout_variables_calculees() : Permet d’ajouter s’il y a lieu, la liste des variables  calculées depuis la base de données.  Attributs_defaut() : Détermine la liste des attributs par défaut. 

Année Universitaire  2007 – 2008   

 

Page 40 sur 59                            


Application Intranet permettant la gestion d’un système d’information

‐ ‐ ‐ ‐ ‐ ‐ ‐ ‐ ‐ ‐ ‐ ‐ ‐ ‐ ‐ ‐ ‐

Case_etat_valeur() : Détermine l’attribut qui sera utilisé pour donner une valeur aux  cases à cocher.  Clef_jointure() : Permet de corriger les clefs de jointures afin d'éviter les ambiguïtés.  Condition_jointure() : Retourne la condition de jointure qui sera utilisée dans le  « WHERE » lors de la création de la requête.  Executer() : Exécute la requête en y appliquant un filtre qui convertit les dates entre le  format International (AAAA‐MM‐JJ) et le format Français ( JJ‐MM‐AAAA).   Is_action() : Détermine si le type demandé possède une colonne action.  Is_attributs() : Détermine si l’attribut fait partie de la liste des attributs à afficher.  Is_editable() : Détermine si les lignes de résultats peuvent être éditées par l’utilisateur.  Is_variables_calculees() : Permet de déterminer si l’attribut demandé est une variable à  calculer.  Lien_javascript() : retourne l’action JavaScript qui permettra la suppression du tuple.  Lien_modification() : retourne l’adresse de la page qui permet la  modification d’un  tuple.  Liste_requete_enregistrees() : retourne un tableau contenant la liste des requêtes  enregistrées par l’utilisateur.  Nb_tuples() : Retourne le nombre de tuples affectés par la requête.  Requete_sql() : Retourne la requête SQL une fois créée.  Tables() : Retourne les tables qui seront utilisées pour effectuer la requête.  Tuple() : Retourne la liste des résultats de la requête une fois éxécuté.  Variables_calculees() :  Retourne la valeur d'une variable calculée ;  Variables_calculees_attributs() : Liste des variables calculées pour chaque type, qui sera  utilisée  lors de la création de la requête.   

3.5.3 Création de la requête    Pour ce qui est du formulaire de création de la requête, j’ai fait un « mix » entre celui de Works DB et  celui de PhpMyadmin, afin d’obtenir une mise en place simple et efficace. 

  Figure 3‐19 : Le créateur de requêtes de Works DB à droite et celui de phpmyadmin à gauche 

Année Universitaire  2007 – 2008   

 

Page 41 sur 59                            


Application Intranet permettant la gestion d’un système d’information

Figure 3‐20 : Capture d’écran du formulaire de création de requêtes  Il sera demandé à l’utilisateur de renseigner les attributs désirés, le type de données, les conditions de  la requête, les conditions de tris et le maximum de tuples.  Puis le créateur de requête déterminera automatiquement les tables utilisées ainsi que les 

conditions de jointures grâce au type des données traitées.  Les informations ainsi demandées permettront de remplir ce gabarit  afin de pouvoir créer au final, une  requête SQL.    SELECT attributs désirés   FROM table(s)  WHERE (Conditions demandées par l’utilisateur) AND conditions de jointures si nécessaire   ORDER BY Conditions de tris  LIMIT Nombre maximum de tuples 

  Maintenant nous allons nous intéresser plus particulièrement au fonctionnement de la méthode  Requete_sql(), qui permet la formation de la requête SQL.           

Année Universitaire  2007 – 2008   

 

Page 42 sur 59                            


Application Intranet permettant la gestion d’un système d’information

Si  Des opérations de comparaison sont demandées 

               

  $nb_comparaison = L’on compte le nombre de comparaisons à effectuer    Si $nb_comparaison >0    $clause_where_active = Vrai  Sinon    $clause_where_active = Faux 

Pour $i=1;  $i <= 5;  $i++       

 

SI  Comparaison.$i est renseigné 

    on vérifie si attributs.$i n’est pas la clef de jointure ou une variable calculée, dans ce  cas là on y applique un filtre afin qu’elle soit valide à l’aide des méthodes  variables_calculees() et clef_jointure().    $condition  .=  On construit les conditions de la clause WHERE.  Fin Pour          $sql = 'SELECT * '.$this‐>variables_calculees_attributs().' FROM '.$this‐>tables();          SI  ($clause_where_active = Vrai)  {    $sql .= ' WHERE ('.$conditions.' ) ';  }  SI ($this ‐>condition_jointure() != null)  {          SI ($clause_where_active = Vrai)    {      $sql .= ' AND '.$this‐>condition_jointure();    }    Sinon    {      $sql .= ' WHERE '.$this‐>condition_jointure();    }        }  SI ( this‐>post[ordonner_par] n’est pas vide)  {    $sql .= ' ORDER BY '.$this‐>post[ordonner_par].' '.$this‐>post[ordre];  }        SI ($this‐>post[limite] n’est pas vide)  {    $sql .= ' Limit '.$this‐>post[limite];  } 

                                                        Retourner $sql   

Année Universitaire  2007 – 2008   

 

Page 43 sur 59                            


Application Intranet permettant la gestion d’un système d’information

3.5.4 Affichage du résultat    Le résultat de la requête est affiché sous forme de tableau, chose identique à Works DB et à  PhpMyadmin, afin de faciliter la visualisation des données.  L’entête du tableau représente la liste des attributs que l’utilisateur a préalablement sélectionnés. La  ligne des attributs est fixe, seul le corps du tableau bouge, cette fonctionnalité a été développée afin de  faciliter la lecture des données.  De plus une fonction de trie utilisant JavaScript a été utilisée, elle permet de trier n’importe quelle  colonne et cela de façon instantanée, c'est‐à‐dire sans recharger la page, ce qui pourrait surcharger le  serveur et augmenterai considérablement les temps de chargements.  Dans l’ordre des colonnes, vous pouvez voir :  ‐

Une liste de cases à cocher. Celles‐ci utilisent la fonction Case_etat_valeur(),pour déterminer  leur valeur. Ces cases servent à sélectionner les tuples qui permettront de produire des  documents grâce aux états.  Cette colonne permet d’éditer les informations de chaque tuple, et si seulement si  la méthode  Is_editable() retourne vrai, dans le cas contraire la colonne n’apparaît pas. Si l’utilisateur a  accédé à l’édition il aura le choix entre 2 actions, la suppression qui utilisera la méthode  Lien_javascript() ou la modification qui utilisera la méthode Lien_modification().  La 3e colonne est elle aussi optionnelle, elle sera seulement affichée si la méthode Is_action()  retourne vrai. Cette colonne est en fait spécifique à chaque type de donnée. Dans ce cas il s’agit  d’un lien vers un dossier qui contient des informations sur chaque véhicule. Notons par exemple  que pour les données de type personnes, nous afficherons un dossier permettant aussi  d’accéder aux informations de la personne, mais aussi sa photo. Le contenu des actions est écrit  dans la méthode action().  Enfin le reste des autres colonnes correspond à l’affichage des attributs sélectionnés avec leurs  valeurs . 

  Figure 3‐21 : Capture d’écran  de l’affichage du résultat de la requête 

Année Universitaire  2007 – 2008   

 

Page 44 sur 59                            


Application Intranet permettant la gestion d’un système d’information

3.6 Créateur d’états    3.6.1 Définition    Une fois les informations entrées dans la base de données, l’utilisateur peut les organiser facilement  sous forme d’états. Un état peut contenir la totalité ou une partie des données sélectionnées. Un  état  est un document générique créé par l’utilisateur. Ce document réagit  aux informations venant de la  base de données, pour produire un document imprimable ou/et utilisable par l’entreprise.   

  Figure 3‐22 : A gauche le gabarit et à droite le document produit 

3.6.2 Utilité    Les états sont très importants pour l’entreprise, car ils permettent :  ‐ ‐ ‐ ‐ ‐

La sortie d’informations de la base de données.  De structurer et préciser les requêtes (l’on peut voir ça comme quelqu’un qui pioche des  informations dans la base de données).  La production de documents administratifs (contrôles, statistiques, analyses,  enregistrements,...).  La production de courriers types qui sont générés automatiquement.   La production de documents facilement lisibles pour les collaborateurs de l’entreprise. 

Année Universitaire  2007 – 2008   

 

Page 45 sur 59                            


Application Intranet permettant la gestion d’un système d’information

3.6.3 Création et modification d’états  Pour que l’utilisateur puisse facilement créer et modifier des états, j’ai utilisé le célèbre éditeur de texte  FCKeditor. Ce programme permet de mettre en place sur un site Internet un petit traitement de texte  accessible via un navigateur. Ce traitement de texte possède les options basiques (alignement,  paragraphe, quelques polices, tableaux...).  Ce projet déjà très abouti promet encore de belles  améliorations (notamment sur la création de tableaux et la correction d’orthographe).  Sa renommée n’est plus à prouver car Il est intégré à de nombreux CMS, notamment SPIP, Joomla. De  plus il est reconnu aussi par de grandes sociétés telles qu’Adobe.  Son interface n’a rien à envier à un traitement de texte et des options d’envoi d’images existent pour  permettre la gestion de bibliothèques d’images.   Le code généré lors de la première validation est valide XHTML, mais cette validation peut se perdre lors  de modifications de texte.  Une zone à droite permet d’afficher les attributs correspondants au type d’état sélectionné. Grâce au  JavaScript en un double clic, l’attribut est inséré  dans la zone de saisie.  

Figure 3-23 : Capture d’écran du créateur d’état    3.6.4 Développement d’un pseudo langage    Dans le but de pouvoir différencier le texte des variables, mais aussi de pouvoir créer des opérations, j’ai  dû mettre au point un pseudo langage.  Une variable est identifiée de cette façon : {mon_attribut},  ainsi le texte entre accolades sera remplacé  par les attributs venant de la base de données. Exemple : {nom_personne} sera remplacé par le nom 

Année Universitaire  2007 – 2008   

 

Page 46 sur 59                            


Application Intranet permettant la gestion d’un système d’information

d’une personne.  Notons que si une variable est inconnue, il sera retourné à l’utilisateur le message  d’erreur suivant : ## ma_variable inconnu ##.  Pour que l’utilisateur ait accès à des fonctionnalités supplémentaires, j’ai mis au point un langage sous  forme de BBcode.  Balise spécialisée dans les dates : [date] [/date]  ‐

‐ ‐

Affichage de date : j’ai donné la possibilité à l’utilisateur d’accéder à la bibliothèque strftime de  PHP, qui permet de formater une date/heure locale avec la configuration locale (Que j’ai  préalablement réglée en langue Française).  Pour afficher la date du jour l’utilisateur devra taper  [date]%d %B %Y[/date]. La liste de tous les paramètres disponibles pour cette balise est  disponible à l’adresse suivante : http://fr3.php.net/manual/fr/function.strftime.php.  [date=intervalle] D1, D2 [/date] permet de retourner l’intervalle en jours entre 2 dates.  La méthode [date=age] D1 [/date]  permet de retourner l’âge en années de la date.  [date=jour]  ou [date=mois] ou  [date=anne] D1 [/date] retourne un bout d’une date : soit le  jour, le mois ou l’année. 

  Balise opération : [op][/op]  Cette balise permet d’effectuer des opérations mathématiques (ex : une simple opération [op]2*3[/op]  affichera 6). Mais cette balise utilise la librairie Maths disponible à cette adresse :  http://fr.php.net/manual/fr/ref.math.php.  (ex : [op] ceil({infraction_mois1}+{infraction_mois2}/2)[/op],  Cette opération ira chercher les variables de la base de données pour les additionner, les diviser et enfin  arrondir au nombre supérieur grâce à la fonction ceil(). 

3.6.5 Fonctionnement du Parsage et de l’affichage 

Figure 3‐24 : Aperçu de la Classe Etat 

Je vais maintenant vous décrire les attributs : 

Année Universitaire  2007 – 2008   

 

Page 47 sur 59                            


Application Intranet permettant la gestion d’un système d’information

‐ ‐ ‐ ‐

$tableau : Liste des cases à cocher.  $id_etat : Identifiant de l’état demandé.  $contenu_etat : contenu de l’état.   $tableau_resultat : contenu une fois traité. 

Puis les méthodes de cet objet :  ‐ ‐ ‐

Affiche () : Permet d’afficher le résultat une fois que l’état a été traité.  Contenu_etat() : Charge le contenu de l’état depuis la base de données, grâce à  l’identifiant.  Nom_etat() : Charge le nom de l’état de la même manière que Contenu_etat() . 

‐ Parse_Template() : Parse l’état en y appliquant les variables venant de la base de données.  ‐ Tableau_resultat() : retourne la variable $tableau_resultat.  ‐ Tableau_valeur() : remplace une variable de formaté sous la forme {ma_variable} par  l’attribut y correspondant , stocké dans la base de données.  ‐ Type_etat() :  retourne le type de l’état demandé.  ‐   Parsage d'un état

tp.etat.php utilisateur visualisation d'un état

Cl.etat.php

BDD

Connexion à la base de données Pour le nombre de ligne sélectionné

création d'un objet Etat

contenu_etat()

type_etat()

ParseT emplate()

retourne état

affiche états(s)

  Figure 3‐25 : Diagramme des séquences de la génération d’états 

Année Universitaire  2007 – 2008   

 

Page 48 sur 59                            


Application Intranet peermettant la gestion g d’un syystème d’inforrmation

3.7 C Création de e graphiqu ues  Pour une entreprrise il est intééressant de cconnaître en temps réel son évolutio on générale. A Afin de mieu ux  prendre et po ointer les po oints faibles eet forts de l’e entreprise, il m’a été dem mandé de mettre au poin nt  comp quelq ques graphiq ques qui pourront fournirr des informaations imporrtantes. Par eexemple, less arrêts de  travails, les pv, les infractionss disques, etcc… 

  3.7.1 JpG Graph    Il exisste plusieurss bibliothèques graphiquees destinéess à la fabricattion de graph hiques. Cela évite d’utilisser  les fo onctions de b bas niveau dee la bibliothèèque graphiq que de PHP n nommée GD2. JpGraph e est une  biblio othèque desttinée à la fab brication de ggraphiques. J’ai choisi ceette librairie car ses perfo ormances sont  remaarquables et parce que so on développeement est co ontinu.  Il est possible grââce à JpGraph h de créer dees graphique es complexess en quelquees lignes, nou us verrons un n  mple par la su uite.  exem JpGraaph, gère une multitude de paramètrres : les éche elles de donn nées, la prisee en charge d des axes, la  position des donn nées, la gestion des titress et légendes, préserve les performances  serveu ur, etc…  De plus l’un des aavantages majeur de cettte librairie c’’est qu’elle eest complètement  orienttée objet. L’o on  retrouve des foncctions proprees à toutes lees parties d’u un graphiquees (axes, lign nes, titres, te extes, etc..).  

  Figu ure 3‐26 : Log go de JpGrap ph 

  3.7.2 Utiilisation de JpGraph    L’utilisation de la bibliothèque JpGraph esst d’une facilité déconcertante. Afin de vous le prrouver je vaiis  vous montrer le ccode  qui perrmet l’affichaage de ce « ccamembert » ».  

Annéee Universitaire  2007 – 2008   

Page 49 sur 59 9                            


Application Intranet permettant la gestion d’un système d’information

  Figure 3‐27 : Graphique crée à partir de la librairie JpGraph    //inclusion des fichiers include ("../db.php"); include ("../includes/jpgraph/jpgraph.php"); include ("../includes/jpgraph/jpgraph_pie.php"); include ("../includes/jpgraph/jpgraph_pie3d.php"); // requite qui va permettre d’extraire les données $sql = "SELECT secteur_enregistrement, COUNT(secteur_enregistrement) as nbe FROM enregistrement WHERE YEAR(date_enregistrement) = YEAR(NOW()) GROUP BY secteur_enregistrement"; global $db; $sth = $db->prepare($sql); $sth->execute(); $info = $sth->errorInfo(); echo $info[2]; // Création des données et des axes while ($row = $sth->fetch(PDO::FETCH_ASSOC)) { $donnees[] = $row["nbe"]; $ab[] = $row["secteur_enregistrement"]; }

Année Universitaire  2007 – 2008   

 

Page 50 sur 59                            


Application Intranet permettant la gestion d’un système d’information

// Create the Pie Graph. $graph = new PieGraph(800,500,"auto"); $graph->SetShadow(); // Set A title for the plot $graph->title->Set("NON CONFORMITES 2007"); $graph->title->SetFont(FF_VERDANA,FS_BOLD,18); $graph->title->SetColor("darkblue"); $graph->subsubtitle->Set("Par Secteur"); $graph->subsubtitle->SetFont(FF_VERDANA,FS_BOLD,15); $graph->subsubtitle->SetColor("darkblue"); $graph->legend->Pos(0.1,0.2); // Create 3D pie plot $p1 = new PiePlot3d($donnees); $p1->SetTheme("sand"); $p1->SetCenter(0.4); $p1->SetSize(200); // Adjust projection angle $p1->SetAngle(45); // Setup the slice values $p1->value->SetFont(FF_ARIAL,FS_BOLD,11); $p1->value->SetColor("navy"); $p1->SetLegends($ab); $graph->Add($p1); $graph->Stroke(); 

  4 Résultats    Dans cette partie, je procèderai à la présentation de  la structure générale de l’application sous forme de  captures d’écran.    Page d’identification, par laquelle l’utilisateur devra obligatoirement passer pour accéder à l’interface.  Notons qu’au centre nous pouvons voir le logo de l’application.   

Année Universitaire  2007 – 2008   

 

Page 51 sur 59                     ��      


Application Intranet permettant la gestion d’un système d’information

  Figure 4‐1 : Capture d’écran de la page d’identification    Vous pouvez voir la page d’accueil de l’administration, conformément à la maquette de l’interface. La  Personne qui s’est identifiée est François Lesage il possède le rang d’Administrateur, car il a accès à  toutes les informations et fonctionnalités de l’application.  De plus vous pouvez voir à droite une petite zone texte très pratique que l’utilisateur peut utiliser  comme pense‐bête. 

Figure 4‐2 : Capture d’écran montrant la zone d’administration de l’application 

Année Universitaire  2007 – 2008   

 

Page 52 sur 59                            


Application Intranet permettant la gestion d’un système d’information

La page qui permet de créer et de modifier les utilisateurs en déterminant leurs informations  personnelles ainsi que leurs droits utilisateurs 

Figure 4‐3 : Capture d’écran du formulaire de création d’utilisateur 

Voici l’interface de gestion des infractions disques, qui affiche tous les conducteurs de l’entreprise en tenant compte de leur date d’entrée et de sortie. Ici l’utilisateur a décidé d’afficher l’exercice de 2007.

Figure 4‐4 : Capture d’écran montrant le gestionnaire des infractions disques 

Année Universitaire  2007 – 2008   

 

Page 53 sur 59                            


Application Intranet permettant la gestion d’un système d’information

Cette capture d’écran montre le créateur d’état, utilisant FCKeditor, Nous sommes en train de modifier l’état nommé « enregistrement réclamation » de type « enregistrement »

Figure 4‐5 : Capture d’écran du créateur d’états    L’un des multiples formulaires d’ajouts. Dans l’exemple présent l’utilisateur a cliqué sur « Ajouter  personne » et il a accès à cette page qui lui permet d’ajouter les informations concernant une personne  ainsi que sa photo.   

  Figure 4‐6 : Capture d’écran d’un des formulaires d’ajout 

Année Universitaire  2007 – 2008   

 

Page 54 sur 59                            


Application Intranet permettant la gestion d’un système d’information

Nous pouvons voir le créateur de requête avec le gestionnaire de requêtes enregistrées,  l’émulateur de  requêtes SQL, la création d’états et l’affichage du résultat de la requête effectuée. 

  Figure 4‐7 : Capture d’écran du créateur de requête    Nous avons décidé de modifier une certaine personne, dès lors, un nouveau formulaire de modification  s’affiche regroupant les diverses informations déjà saisies, nous pouvons les consulter et les modifier. 

  Figure 4‐8 : Capture d’écran du formulaire de modification d’une personne    Année Universitaire  2007 – 2008   

 

Page 55 sur 59                            


Application Intranet permettant la gestion d’un système d’information

5 Discussion    Dans cette partie, je vais porter un regard critique sur le travail que j’ai effectué lors de ces 10 semaines  de stage.  En ce qui concerne l’interface, certaines pages  auraient pu être plus travaillées afin de garantir une  meilleure ergonomie. Mais je ne me suis pas trop attardé sur cette partie du développement car j’ai  préféré consacrer mon temps aux principales fonctionnalités de l’application. La page qui correspond le  mieux à cet exemple est la page de création de requêtes qui se trouve un peu noyée sous les boutons de  formulaires.   Pour l’optimisation du temps de chargement des pages de l’application, il aurait été intéressant de  forcer le navigateur à utiliser son système de caches. Même si la version de Firefox 3 accélère nettement  le temps d’interprétation des pages, l’utilisateur devra se montrer vigilant à ne pas afficher trop  d’informations à la fois.  Au départ il était prévu de mettre en place un outil graphique inspiré de celui d’Excel, pour permettre la  génération de graphiques à la volée. Mais par manque de temps je n’ai pas pu me consacrer à la  création de ce module. Toutefois j’ai créé les graphiques les plus importants pour la gestion de  l’entreprise.  Il existe quelques failles de sécurités au niveau de la connexion à la base de données, qui pourraient être  exploitées par des personnes malveillantes. Toutefois ces failles sont vraiment très minimes et ne  présentent qu’un risque quasi nul. Je tiens seulement à les mentionner en tant que puriste.   Il serait intéressant de mettre au point un système en AJAX, qui permettrait l’édition des tuples  directement dans l’affichage du résultat des requêtes, et ce sans être obligé de passer par les  formulaires. Toutefois il faudrait revoir une partie de l’architecture du programme, car les contrôleurs  ne valideraient plus les formulaires  dans leur intégralité mais les champs les uns après les autres.  Une documentation a été créée pour les futures personnes qui pourraient reprendre le développement  de l’application. Cette documentation est sous forme de document HTML elle a été générée grâce à  PHPDocumentor.  Le projet a été présenté à l’ensemble de l’équipe dans la salle de réunion grâce à un rétroprojecteur. De  plus une formation a été donnée au personnel afin qu’il puisse utiliser au mieux le logiciel. 

Année Universitaire  2007 – 2008   

 

Page 56 sur 59                            


Application Intranet permettant la gestion d’un système d’information

6 Conclusion    J’ai réalisé une plateforme Intranet permettant de gérer une partie du système d’information des  Transports Charlon. Cette plateforme permet de résoudre plusieurs problèmes rencontrés par  l’entreprise. Ces problèmes sont résolus grâce à la création d’une base de données structurée qui  permet de recouper diverses données. Par la suite un système  de gestion des droits des utilisateurs   permet de faciliter l’accès à l’information en définissant des droits pour chaque poste. Enfin l’application  apporte un gain de temps et qualité grâce aux contrôles effectués sur les formulaires, la création de  fiches types et la génération de graphiques.    L’ensemble des objectifs a été réalisé, même si cette application n’est pas optimale et pourrait voir la  création d’un créateur de graphiques. Elle répond pourtant à ce pourquoi elle a été instiguée et est  d’ores et déjà utilisée par l’entreprise. Toutefois, afin d’améliorer la plateforme, j’aurais pu développer  certaines fonctionnalités proposées dans la discussion, qui auraient permis à notre plateforme d’être  totalement indépendante. Mais Le temps et la complexité de certaines tâches ont été les principaux  facteurs m’empêchant d’accomplir ces dernières. Cette partie pourrait faire l’objet d’un autre projet,  voir d’un contrat professionnel.  Ce projet m’a permis d’appliquer les connaissances qui m’ont été enseignées au cours de ces deux  années de DUT Informatique à l’Université des Sciences Montpellier II, mais aussi de mettre en avant  mes connaissances personnelles en PHP (langage qui n’est pas enseigné à sa juste valeur).  J’ai été  confronté à de nombreux problèmes et dans la plupart des cas j’ai du trouver une solution par mes  propres moyens afin de pouvoir les résoudre. Pour moi, ce projet aura été l’occasion de découvrir le  monde de l’entreprise que je n’avais encore jamais eu le privilège de connaître !       

Année Universitaire  2007 – 2008   

 

 

Page 57 sur 59                            


Application Intranet permettant la gestion d’un système d’information

Bibliographie 

http://php.net/ Site officiel de PHP.  http:/ /fr.wikipedia.org/ Encyclopédie gratuite en ligne.  http://uml.free.fr/ Site de cours UML.  http://developpez.com Club d'entraide des développeurs francophones.  http://phpfrance.com   http://phpindex.com La passerelle française des technologies PHP: Hypertext Preprocessor.  http://zend.com/fr/  The PHP company.  http://wampserver.com/ Apache, MySQL, PHP pour Windows    François Lesage, Manuel Qualité des Transports CHARLON.   Eric Daspet et Cyril Pierre de Geyer, PHP 5 avancé 4e édition.  Pawel Kozlowski, PHP Solutions N°2 2005.  Bruno Catteau et Nicolas Faugout, AJAX le guide complet  Documents administratifs et de sociétés. 

   

Année Universitaire  2007 – 2008   

 

 

Page 58 sur 59                            


Application Intranet permettant la gestion d’un système d’information

Résumé Dans le cadre de ma  2ème année de DUT  Informatique, j’ai développé une plateforme permettant la  gestion d’un système d’information. Cette plateforme, implémentée dans un environnement Intranet  utilise le couple PHP/MySQL. Elle permet de regrouper et de synthétiser les informations dont  l’entreprise a besoin. L’application permet d’insérer, d’afficher et modifier des informations de la base  de données, mais aussi de créer des états et de générer des graphiques. Cette application a été réalisée  dans l’optique d’améliorer le système d’information de l’entreprise afin qu’elle respecte au mieux les  attentes ISO 9001.       Mots clés : Système d’information, Intranet, base de données, formulaires, états, graphiques ISO 9001 :  2001, PHP, MySQL. 

Summary  During my 2nd year DUT Science, I have developed a platform for the management of an information  system. This platform, implemented in a couple Intranet uses the PHP / MySQL. It brings together and  synthesize the information the company needs. The application lets you insert, view and modify  information in the database, but also create reports and generate graphics. This application has been  made in terms of improving the information system of the enterprise so that it better meets the  expectations ISO 9001.     Keywords: Information System, Intranet, database, forms, reports, charts ISO 9001: 2001, PHP, MySQL. 

Année Universitaire  2007 – 2008   

 

Page 59 sur 59                            


gfh