rapport stage de perfectionnement - application de suivi de temps web2.0 sous symfony framework...

:: Rapport du stage technicien ::

Elaboré par : Karray Walid

Encadré par : Zouari Fourat

Classe : IR-41

Validation finale

Par : ………………………

Signature :

Période : du 12/01/2009 au 06/02/2009

Année Universitaire : 2008/2009

Solution de suivi de temps « TimeIt »

REPUBLIQUE TUNISIENNE

Ministère de l’Enseignement Supérieur

Direction Générale des Etudes Technologiques

Institut Supérieur des Etudes technologiques de Djerba

Département Informatique

Sommaire

Remerciement ....................................................................................................4

Introduction .......................................................................................................5

1. Etude de l’organisme ...................................................................................6

1.1. Présentation de l’organisme .......................................................................6

1.2. Organigramme de l'entreprise: ...................................................................7

1.3. Description de la structure concernée par le stage: .........................................7

2. Présentation du thème du stage.....................................................................8

2.1. Champ de l’étude et objet du stage .............................................................8

2.2. Planning prévisionnel du stage.................................................................. 10

3. Infrastructure informatique ......................................................................... 11

3.1. Matériels informatique ............................................................................ 11

3.2. Logiciels utilisés .................................................................................... 12

4. Etude préalable ........................................................................................ 17

4.1. Description de l’existant .......................................................................... 17

4.2. Critique de l’ex istant............................................................................... 20

4.3. Solutions proposées ............................................................................... 21

5. Etude conceptuelle ................................................................................... 22

6. Réalisation .............................................................................................. 24

6.1. 1ère étape: Extraction du projet depuis le dépôt ............................................ 24

6.2. 2ème étape: Configuration de la base de données .......................................... 25

6.3. 3ème étape : Dans la couche Modèle ........................................................... 28

6.4. 4ème étape : Dans la couche Vue ............................................................... 30

6.5. 5ème étape : Dans la couche Contrôleur ....................................................... 32

6.6. 6ème étape : Le test ................................................................................ 34

6.7. 7ème étape : Mise à jour du dépôt. ............................................................. 35

Conclusion ....................................................................................................... 36

Glossaire ......................................................................................................... 37

Netographie ..................................................................................................... 38

Remerciement

Je tiens à remercier Mr. Zouari Fourat, le chef de projet à TriTUX pour

avoir veillé au bon déroulement de mon stage et pour m'avoir donné les

moyens et l'assistance nécessaire durant mon stage.

Je n’oublie pas aussi ses précieux conseils techniques durant mon

intervention au niveau du projet.

Introduction

Ce stage, d’une durée quatre semaines, a consisté à développer une

solution qui contrôle les droits des utilisateurs dans un projet de suivi de temps

nommé TimeIt.

Ce rapport présente le travail que j’ai effectué lors de mon stage au sein de

TriTUX qui s’est déroulé du 12/01/2009 au 06/02/2009

Je me suis familiarisé avec un environnement technique et un ensemble d’outils de

développement d’applications web sous Linux et une technique de gestion de projet

qui est employée par la communauté Open Source.

L’intervention est avéré très intéressante et très enrichissante pour mon

expérience professionnelle.

Le but de ce rapport n’est pas de faire uniquement une présentation

exhaustive de tous les aspects techniques que j’ai pu apprendre ou approfondir, mais

aussi, de manière synthétique et claire, de faire un tour d’horizon des aspects

techniques et humains auxquels j’ai été confronté.

Je vous expose dans ce rapport en premier lieu une présentation des

entreprises, ensuite, je vous explique les différents aspects de mon travail durant ces

quelques semaines et enfin, en conclusion, je résume les apports de ce stage.

Etude de l’organisme

sur 38

1. Etude de l’organisme

1.1. Présentation de l’organisme

TriTUX S.A.R.L. est une SSII Tunisienne née par le regroupement, au sein d'un

réseau professionnel, des compétences provenant de divers horizons et partageant la

même conviction : que les nouvelles technologies de l'information et de la

communication (NTIC) basées sur les logiciels libres, constitueront le choix

fondamental face aux exigences de la société future, société de l'information.

Dynamique, rapide et accompagnant les changements et bouleversements induits

par l'émergence de nouvelles techniques et des nouveaux besoins des usagers,

TriTUX a repensé l'approche des activités liées aux NTIC par l'adaptation du choix

