Fil d'Ariane
  • 30 minutes
  • Moyenne
Connectez-vous ou inscrivez-vous pour bénéficier de toutes les fonctionnalités de ce cours !

Introduction du cours

Dans certaines applications web, on fait la distinction entre des profils d'utilisateur, par exemple quand on veut distinguer un administrateur d'un simple rédacteur : certains auront le droit de modifier des éléments, d'autres non.

Dans ce cours, vous allez utiliser un framework php (dont je suis l'auteur), le mkframework, pour créer une application où les utilisateurs pourront se connecter et se voir attribuer différents droits :

  • un utilisateur administrateur pourra administrer les utilisateurs, les droits des profils et leur assigner des profils ;

  • un utilisateur rédacteur pourra rédiger ceux-ci ;

  • et enfin un utilisateur validateur pourra les valider.

Modélisez les utilisateurs dans une base de données

Avant de commencer à coder, vous allez d'abord créer la base de données qui nous servira de socle pour bâtir votre application.

Cette base nous servira à stocker les éléments soumis à droits, les utilisateurs, leurs groupes et les permissions qui donneront droit à tel ou tel groupe d'accéder/d'interagir avec tel autre éléments.

Le modèle de données

Avant de commencer à créer une base de données, il est judicieux de se poser pour bien définir son besoin. Pour cela il existe des bonnes pratiques, notamment le MCD (Modèle Conceptuel de Données) qui permet de représenter ses tables sous forme d'un schéma clair.

Ce type de schéma permet également de visualiser facilement les liens/interactions entre les différentes tables que nous allons créer, il permet notamment d'identifier les FK (clés étrangères, ou foreign keys en anglais) qui sont des champs contenant l'identifiant d'un élément dans une autre table.

Par exemple pour les permissions on ne va pas marquer en "dur" pour chaque permission "guest" ou "admin", on va y insérer les identifiants des groupes (ça prend moins de place et ça permet de pouvoir renommer les groupes).

Voici le schéma MCD représentant la base de données que vous allez créer avec les tables et leurs liens.

MCD
MCD (Modèle Conceptuel de Données)

Vous pouvez voir sur la figure ci-dessus les différentes tables dont on a besoin dans notre base de données : 

  • La table users contient les utilisateurs avec un champ pour lui renseigner un groupe ;

  • La table groups renseigne les groupes/profils ;

  • La table actions contient les verbes à vérifier ;

  • La table items contient les éléments à soumettre à droits ;

  • La table permissions précise pour chaque profil des listes d'actions autorisées sur certains éléments. On pourra ainsi paramétrer le profil "admin" pour qu'il soit autorisé à modifier les droits des "users", le profil "validateur" pour qu'il puisse "valider" les "articles", etc.

La requête SQL

Exécutez la requête suivante pour créer les tables.

CREATE TABLE `users` (
`id` int(11) NOT NULL auto_increment,
`login` varchar(150) NOT NULL,
`password` varchar(150) NOT NULL,
`groups_id` INT NOT NULL,
PRIMARY KEY  (`id`)
);

CREATE TABLE `groups` (
`id` int(11) NOT NULL auto_increment,
`name` varchar(50) NOT NULL,
PRIMARY KEY  (`id`)
);

CREATE TABLE `permissions` (
`id` int(11) NOT NULL auto_increment,
`action_id` INT NOT NULL,
`item_id` INT NOT NULL,
`allowdeny` varchar(50) NOT NULL,
`groups_id` int(11),
PRIMARY KEY  (`id`)
);

CREATE TABLE `actions` (
`id` int(11) NOT NULL auto_increment,
`name` varchar(50) NOT NULL,
PRIMARY KEY  (`id`)
);

CREATE TABLE `items` (
`id` int(11) NOT NULL auto_increment,
`name` varchar(50) NOT NULL,
PRIMARY KEY  (`id`)
);

Connectez votre application à la base de données

Maintenant que vous avez défini votre base de données, vous allez créer une application avec le mkframework et la relier à cette base.

Créez votre application avec le mkframework

Commencez par télécharger le mkframeworkpour l’installer (ou plutôt pour installer son builder).

Téléchargez l’archive zip et décompressez-la dans le répertoire web de votre serveur Apache.
Ouvrez votre navigateur à l'adresse localhost, et rendez-vous sur le répertoire précédemment extrait.

Le builder
Le builder du mkframework

Renseignez le champ "monApplication" et validez avec le bouton "Créer".

Vous êtes redirigé sur la page listant les projets :

Builder, liste des projets
Builder, liste des projets

Paramétrez votre application

La base a été créée, l'application également, il vous faut maintenant les connecter ensemble.

Nous allons laisser le navigateur de coté un instant pour aller éditer un fichier de votre application.

Dans votre application (générée dans le répertoire data/genere du builder), vous avez un répertoire conf/  dans lequel il y a plusieurs fichiers de configuration.
Éditez le fichier conf/connexion.ini.php  pour renseigner la connexion à votre base de données MySQL.

;<?php die()?>
[db]
aclDatabase.dsn="mysql:dbname=aclDb;host=localhost"
aclDatabase.sgbd=pdo_mysql
aclDatabase.username=root
aclDatabase.password=root

Retournons à notre navigateur (ouvert sur le builder).

Cliquez sur le bouton "Editer le projet", vous verrez alors les options suivantes s’afficher :

Builder, menu de génération d'un projet
Builder, menu de génération d'un projet

Le mkframework est un framework MVC (Modèle-Vue-Contôleur) utilise une couche modèle pour accéder aux données . Cliquez donc sur "Créer la couche modèle".

Builder, création de la couche modèle 1/2
Builder, création de la couche modèle 1/2

Le builder (générateur web) vous liste les profils présents dans votre fichier conf/connexion.ini.php.

Cliquez sur le profil aclDatabase que vous venez de créer.

Builder, création de la couche modèle 2/2
Builder, création de la couche modèle 2/2

Le builder utilise le profil de connexion sélectionné pour lister les tables qu'il voit.

Validez avec le bouton "Générer". Le builder génère ainsi une classe pour chaque table que vous avez cochée.

Demandez aux utilisateurs de se connecter

Pour gérer les droits, il faut d'abord identifier l'utilisateur connecté, vous allez donc ajouter un module d'authentification à votre application.

Dans le générateur web, cliquez sur "Créer un module d'authentification avec inscription".

Builder, création d'un module d'authentification 1/2
Builder, création d'un module d'authentification 1/2

Le builder vous demande quel classe modèle utiliser pour les utilisateurs, sélectionnez model_users. Vous devez ensuite sélectionnez les champs en base de données où seront stockés le nom d'utilisateur et le mot de passe : sélectionnez login  et password .

Builder, création d'un module d'authentification 2/2
Builder, création d'un module d'authentification 2/2

Le builder vous indique qu'il faut modifier la classe model_users.php  pour y ajouter deux méthodes.

Copiez ces deux méthodes (affichées sur le builder) dans votre classe modèle. Pour cela, vous pouvez :

  • soit éditer la classe en question via votre éditeur de codephp ;

  • soit cliquer sur le lien model_users  qui vous amènera dans l'explorateur de projet directement sur la classe à modifier.

Builder, explorateur de projet
Builder, explorateur de projet

Une fois ceci fait, cliquez sur le bouton "réactualiser la page". Le builder nous affiche alors un formulaire différent :

Builder, retour sur création module d'authentification 1/2
Builder, retour sur création module d'authentification 1/2

On voit que le module d'authentification utilisera les méthodes getListAccount()  et hasPassword()  du model model_users .
On voit également le couple module/action redirigé une fois l'authentification faite.
Et enfin on voit les champs utilisés pour le nom d'utilisateur et le mot de passe, comme indiqué précédemment.

Validez le formulaire en cliquant sur le bouton "Générer le module d'authentification".

Builder, retour sur création module d'authentification 2/2
Builder, retour sur création module d'authentification 2/2

On vous demande ici d'activer la variable enabled  dans la section [auth]. Pour cela, vous pouvez soit cliquer sur le lien conf/site.ini.php, soit éditer directement le fichier de configuration.

Builder, explorateur de projet
Builder, explorateur de projet

Une fois cette variable passée à 1 , vous pouvez cliquez sur le lien "voir le site".

Votre application, formulaire d'authentification
Votre application, formulaire d'authentification

Rentrons dans le vif du sujet: l'application est créée, elle permet d'identifier les utilisateurs, vous allez maintenant pouvoir ajouter cette fameuse gestion de droits.

Utilisez le builder pour gagner du temps

Dans le builder, cliquez sur "Ajouter une gestion de droits à votre application Beta".

Builder, génération de gestion de droits 1/3
Builder, génération de gestion de droits 1/3

Le builder vous indique les tables nécessaires pour une gestion de droits : ça tombe bien, on les a déjà créées ! Mais si ce n'était pas le cas, vous avez sous le schéma la requête SQL pour le faire.

En scrollant, le builder vous demande de faire le lien entre votre base de données et le schéma théorique.

Builder, génération de gestion de droits 2/3
Builder, génération de gestion de droits 2/3

Ici, il vous faut indiquer pour chaque table théorique, la classe modèle correspondante, puis il faut indiquer la même chose pour les champs des tables.

Sélectionnez les champs correspondant en vous aidant du schéma ainsi que des chiffres indicatifs.

Cliquez enfin sur le bouton "Générer".

Builder, génération de gestion de droits 3/3
Builder, génération de gestion de droits 3/3

Le builder vous affiche un lien vers le module de gestion de droits généré. Vous avez également un morceau de code à copier dans votre module d'authentification.

Copiez les deux lignes ci-dessous (comme indiqué sur le builder), qui vont permettre à votre application de charger les droits par rapport à l'utilisateur connecté.

<?php

$oUser=_root::getAuth()->getAccount();
model_rightsManager::getInstance()->loadForUser($oUser);

Éditez le fichier module/auth/main.php , et rendez-vous  en fin de méthode checkLoginPass().

<?php
(...)
    private function checkLoginPass(){
    (   
        (...)
		
		//on charge ici les droits
		 $oUser=_root::getAuth()->getAccount();
		model_rightsManager::getInstance()->loadForUser($oUser);
		
        
		_root::redirect('default::index');
	}

Collez ces deux lignes juste avant la redirection (une fois que l'utilisateur a bien été vérifié et identifié).

Générez ensuite un module menu pour votre application

Vous allez maintenant ajouter un menu afin de naviguer dans votre application : cliquez sur "Créer un module menu".

Builder, génération d'un module menu 1/2
Builder, génération d'un module menu 1/2

Ici, vous cochez les couples module/actions pour lesquels vous souhaitez créer une entrée dans le menu.

Validez le formulaire en pressant le bouton "Générer le menu".

Builder, génération d'un module menu 2/2
Builder, génération d'un module menu 2/2

Le builder vous a généré le module d'authentification et vous affiche une ligne à ajouter dans la méthode before() des modules default et rightsManager (créé à l'instant par le builder pour gérer les droits).

<?php 
class module_default extends abstract_module{
    
	public function before(){
		$this->oLayout=new _layout('template1');
		
		//assignez le menu a l'emplacement menu
		$this->oLayout->addModule('menu','menu::index');
	}

Cliquez enfin sur "voir le site", vous arrivez sur le formulaire de login. Cliquez sur le lien inscription et enregistrez deux utilisateurs "admin" et "redac" , identifiez-vous ensuite avec le compte "admin".

Votre application (incluant le menu fraichement généré)
Votre application (incluant le menu fraîchement généré)

Ajoutez des droits à vos utilisateurs

Vous avez ajouté une gestion de portes (gestion de droits), il va falloir ajouter les serrures (vérification d'accès) et définir à quels groupes donner quelles clés (donner des permissions aux groupes).

Éditez le module "menu" : ouvrez le fichier module/menu/main.php .

<?php
Class module_menu extends abstract_moduleembedded{
    	
	public function _index(){
		
		$tLink=array(
			'Accueil' => 'default::index',
			'Droits' => 'rightsManager::index',
			'Se deconnecter' => 'auth::logout',

		);
		
		$oView=new _view('menu::index');
		$oView->tLink=$tLink;
		
		return $oView;
	}
}

Comme vous le voyez, un tableau liste les liens du menu (la clé du tableau est le libellé, tandis que la valeur est la valeur module/action) .

Vous allez ajouter après cette initialisation une boucle vérifiant les droits.

<?php
Class module_menu extends abstract_moduleembedded{
    	
	public function _index(){
		
		$tLink=array(
			'Accueil' => 'default::index',
			'Droits' => 'rightsManager::index',
			'Se deconnecter' => 'auth::logout',

		);
		
		foreach($tLink as $sLabel => $sLink){
			//si l'utilisateur n'a pas le droit d'acceder au lien
			if(!_root::getACL()->can('access',$sLink) ){
				//on supprime le lien du menu
				unset($tLink[$sLabel]);
			}
		}
		
		$oView=new _view('menu::index');
		$oView->tLink=$tLink;
		
		return $oView;
	}
}

Renseignez les permissions.

Revenons à votre application, cliquez sur le lien "Droits", vous voyez ainsi le module généré précédemment par le builder :

Votre application, menu gestion de droits
Votre application, menu gestion de droits

Cliquez sur le lien "New".

Votre application, menu gestion de droits: ajout de permission
Votre application, menu gestion de droits: ajout de permission

Vous allez ajouter un droit d'accès sur la liste des liens précédemment vus dans le module "menu".

Mais dès la première insertion, vous perdez le menu : en effet, la gestion de droits est désormais active.

Si vous cliquez sur le bouton Permissions, vous voyez les demandes de permissions effectuées et le fait que les lignes sont rouges indique un refus du framework :

Barre de debug, affichage des permissions
Barre de debug, affichage des permissions

En dessous du tableau des permissions, vous voyez un tableau des utilisateurs : cliquez sur votre utilisateur "admin" et renseignez son profil "administrateur".

Lorsque vous revenez, vous n'avez toujours pas le menu et c'est normal. Normal, car pour des raisons de performance, les droits ne sont chargés qu'au login, c'est pour cela que l'ajout de droits n'est pas pris en compte.

Finissons d'ajouter les liens rightsManager::index et auth::logout.

Votre application, affichage des groupes et utilisateurs
Votre application, affichage des groupes et utilisateurs

Vous allez également ajouter les droits pour les rédacteurs : juste la page d'accueil et le lien de déconnexion.

Votre application, affichage des permissions
Votre application, affichage des permissions

Assignez le profil redacteur  à l'utilisateur redac.

Et voyez le résultat !

Déconnectez-vous (en entrant dans l'URL index.php?:nav=auth::logout ) et connectez-vous avec le compte "admin".

Votre application, affichage avec permissions validées
Votre application, affichage avec permissions validées

Comme vous pouvez le voir, on a bien notre menu rempli, et en cliquant sur le bouton "permissions", on voit bien nos trois liens en vert.

En revanche, si vous vous connectez avec le compte "redac", vous avez un menu limité :

Votre application, mise en avant d'une permission refusée
Votre application, mise en avant d'une permission refusée

Vous voyez bien dans la liste de debug que le module de gestion de droits est en rouge, ce qui est confirmé dans l'affichage du menu.

Il faut également vérifier dans le module de gestion de droits que l'utilisateur connecté a bien le droit de s'y rendre.

Pour cela, éditez le fichier module/rightsManagement/main.php , et ajoutez ce qui suit dans la méthode before():

<?php
class module_rightsManager extends abstract_module{
    
	public function before(){
		
        //on verifie les droits au debut du module
		if(!_root::getACL()->can('access','rightsManager::index') ){
			//si il n'a pas le droit d'etre ici
			//on le redirige
			_root::redirect('default::index');
		}
		
		$this->oLayout=new _layout('template1');
		
		$this->oLayout->addModule('menu','menu::index');
	}

Conclusion

Et voilà, vous savez maintenant ajouter une gestion de droits à votre application web avec le mkframework ! J'espère que vous avez pu apprécier le confort du builder de ce framework et le temps qu'il vous fait gagner.

Vous l'avez sûrement remarqué : le menu de génération est bien fourni et propose bon nombre d'actions pouvant vous faire gagner un temps précieux. Mais ce n'est pas tout : ce framework publié fin 2009 ne cesse d'évoluer, et depuis quelques mois, le framework s'est doté d'un market permettant non seulement de mettre à jour votre builder avec de nouvelles fonctionnalités, mais également d'en profiter et de faire profiter la communauté du framework.

Le market permet d'ajouter des extensions à votre builder
Le market permet d'ajouter des extensions à votre builder
Le market application permet d'ajouter modules et plugin à votre application.
Le market application permet d'ajouter modules et plugin à votre application.

J'espère que ce cours vous aura donné envie de découvrir un peu plus ce framework et d'y contribuer en développant vos propres modules. Et n'oubliez pas de garder en tête ce dernier conseil : pensez au principe DRY : Don't Repeat Yourself. Ne vous répétez pas : capitalisez !
Quand vous développez un module : demandez-vous si vous ne risquez pas d'en avoir besoin dans une future application. Idem pour les classes, privilégiez les plugins au classes métiers "fourre-tout".

Merci d'avoir lu ce cours, et bonne continuation avec PHP !

Aussi sur OpenClassrooms

Programmez en orienté objet avec PHP

Programmez en orienté objet en PHP

Exemple de certificat de réussite
Exemple de certificat de réussite