IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)

Documentation de l'Aedituus


précédentsommairesuivant

III. Support de l'utilisateur

Pour gérer la session, sont obligatoires les fichiers
  • user.class.php
  • session.class.php (ou sessionphp.class.php)
  • interface.php (définition de l'interface iSession)
  • mysql.class.php
  • dbmanager.class.php
  • commun.php
  • fonction.php
et les tables
  • membres
  • sessions
  • session_vars
  • membre_vars
  • champs
  • champs_value

III-A. Classe Csession.class.php

L'explication ci-dessous ne compte que pour session.class.php (le fichier sessionphp.class.php sera traité plus tard)

La class CSession est une implémentation du support d'une session utilisateur alternative à celle de PHP. Elle n'utilise pas ce qui est présent dans PHP (c'est à dire les session_start()...).

Cette classe n'est pas utilisée directement, elle est la classe mère de la classe CUser, qui correspond, elle, au support de l'utilisateur en général. L'héritage s'explique par le fait que le support d'un utilisateur comprend le support de sa session. De plus, la classe CSession n'est ainsi pas instanciée directement, ce qui évite aux données "sensibles" tels que l'id de session d'être accessible depuis le reste du script. Il y a 3 données membres de CSession qui sont accessibles depuis la classe CUser (et que de cette classe, jamais du reste du script)

Données membres protected de la classe CSession
  • $session_logged_in qui indique à la classe CUser que l'utilisateur actuel s'est connecté,
  • $session_user_id qui correspond à l'Identifiant du membre dans la table membres
  • $session_ip qui est à la fois une donnée de session et une donnée de l'utilisateur.

Cette classe utilise un cookie pour identifier l'utilisateur durant sa navigation. Elle n'utilise pas du tout le passage de l'identifiant de session par URL, car ceci est considéré comme une potentielle faille de sécurité. Elle utilise un 2ième identifiant de session, qu'on appelle Token, qui change à chaque page. Ce dispositif rend très difficile le vol de session, mais présente un défaut : si le hacker vole la session alors que l'utilisateur vient de finir sa navigation, sans se déconnecter, le token n'empêchera pas le vol de la session.

La session est initialisé dès la première page, que le visiteur soit connecté et reconnu comme membre, ou non connecté reconnu comme visiteur.

Enfin, pour finir, une surcharge des opérateurs d'affectation (setter) et les accesseurs (getter) permet une utilisation de la classe comme support de stockage des variables de session.

En PHP, ces deux rôles sont confondus dans l'appellation session, mais en réalité, elles sont composées de la partie liaison entre le client et le serveur pour le maintient de la « connexion », et du stockage des nombreuses variables qu'on souhaite attribuer à cette session.

On aurait pu ici externaliser cette fonction de stockage dans une autre classe, mais ça aurait compliqué encore plus.

Pour utiliser le stockage de variable, il faut procéder de cette façon.
  • Déclaration d'un objet de CUser (CSession ne doit pas être utilisée directement)
  • Pour affecter :$user->ma_variable = 'Hello world';
  • Pour récupérer : echo $user->ma_variable ;    // Hello world

Ces variables sont stockées dans la table session_vars. La classe redéfinit les opérateurs isset et unset pour ce type de variable, mais ceci est transparent pour le développeur.

Ne pas utiliser le tableau $_SESSION

liste des méthodes publiques
Sélectionnez
	interface iSession 
	{ 
	    public function session_begin(); 
	    public function connectUser( $id_user ); 
	    public function deconnectUser(); 
	    public function isConnected(); 
	    public function identifieUser( $id_user ); 
	    public function getSessionVars(); 
	    public function getIP(); 
	};

III-B. Classe Csessionphp.class.php

La classe CsessionPHP implémente l'interface iSession ci-dessus et utilise les sessions PHP, La classe est plus simple à comprendre mais moins souple et contrôlable, car liée à l'implémentation des sessions dans PHP. Elle permet de garder la compatibilité avec d'éventuels scripts existants utilisant les sessions PHP. L'utilisation du tableau $_SESSION est donc possible, mais $user->ma_variable reste utilisable. Les 2 étant reliés, par exemple

Les 2 méthodes sont liées
Sélectionnez
	$_SESSION['hello'] = 'world'; 
	echo $user->hello;    // world

et inversement.

III-C. Classe CUser.class.php

La classe Cuser permet au développeur de manipuler les données de l'utilisateur. Elle est le lien entre la gestion de la session utilisateur et l'interface (le site dans sa globalité).

Elle permet d'accéder aux données du membre
  • Donnée de session à travers les méthodes de la classe Csession
  • Données permanentes provenant de la table membre_vars

Ces dernières ont 2 moyens d'être créées, d'une part lors de l'inscription, si le développeur a ajouté des champs personnalisés (cf.page inscription), d'autre part directement dans le code à l'aide des fonctions :

  • setPermanentVar permettant de créer/modifier une donnée permanente
  • getPermanentVar permettant de la récupérer
  • delPermanentVar permettant de l'effacer.

Il est possible grâce à ces fonctions de modifier les données saisies par l'utilisateur sur le formulaire d'inscription. Pour cette raison, attention au choix des noms lors de la création de celle-ci par les fonctions afin de ne pas écraser les données saisies par l'utilisateur, si ce n'est pas explicitement votre but.

Ces données sont permanentes, ce ne sont pas des variables de session, elles survivent après une déconnexion et sont de nouveau accessibles lors d'une nouvelle connexion.

III-D. Class CUserList.class.php

III-E. Exemple d'utilisation simple

Nous allons voir ici comment créer rapidement un espace membre exploitable en utilisant les classes présentées précédemment, session.class.php, user.class.php et cuserlist.class.php (+ quelques dépendances)
Tout d'abord, dans un répertoire indépendant, créer un répertoire include et placer y les fichiers

Liste des fichiers à mettre dans le répertoire include
  • dbmanager.class.php
  • mysql.class.php
  • interface.php
  • session.class.php
  • user.class.php
  • userlist.class.php
  • fonction.php

dbmanager.class.php et mysql.class.php permettent la connexion à une base de donnée MySQL
interface.php, session.class.php, user.class.php et userlist.class.php sont les classes dont nous avons parlées ci-dessus et sont au coeur de la gestion de l'utilisateur
fonction.php contient quelques fonctions simples

Créons maintenant à la racine 4 fichiers common.php, inscript.php, connect.php et index.php
Le fichier common.php contiendra les includes, la définition de constantes, la connexion à la bdd et la récupération en base de la configuration de l'aedituus.

Code du fichier common.php
Sélectionnez
<?php
define ('PIWARE_ROOT', './');
define ('SESS_NAME', 'piware');
define ('SESS_TIME', 7200);

require_once 'include/dbmanager.class.php';
require_once 'include/mysql.class.php';
require_once 'include/interface.php';
require_once 'include/session.class.php';
require_once 'include/user.class.php';
require_once 'include/userlist.class.php';
require_once 'include/fonction.php';
 
$cfg['prefix']          = 'pw_';

// Connexion à la bdd
$db = db::getInstance('Mysql');
$db->setParam( 'localhost', 'root', '', 'test_aedituus');
$db->connect();

// On récupère la config générale 
$result = $db->get_results( "SELECT co_key, co_value FROM ".$cfg['prefix']."config" );
foreach ($result as $config)
{
    $cfg[$config->co_key] = $config->co_value;
}
?>

La constante PIWARE_ROOT indique le chemin vers la racine et sert à vérifier que les fichiers inclus ne le sont pas par un script externe.
Les constantes SESS_NAME et SESS_TIME définissent respectivement le nom et la durée de la session (en secondes).

III-E-1. L'inscription

Attaquons maintenant la page d'inscription.

Code de la page d'inscription
Sélectionnez
<?php
require_once 'common.php';
$user = CUser::getInstance();
$user->session_begin();

if ( ! empty($_POST['formSend']))
{
    if ( (empty($_POST['login'])) || (empty($_POST['mdp'])) || ($_POST['mdp'] != $_POST['mdp2']) )
    {
        $msg = 'Erreur de login ou mot de passe';
    }
    else
    {
        $user->login = $_POST['login'];
        $user->mdp = $_POST['mdp'];
        $id_membre = CUserList::addUser($user);
        
        if ( is_null($id_membre) )
        {
            $msg = 'Echec inscription';
        }
        else
        {
            $msg = 'inscription réussis';
            $user->connectUser( $id_membre );
            $user->setPermanentVar('eye_color', $_POST['eye_color']);
        }
    }
}


echo '<html>
<head></head>
<body>'.$msg.'<br /><form action="" method="post">
    Pseudo : <input type="text" name="login" value="'.$user->login.'" /><br />
    Mot de passe : <input type="password" name="mdp" /><br />
    Confirmation : <input type="password" name="mdp2" /><br />
    La couleur de vos yeux : <input type="text" name="eye_color" value="" /><br /><br />
    <input type="submit" name="formSend" value="Valider" />
</form>
</body>
</html>';
?>

Beaucoup de choses à dire ici, nous allons étudier du haut vers le bas.
On commence par inclure notre fichier common.php définit ci-dessus.

Initialisation de l'utilisateur
On récupère l'objet $user courant par la technique du singleton.
On démarre la session par $user->session_begin();
(Toutes les pages du site commenceront de cette manière)

Traitement du formulaire
Nous avons ensuite le traitement du formulaire. On commence par vérifier que les champs ne sont pas vides et que le mot de passe et sa confirmation coïncident.
Si tout est ok, on commence l'enregistrement de notre utilisateur. Pour cela, on rempli notre objet $user avec les attributs login et mdp (il y a aussi email, mais je ne l'ai pas mis ici pour ne pas surcharger).
Une fois notre objet $user rempli, on l'ajoute à la liste des utilisateurs par le service CUserList::addUser auquel on passe notre objet $user en paramètre.
Ce service va enregistrer pour nous l'utilisateur dans la base de donnée et retourne l'identifiant de celui-ci en cas de succès.

La dernière partie est optionnelle : si l'utilisateur est bien enregistré, outre un message l'avertissant, on le connecte directement et on ajoute une variable supplémentaire demandée dans le formulaire.

Enregistrement de variables permanentes
Je vais présenter plus en détail cette dernière fonctionnalité. Il s'agit d'un service d'enregistrement rapide de variables lièes à un utilisateur. Vous pouvez définir toutes les variables qui vous semblent utiles, mais vous ne devez pas utiliser les mots-clés login, email, mdp et instance qui sont déjà utilisées par la classe CUser.
Ces variables peuvent provenir de formulaire comme ici ou directement depuis le code. Elles s'enregistrent par la méthode $user->setPermanentVar($key, $value), se récupèrent par $user->getPermanentVar($key) et s'effacent par $user->delPermanentVar($key).
Il faut bien comprendre, comme le nom des méthodes l'indiquent, que ces variables sont permanentes et survivent après une déconnexion.
Il est important de noter aussi que l'utilisateur doit être soit connecté ($user->connectUser($id_user)) soit identifié ($user->identifieUser( $id_user )) pour utiliser ces 2 méthodes. L'identification permet de reconnaître un utilisateur, mais le laisse en mode non connecté.

Affichage du formulaire
Au niveau du formulaire, vous remarquerez que l'attribut value du login contient $user->login. En effet, après envoi du formulaire, la valeur dans le POST est placée dans l'objet $user. Ceci nous permet donc, lors d'un échec à l'inscription, de remplir les champs avec ce qu'on a déjà enregistré. Seul est exclu le mot de passe, car il est préférable qu'il soit ressaisi à chaque tentative.
Nous verrons plus loin que ceci peut être fait avec les champs "optionnels" tel que le eye_color à certaines conditions (nous verrons en même temps une méthode plus simple de les enregistrer).

III-E-2. La connexion

Notre utilisateur est enregistré en base de donnée et nous allons voir maintenant comment réaliser la page de connexion.

Code de la page de connxion
Sélectionnez
<?php
require_once 'common.php';
$user = CUser::getInstance();
$user->session_begin();

if ( ! empty($_POST['formSend']))
{
    if ( (empty($_POST['login'])) || (empty($_POST['mdp'])) )
    {
        $msg = 'Veuillez renseigner tous les champs';
    }
    else
    {
        $user->login = $_POST['login'];
        $baseUser = CUserList::getUserByLogin( $user->login );
        $md5mdp = md5( CUserList::getUserGDS( $user->login ) . stripslashes($_POST['mdp']) . CUserList::getUserGDS($user->login));
        if ($baseUser->mdp != $md5mdp)
        {
            $msg = 'Mauvais mot de passe';
        }
        else
        {
            $user->connectUser( $baseUser->getUserId() );
            $msg = 'Vous êtes connecté';
        }
    }
}

echo '<html>
<head></head>
<body>'.$msg.'<br /><form action="" method="post">
    Pseudo : <input type="text" name="login" value="'.$user->login.'" /><br />
    Mot de passe : <input type="password" name="mdp" /><br />
    <input type="submit" name="formSend" value="Valider" />
</form>
</body>
</html>';
?>

Comme pour la page d'inscription, je vais expliquer du haut vers le bas.
On commence par inclure notre fichier common.php définit ci-dessus.

Initialisation de l'utilisateur
On récupère l'objet $user courant par la technique du singleton.
On démarre la session par $user->session_begin();

Traitement du formulaire
Nous avons ensuite le traitement du formulaire. On commence par vérifier que les champs ne sont pas vides. Si tout est ok, on commence la procédure de connexion.
On récupère un objet user correspondant au login que le visiteur a saisis. Cet objet nous servira de base pour la comparaison (nous ne comparons ici que les mots de passe, mais on aurait pu comparer les dates de naissance, les emails....). Cet objet est appelé $baseUser, on le récupère par le service CUserList::getUserByLogin ($login).
On compare ensuite les mots de passe (attention, le mot de passe enregistré en base est de la forme MD5(GDS+mdp+GDS)), il faut donc redonner cette forme au mot de passe provenant du formulaire. Si la compraraison est un succès, on connecte l'utilisateur simplement par $user->connectUser( $id_user ).

Affichage du formulaire
On note, comme pour le formulaire d'inscription, que l'objet user permet de conserver le login saisit durant les tentatives.

III-E-3. Page protégée

Nous allons voir ici l'exemple typique d'une page ayant un contenu "public" et un contenu "privé" personnalisé au membre connecté.

Exemple de page public/privée typique
Sélectionnez
<?php
require_once 'common.php';
$user = CUser::getInstance();
$user->session_begin();
$userdata = $user->getUserData();

if ( ! $user->isConnected() )
{
    echo 'Vous devez être connecté pour voir cette page, vous pouvez vous connecter par ce lien : <a href="./connect.php">Page de connexion</a>';
}
else
{
    
    echo 'bonjour '.$userdata['login'].', vous avez de jolis yeux '.$userdata['eye_color'].'<br />Pour vous déconnecter, c\'est ici : <a href="./connect.php?a=deco">Page de déconnexion</a>';
}
?>

On voit apparaître $userdata. Ce tableau contient toutes les propriétés accessibles de l'utilisateur. N'hésitez pas à faire un print_r($userdata). Ce tableau sera principalement rempli par le développeur, car comme vous pouvez le constater, outre le login, on retrouve ici notre variable eye_color définit à l'inscription.
Vous noterez la fonction $user->isConnected qui se passe de commentaires. Vous remarquerez aussi surement qu'il y a un lien vers une page de déconnexion, qui nous n'avons pas vu encore, et que nous ne verrons pas ;-). A vous de chercher ! (un indice : $user->deconnectUser() )

III-F. Conclusion de la partie support de l'utilisateur

Voila, vous avez un espace membre. Bon il est très succint, mais il fonctionne. Il vous restera à écrire la déconnexion, une barre de navigation entre inscription/connexion/déconnexion et un brin de finition...

Ou alors, vous continuez la lecture, et découvrirez que tout est déjà fait et prêt à l'usage. Cet exemple permet aussi et surtout de montrer que l'aedituus n'est pas un bloc figé, mais que chaque brique peut être facilement intégrée à un système existant. Il vous suffira de reproduire ce qui a été fait ci-dessus.


précédentsommairesuivant

Vous avez aimé ce tutoriel ? Alors partagez-le en cliquant sur les boutons suivants : Viadeo Twitter Facebook Share on Google+   

  

Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright © 20/09/2006 Guillaume Affringue. Aucune reproduction, même partielle, ne peut être faite de ce site ni de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.