"Open Source " garantissant la sécurité, fiabilité, flexibilité, et surtout, une évolution

quotidienne vers le top de la technologie.

o Domaines d'activité:

Les domaines d’activités de TriTUX s’étendent sur plusieurs disciplines à

savoir :

- Bases de données libres,

- Logiciels libres,

- Développement de solutions avec des outils/ressources libres,

- Annuaires LDAP,

- Messageries mail,

- Messageries courtes (SMS) et Multimédia (MMS),

- Systèmes GNU Linux,

- Supervision et monitoring,

- Réseaux complexes,

- Sécurité et optimisation.

o Références de TriTUX:

TriTUX a développé plusieurs applications, en voici quelques références :


sur 38

- Assurances BIAT,

- Tunisie Telecom,

- Mobile Services,

- Nouvelair,

- Alva,

- Sameteam,

- PixelJ,

- Attijari Bank,

- Groupe Délice Tunisie.

1.2. Organigramme de l'entreprise:

1.3. Description de la structure concernée par le stage:

Les activités dans l ‘entreprise se diversifient en plusieurs autres secteurs.

Le service développement d’applications web me semble le plus intéressant car il

est évolutif et nécessite de la réflexion et le savoir faire en plus qu’existe une

multitude de secteurs qui dépondent de ce dernier.

Direction Générale

DéveloppeurManager

Service commerciale

Service Développement

Service DesignService

developpement Web

Service documentation

Service Maintenance

Présentation du thème du stage

sur 38

2. Présentation du thème du stage

2.1. Champ de l’étude et objet du stage

L’objectif majeur de ce stage est de trouver une solution au système de gestion de

permission des utilisateurs dans un projet de suivi de temps « TimeIt ». Il faut que

cette application différencie les utilisateurs hiérarchiquement de façon qu’il s’y trouve

des utilisateurs plus privilégiées que d’autres dont le but est d’empêcher ou

d’autoriser l’exécution de certaines taches, tel que la création, l’édition, la

suppression et la suspension de l’activité des utilisateurs.

Le schéma ci-dessous explique les huit différentes étapes à suivre durant ce stage.


sur 38

Se familiariser avec le Framework Symfony

Télécharger la dernière version projet (TimeIt) depuis le dépôt

Comprendre le fonctionnement de l’application

Etudier le problème

Préparer une solution primaire (par des schématisations)

Implémenter la solution dans le projet

Tester

Mettre à jour la version du dépôt

FIGURE 1: LES DIFFERENTES TACHES A EXECUTER (PAR ORDRE)


sur 38

2.2. Planning prévisionnel du stage

1ére

Semaine

2éme

semaine

3éme

semaine

4éme

semaine

Phase préliminaire


Documentation

Interventions dans le

projet

Rédaction du rapport

Infrastructure informatique

sur 38

3. Infrastructure informatique

3.1. Matériels informatique

TriTUX possède une infrastructure informatique importante qui satisfait

convenablement à ses besoins, offrant à ses employées 8 ordinateurs pour chacun,

dont 5 ordinateurs portables et 3 ordinateurs de bureau en plus d’un serveur central

commun à tous les membres de l’entreprise.

Les ordinateurs :

Marque Processeur Mémoire vive Disque dure

DELL-Dimension 3.6 Ghz 1,5Go 120Go



IBM-Thinkpad DualCore 1.8Ghz 2Go

IBM -Thinkpad DualCore 1.8Ghz 2Go 100Go

TOSHIBA-SATELLITE Core2Duo 1.7Ghz 4Go 350Go



o Le serveur :

Il se compose de 4 blocs :

Bloc n°1 :

- Architecture : PC-Intel

- Fréquence du microprocesseur : 3,6

GHz

- Capacité mémoire vive (RAM) : 3 Go

- Taille du disque dure : 250 Go.

- Domaine : moonfish.tux

FIGURE 2. PHOTO DU SERVEUR


sur 38

- Description : gère tout ce qui est réseaux, internet et firewall.

Bloc n°2 :


- Fréquence du microprocesseur : 2x1 GHz



- Domaine : shark.tux

- Description : Machines virtuelles (Plusieurs machines virtuelles ayant

chacun son adresse IP)

Bloc n°3 :


- Fréquence du microprocesseur : 2x1 GHz



- Domaine : bluefish.tux

- Description : Gère la messagerie vocale sur un réseau IP, VoIP.

Bloc n°4 :

- Nature : JBOD

- Contrôleur/Connecteurs : SCSI

- Nombre maximal de disques dure : 8

- Disques : 120 Go+120 Go +250Go

- Description : Concaténation de disques durs

3.2. Logiciels utilisés

TriTUX utilise des logiciels libres qui fonctionnement sur la plupart des

distributions GNU/Linux. Les systèmes d’exploitation installés sur les clients sont

Ubuntu-Linux versions 8.04 et 8.10 et Debian 4.0 pour le serveur.


sur 38

Voici une liste des logiciels les plus utilisées par l’entreprise :


sur 38

o Symfony :

Symfony est un Framework MVC « Modèle-Vue-Contrôleur » libre entièrement

écrit en PHP 5. En tant qu’un Framework, il facilite et accélère le développement des

sites et d'applications Internet et Intranet.

FIGURE 3. MODELE MVC

Symfony intègre Proprel qui est lui aussi un Framework de mapping objet-

relationnel « ORM » offrant une technique de programmation informatique qui crée

l'illusion d'une base de données orientée objet à partir d'une base de données

relationnelle en définissant des correspondances entre cette base de données et les

objets du langage utilisé. On pourrait le désigner par « correspondance entre monde

objet et monde relationnel ».

Les fichiers de configuration employés par Symfony sont au format YAML qui est

un langage de sérialisation de données comme XML mais plus humain et facile à

interpréter.

o Apache HTTP Server :

Apache, est un logiciel de serveur HTTP produit par l'Apache Software Foundation.

C'est le serveur HTTP le plus populaire du Web. C'est un logiciel libre avec un type

spécifique de licence, nommée licence Apache.

http://fr.wikipedia.org/wiki/Fichier:ModelViewControllerDiagram.svg


sur 38

Il est noté que Symfony exige l’activation du module REWRITE du serveur web

Apache, ce module permet aux développeurs d’utiliser un format personnalisable

d’adresses URL qui sont compréhensibles par n’importe quel visiteur et facilite la

tache d’indexation par les moteurs de recherche. Il existe différentes manières pour

activer le module RE_WRITE, la plus simple se fait via la commande « a2enmod

rewrite » dans la console de linux.

o MySQL :

MySQL est un système de gestion de base de données (SGBD). Selon le type

d'application, sa licence est libre ou propriétaire. Il fait partie des logiciels de gestion

de base de données les plus utilisés au monde, autant par le grand public

(applications web principalement) que par des professionnels, au même titre que

Oracle ou Microsoft SQL Server.

o PHP :

PHP (sigle de PHP: Hypertext Preprocessor), est un langage de scripts libre

principalement utilisé pour produire des pages Web dynamiques via un serveur

HTTP, mais pouvant également fonctionner comme n'importe quel langage interprété

de façon locale, en exécutant les programmes en ligne de commande. PHP est un

langage impératif disposant depuis la version 5 de fonctionnalités de modèle objet

complètes. En raison de la richesse de sa bibliothèque, on désigne parfois PHP

comme une plate-forme plus qu'un simple langage.

Il est noté que les versions 1.0.x de Symfony nécessite les versions 5.2.x et

supérieurs de PHP.

o Zend Studio for Eclipse 6.1.0 :

Zend Studio for Eclipse (Version 6.1.0) est un IDE pour les applications PHP

issu de Zend Studio et de la plate-forme Eclipse. Zend Studio for Eclipse offre des

fonctionnalités d'édition de code, de débogage, de refactoring et le support des tests

unitaires.


sur 38

o Subversion :

Subversion (en abrégé svn) est un système de gestion de versions, distribué sous

licence Apache et BSD. Il a été conçu pour remplacer CVS. Ses auteurs s'appuient

volontairement sur les mêmes concepts (notamment sur le principe du dépôt

centralisé et unique) et considèrent que le modèle de CVS est le bon, et que seule

son implémentation est en cause.

o PostgreSQL8.3:

PostgreSQL est un système de gestion de base de données relationnelle et objet

(SGBDRO). C'est un outil libre disponible selon les termes d'une licence de type BSD.

Ce système est concurrent d'autres systèmes de gestion de base de données,

qu'ils soient libres (comme MySQL et Firebird), ou propriétaires (comme Oracle,

Sybase, DB2 et Microsoft SQL Server). Comme les projets libres Apache et Linux,

PostgreSQL n'est pas contrôlé par une seule entreprise, mais est fondé sur une

communauté mondiale de développeurs et d'entreprises.

o Trac 0.10.3:

Trac est un système Open Source de gestion complète de projet par

Internet/Intranet procurant une interface de contrôle de version de « subversion ».

o Firefox :

Mozilla Firefox est un navigateur Web gratuit, développé et distribué par la Mozilla

Foundation aidée de centaines de bénévoles grâce aux méthodes de développement

Open Source et à la liberté du code source.

Etude préalable

sur 38

4. Etude préalable

4.1. Description de l’existant

Il s’agit d ’un logiciel de suivi de temps nommé TimeIt désigné pour un centre

appel, permettant de comptabiliser le temps consommé par un employé pour une

activité donnée.

Cette solution permet aux responsables du centre d’appel de consulter l’historique

d’activités des employés et de comptabiliser le temps de production brut pour chacun

d’entre eux pour une date ou une période au choix.

TimeIt permet en plus de calculer le temps consommé par un employé dans des

activités de natures différentes tel que :

en état de production,

en pause de déjeuner,

en attente faute de pannes techniques,

en formation,

en réunion…etc.

L’application TimeIt est conçu pour fonctionner en mode client/serveur puisque

elle est destinée pour une utilisation simultanée par plusieurs utilisateurs « l es

employés du centre d’appel », en plus il est fréquent que plusieurs requêtes seront

envoyés simultanément. TimeIt est une application web dynamique utilisant un

SGBD fonctionnant en mode client/serveur.

o Description du champ d’étude :

Le champ d’étude est concentré sur les droits d’utilisateurs (permissions).

TimeIt ne peut être exécutée qu’après avoir s’identifier. Pour que chaque

utilisateur puisse s’identifiée indépendamment elle offre aux utilisateurs autorisées la

possibilité de créer plusieurs comptes.

Il peut exister plusieurs types de comptes:

Etude préalable

sur 38

- Des comptes d’utilisateurs simples,

- Des comptes des superviseurs,

- Des comptes d’administrateurs,

- Des comptes dont leurs privilèges sont au choix.

Pour différencier les utilisateurs les uns aux autres il faudra que chaque utilisateur

appartienne à un groupe ayant un certain niveau hiérarchique et que chaque groupe

ait une ou plusieurs permissions (voir la figure n°4).

La création d’un nouveau compte d’utilisateur est une procédure très fréquente.

Elle est gérée par les supérieurs de l’entreprise pour chaque recrutement d’un nouvel

employé.

Pour créer un nouveau compte il faut donner le nom complet de l’employée, un

login, un mot de passe, l’affecter à un groupe puis valider (voir la figure n° 5).

Permission Groupe

Possède

Avoir

Id

#groupe_parent

nom

*

1

1,n

1,n

Id

nom

FIGURE 4. MODELE ENTITEE-ASSIOCIATION (SIMPLIFIE)

Etude préalable

sur 38

FIGURE 5. CREATION D'UN NOUVEAU COMPTE D'UTILISATEUR

Les groupes sont hiérarchisés de façon que :

Au sommet on trouve le groupe Administrateur.

Au dessous on trouve les groupes fils qu’eux-mêmes peuvent être parent

et ainsi de suite.

Admin

Groupe X

Groupe Z

Groupe R

Groupe U

Groupe Y

Groupe V Groupe W

FIGURE 6. HIERARCHIE DES GROUPES

Etude préalable

sur 38

4.2. Critique de l’existant

TimeIt est en phase de test « Beta », nécessitant encore quelques corrections

pour passer à la version stable 1.0. L’une des nécessitées urgentes est lié avec la

gestion des utilisateurs et la restriction des actions.

o Tâches demandés:

Lors de l'édition ou création d’un nouveau compte d’utilisateur:

- Ne pas affecter un utilisateur à un groupe plus haut que le

groupe au quel appartient l'acteur (C’est le point qui sera

traiter dans ce rapport).

- Ne pas éditer des utilisateurs équivalents ou supérieurs

hiérarchiquement

Lors de la suppression d’un utilisateur:

- Ne pas effacer un utilisateur équivalent ou supérieur

hiérarchiquement

Il est noté que l’assignation des tâches est dirigée par le chef de projet, utilisant

une technique de collaboration employée par la communauté Open Source, l’une des

applications répondant à cette technique est nommée Trac.

Pour utiliser Trac il faut avoir un accès au serveur de l’entreprise et un compte

d’accès propre à ce dernier. L’accès se fait via l’adresse

http://dev.shark.tux/tridev/timeit (voir la figure n°7).

http://dev.shark.tux/tridev/timeit

Etude préalable

sur 38

FIGURE 7. GESTION DU PROJET TIMEIT SOUS TRAC

4.3. Solutions proposées

Comme une bonne solution, on a décidé que chaque groupe aura un poids

définissant son niveau hiérarchique de façon que le groupe le plus haut

hiérarchiquement et celui ayant le poids le plus faible.

Le contrôle de la permission d’utilisateurs s’effectue par la comparaison des poids

des groupes aux qu’ils appartiennent les utilisateurs.

Etude conceptuelle

sur 38

5. Etude conceptuelle

D’après le modèle entité association (voir la figure n°4) et le schéma hiérarchique

des groupes (voir la figure n°6), on interprète que chaque utilisateur est affecté à un

seul groupe et que chaque groupe possède un seul groupe parent, définit par la clé

étrangère qui réfère à la clé primaire de la même entité « Groupe », cette relation

résulte un arbre (hiérarchique) de groupes.

o Idées proposées :

On doit savoir au début le niveau du groupe de l’utilisateur connecté par

rapport à un autre. Cette idée se traduit par l’ajout d’un nouvel attribut

« poids » de type entier dans l’entité « Groupe » (voir la figure n°8) qui

va nous permettre de savoir à quel niveau appartient le groupe.

En allant du bas en haut le poids s’affaiblit et vice-versa. L’administrateur

ne possédant pas de parent aura le poids 0 (voir la figure n°9).

Permission Groupe

Possède

Avoir

Id

#groupe_parent

nom

poids

*

1

1,n

Id

nom

1,n

FIGURE 8. MODELE ENTITE ASSOCIATION APRES AJOUT DE L'ATTRIBUT POIDSS

Etude conceptuelle

sur 38

FIGURE 9.HIERARCHIE DES GROUPES AVEC LES DIFFERENTS NIVAUX

L’interdiction d’affectation de l’utilisateur à créer à un groupe interdit se fait

par l’élimination des groupes les plus hauts hiérarchiquement de la liste de

sélection du groupe.

Pour que TimeIt soit une application sécurisée on ajoute un contrôle au

niveau de l’action.

Réalisation

sur 38

6. Réalisation

Pour clarifier les différentes procédures, on a réparti l’exécution en 7 étapes :

6.1. 1ère étape: Extraction du projet depuis le dépôt

L’extraction de la dernière version de la source de l’application TimeIt se fait via

l’outil subversion-client et plus précisément en utilisant la commande « svn » avec

l’option checkout « co » -1er paramètre (voir la figure ci-dessous).

FIGURE 10. EXTRACTION DU PROJET TIMEIT DEPUIS LE DEPOT

http://dev.shark.tux/svn/tritux/timeit/trunk - le 2ème paramètre

représente l’emplacement la dernière version du projet sur le serveur.

timeit –le 3ème paramètre, représente la destination qui sera le chemin

relatif du projet dans la machine locale (copie de travail).

Après l’extraction « checkout » le dossier racine du projet renfermera une dizaine

de répertoires, cette structure est définit par le Framework Symfony.

http://dev.shark.tux/svn/tritux/timeit/trunk

Réalisation

sur 38

Figure 11. Structure du projet

6.2. 2ème étape: Configuration de la base de données

Le projet qu’on vient de l’extraire du dépôt, contient déjà la structure de la base

de données. Cette structure est enregistrée dans le fichier

timeit/config/schema.yml. En plus quelques données basiques telles que les

groupes, les utilisateurs et les activités de base sont enregistrées dans plusieurs

fichiers au format YAML sous le répertoire timeit/data/fixtures

Ces données existent statiquement dans des fichiers mais pas encore pour notre

SGBD « MySQL ».

Avant de procéder à la création de la base de données il faut tout d’abord

consulter le contenu du fichier de configuration de la base de données de notre

projet. Le fichier timeit/config/propel.ini qui contient tout les paramètres de la

base de données à créer (voir la figure ci-dessous).

Réalisation

sur 38

On distingue les informations suivantes :

1. timeit : Nom de l’utilisateur

2. tiadmin : Mot de passe

3. localhost : Nom de l’hôte

4. timeit : Nom de la base de données

Configuration du nom de l’hôte :

localhost est déjà le nom d’hôte par défaut de notre machine.

La création d’un nouvel utilisateur et une base vide nécessite l’outil

MySQL CLI pour la console de Linux. La figure ci-dessous explique cette

procédure.

1 2 3 4

FIGURE 12. CONTENU DU FICHIER DE CONFIGURATION DE LA BD

Réalisation

sur 38

FIGURE 13. CREATION DE LA BASE DE DONNEES ET LE NOUVEL UTILISATEUR

Connexion en tant que timeit et vérification de l’existence de la base de

données récemment crée. (Voir la figure n°14)

FIGURE 14. VERIFICATION DE L 'EXISTENCE DE LA BASE POUR LE NOUVEL UTILISATEUR

Pour le moment on a définit un nouvel utilisateur ayant tout les privilèges pour

exploiter sa nouvelle base de donnée. Cette base ne possède pas encore des tables

(pas de structure).

Réalisation

sur 38

Maintenant il nous reste qu’a : générer les modèles, donner une structure à notre

base et l’alimenté par des données.

Symfony offre une option qui effectue ces trois taches d’une façon automatique.

FIGURE 15. GENERATION DES MODELES, STRUCTURATION DE LA BASE DE DONNEES ET CHARGEMENT DES DONNEES

Maintenant notre base de données possède une structure en plus qu’elle contienne

des données primaires. On peut maintenant lancer l’application pour vérifier le bon

fonctionnement via l’adresse http://localhost/projects/unstable/timeit/web. (Une

page d’authentification doit s’afficher).

6.3. 3ème étape : Dans la couche Modèle

o Ajout de l’attribut poids « weight » dans la table Groupe « sf_guard_group » :

Comme on l’a déjà mentionné précédemment il faut tout d’abord modifier la table

Groupe nommé « sf_guard_group » dans notre projet, et ceci en ajoutant un

attribut poids « weight » de type entier. Pour l’implémenter dans notre projet on

ouvre le fichier timeit/config/sfGuardPlugin_schema.custom.yml qui contient

le squelette de la table Groupe et Utilisateur écris au format YAML, et on ajoute

ensuite le nouvel attribut « weight » Comme le montre (la figure n° 16)

FIGURE 16. AJOUT DE L 'ATTRIBUT "WEIGHT"

o Surcharge de la méthode « save » de la classe mère « PluginsfGuardGroup » :

Avant de penser à surcharger la méthode save() de la classe

PluginsfGuardGroup, il faut tout d’abord penser à la façon dont la quelle la valeur

de « weight » sera attribuée lors de la création d’un nouveau groupe, es-ce que c’est

manuellement ou automatiquement ?

http://localhost/projects/unstable/timeit/web

Réalisation

sur 38

Le cas le plus simple et de choisir le premier choix, mais faut-il chercher à chaque

fois le niveau hiérarchique du groupe parent puis l’incrémenter par un pour créer le

nouveau groupe ? Que se passe-il si un utilisateur assigne au poids une valeur

quelconque ?

Donc la manière la plus propre et d’automatiser cette opération juste au moment

de la création du nouveau groupe.

On sait bien que Symfony intègre Propel qui traduit tout ce qui est modèle

relationnelle en modèle objet. Propel a déjà traduit l’entité Groupe

« PluginsfGuardGroup» en une classe et ses attributs en attributs de classe, cette

classe possède en plus des propriétés telque « getweight() »,

« getParentGroup() » et des méthodes tel que « save() », « delete() »…

Propel offre deux classes pour chaque table ; une qui est mère

« PluginsfGuardGroup » ayant les différents attributs, propriétés et méthodes et une

autre classe fille « sfGuardGroup » qui l’hérite et n’ayant aucune implémentation.

C’est dans la classe fille où on va implémenter la méthode save() qui existe déjà

dans la classe mère, cette dernier permette l’enregistrement des données d’un

nouveau groupe dans la base de donnée.

Pour automatiser cette procédure comme on l’a déjà mentionner précédemment il

faudra donc redéfinir notre propre méthode save(). En langage d’objet cette

technique s’appelle surcharge.

Réalisation

sur 38

FIGURE 17.SURCHARGE DE LA METHODE SAVE()

o Mise à jour des modèles et la base de données:

Une fois qu’on a enregistré les modifications, on doit obligatoirement mettre à

jours la structure et les données de notre base de données, ce qui va ajouter le

nouvel attribut « weight » à la table sfGuardGroup comportant une valeur qui

répond au poids du groupe correspondant

FIGURE 18.GENERATION DES MODELES, STRUCTURATION DE LA BASE DE DONNEES ET CHARGEMENT DES DONNEES

6.4. 4ème étape : Dans la couche Vue

o Implémentation d’un comparateur de poids getCompareWeight():

Il est très pratique d’implémenter une solution par la quelle notre application

connaitra le niveau hiérarchique d’un groupe par rapport à un autre.

On distingue par conséquence 3 états:

Réalisation

sur 38

- Poids de X < Poids de Y X est parent de Y : désigné par la

valeur 0

- Poids de X = Poids de Y X et Y sont frères : désigné par la

valeur 1

- Poids de X > Poids de Y X est fils de Y : désigné par la valeur

2

Cette solution est très simple à implémenter en plus qu’elle sera employée dans

toutes les situations où on veut contrôler un utilisateur. On aura donc plusieurs

appels à cette méthode. Symfony recommande l’implémentation des méthodes

fréquemment appelées dans le fichier timeit/lib/myTools.class.php.

FIGURE 19. IMPLEMENTATION DE LA METHODE GETCOMPAREWEIGHT()

o Modification de la liste de choix des groupes:

Si on pose cette question : Est-il logique qu’un simple employé créa un compte

d’un superviseur ou d’administrateur? Sûrement que ça n’a aucun sens !

La meilleur méthode est de limiter la liste de choix des groupes selon le poids du

groupe au qu’il appartient l’acteur. Par exemple : L’utilisateur Alpha dont le poids de

son groupe est 2 aura le droit de créer des utilisateurs ayant le même poids que sont

groupe ou plus, veut dire les groupes dont le poids est 2, 3, 4,5… et ainsi de suite.

Les groupes ayant les poids 0 et 1 ne doivent pas être affichés.

Réalisation

sur 38

6.5. 5ème étape : Dans la couche Contrôleur

o Ajout de contrôle dans la méthode executeCreate() :

La méthode executeCreate() de la couche contrôle représente la logique de

l’opération d’ajout d’un nouvel utilisateur dans la base de donnée, et ce qu’on vient

de faire dans l’étape précédente représente un contrôle au niveau de l ’interface.

La base de donnée prend compte du nouvel utilisateur juste après la validation de

ses informations ; tel que son, le mot de passe et l’identificateur du groupe au qu’il

appartient. On vient précédemment d’implémenter une solution éliminant de la liste

de choix les groupes ayant un niveau hiérarchique plus haut que ce lui de l’acteur.

On se pose cette question : A quoi sert un deuxième test dans la couche

contrôleur tant que la liste des groupes comporte uniquement ceux qui sont

autorisées ? Tout simplement c’est une raison de sécurité.

Le diagramme ci-dessous expliquera la logique de ce contrôle.

Réalisation

sur 38

Si validation

du formulaire

Page : Erreur 404 BD

TimeIt

Poids de l’acteur

<=

Poids de

l’utilisateur à créer

Vrai

Vrai

Page : Liste des tous les utilisateurs

Faux

Page : Edit (user)

Faux

Contrôle

Afficher

Afficher

Afficher

FIGURE 20.ORDINOGRAMME « EXECUTECREATE() »

Réalisation

sur 38

La figure 30 montre la modification apportée à la méthode executeCreate(). Les

lignes de 32 à 36 représentent le contrôle.

FIGURE 21. AJOUT DU CONTROLE AU NIVEAU DU CODE

6.6. 6ème étape : Le test

Cette étape est vue la plus importante malgré qu’on a fini les implémentations,

mais qui assure son bon fonctionnement et la stabilité ? Il faut certainement exécuter

une série de test pour s’assurer ?

Si on s’identifie en tant qu’un superviseur on va constater que lors de la création

d’un nouveau compte d’utilisateur ; la liste de choix ne contient que les groupes dont

leur niveau hiérarchique est égal et inférieure au groupe à lequel on appartient ( voir

la figure n°22 ), ceci prouve que la modification subite au niveau couche vue a bien

jouée son rôle,

Il est aussi nécessaire de réaliser un test avancé pour être sûr que le contrôle

ajouté dans la couche contrôleur ne présentant aucun problème.

Malheureusement ce test ne fera pas objet de ce rapport pour la raison qu’il

nécessite trop de proèdres pour qu’on puisse le traiter. Il se présente par une

technique utilisée par les pirates pour attaquer certains sites web.

Réalisation

sur 38

FIGURE 22.AJOUT D'UN NOUVEAU UTILISATEUR

o

6.7. 7ème étape : Mise à jour du dépôt.

Il nous reste maintenant qu’a mettre à jour la version du dépôt (qui existe sur le

serveur) pour que tout les participants à ce projet peuvent voir les changements et

les améliorées.

La commande svn commit transfère au serveur uniquement les fichiers qui ont

subits des modifications. Tous les développeurs peuvent actualiser leur copie de

travail via la commande svn up.

Figure 23. Mettre à jour la version du dépôt

Conclusion

Ce stage au sein de TriTUX m’a fait découvrir la vie professionnelle dans une

entreprise ayant une importante clientèle au niveau de la taille. L’esprit de la

collaboration de la communauté Open Source y est très présent, et l’aspect de la

technicité et de perfectionnisme apparaît dans chaque tâche.

Cette période de quatre semaines, bien que m’ayant peu apporté au niveau

enrichissement de connaissances techniques et scientifiques, m’a permis de

développer une méthodologie rigoureuse et efficace pour pouvoir participer au

développement du projet TimeIt. J’ai pris conscience de l’importance du savoir-être

(être dynamique, être motivé…) et des relations humaines seules capables des faire

avancer les choses.

Glossaire

BSD: Berkel ey Sof tware Dis tribu tion

CLI: Command Line Interface

CVS: Concurrent Versions System

GNU: Gnu 's Not Unix

HTML: HyperTex t Markup Language

HTTP: Hyper text T ransfer Pro to col

IDE: Integrated Developm en t Environm ent

JBOD: Just a Bunch O f Di sks

LDAP: Lightweight Dir ector y Access Pro tocol

MMS: Mul timedia Messaging Servi ce

MVC: Model V i ew Controll er

NTIC : Nouvelles Technologies de l ’Inform ati on et de l a

Communication

ORM: Object Relational Mapping

PHP: Hyper tex t Pr epro cessor

SGBD : Systèm e de Gestion de Base de données

SGBDRO : Systèm e de Gestion de Bases de Données Obj ets

SMS: Shor t Message Servi ce

SQL: Str uctured Query Language

SSII : Soci été de Servi ce et d ’Ingéni eri e de l ’Inform ati que

SVN: SubVer sio N

VoIP: Voi ce Over IP

XML: eX tensibl e Markup Language

YAML: Yaml A in’ t Markup Language

Netographie

http://fr.wikipedia.org/wiki/Symfony Symfony Wikipedia 22 février 2009

http://fr.wikipedia.org/wiki/Apache_(logiciel) Apache http Server

Wikipedia 20 février 2009

http://fr.wikipedia.org/wiki/Mysql MySQL Wikipedia 24 février 2009

http://fr.wikipedia.org/wiki/Php PHP:Hypertext

Preprocessor

Wikipedia 26 février

2009

http://fr.wikipedia.org/wiki/Zend_(informatique) Zend (informatique)

Wikipedia 6 février 2009

http://fr.wikipedia.org/wiki/Subversion Subversion Wikipedia 7 février 2009

http://fr.wikipedia.org/wiki/PostgreSQL PostgreSQL Wikipedia 26 février

2009

http://fr.wikipedia.org/wiki/trac Trac Wikipedia 1 janvier

2009

http://fr.wikipedia.org/wiki/Firefox Mozilla Firefox Wikipedia 21 février 2009

http://fr.wikipedia.org/wiki/Symfony

http://fr.wikipedia.org/wiki/Apache_(logiciel)

http://fr.wikipedia.org/wiki/Mysql

http://fr.wikipedia.org/wiki/Php

http://fr.wikipedia.org/wiki/Zend_(informatique)

http://fr.wikipedia.org/wiki/Subversion

http://fr.wikipedia.org/wiki/PostgreSQL

http://fr.wikipedia.org/wiki/trac

http://fr.wikipedia.org/wiki/Firefox

rapport stage de perfectionnement - application de suivi de temps web2.0 sous symfony framework...

Documents