Alors, je savais pas si je devais mettre ca dans les tutos ou ici. Je tente ici sait on jamais.
Aujourd'hui, quoi de neuf ? Gestion de modules d'un site web.
Un truc tout simple bien entendu.
La gestion des modules se fait via un simple fichier XML. Dans ce fichier, on établi si oui ou non on veut activer le module. C'est pour le moment quelque chose de très simple.
Voici le code :
Source / Exemple :
<?php
// Toute classe doit hériter de celle ci.
abstract class Core {
static private $module = array();
static private $modconf = NULL;
public function __construct($modname) {
if ( !isset(self::$modconf) ) self::$modconf = simplexml_load_file('./class/init.xml');
if ( self::isModLoadable($modname) ) {
self::$module[$modname] = TRUE;
} else {
throw new Exception('Module impossible à instancier');
}
}
static private function isModLoadable($modname) {
foreach ( self::$modconf->module as $module ) {
if ( (string) strtolower($module->name) == strtolower($modname)
&& (string) strtolower($module->loadable) == 'true' )
return TRUE;
}
return FALSE;
}
}
// Voici donc la classe en elle-même. C'est un truc tout simple n'est-ce-pas ?
// L'emploi des propriétés statiques est faite pour controler les modules. (et encore, c'est pas très poussé pour le moment !
// Voici le fichier XML :
?>
<?xml version="1.0" encoding="iso-8859-1"?>
<modules>
<module>
<name>mysql</name>
<loadable>TRUE</loadable>
</module>
<module>
<name>news</name>
<loadable>TRUE</loadable>
</module>
<module>
<name>test</name>
<loadable>FALSE</loadable>
</module>
</modules>
<?php
// La aussi, c'est du simple, on voit aisément la relation entre la classe du haut et le fichier ci-dessus.
// Prenons une classe d'un projet :
class x extends Core {
public $y;
private $z;
public function __construct() {
parent::__construct(__CLASS__);
}
// .... etc...
}
// En instanciant mon objet, je vais vérifier via la méthode statique si je peux oui ou non utiliser mon module.
// Voici comment se passe l'instanciation :
try {
$x = new x;
$x->doSomething();
$x->try();
} catch ( Exception $e ) {
echo $e->getMessage();
}
// Que va t'il se passer ? Si le module 'x' est présent dans mon fichier XML, et que 'loadable' => TRUE alors je peux continuer à utiliser mon objet, SINON on passe par la case d'exception.
// On peut voir ca avec un système de news et de commentaires.
// Imaginons qu'on puisse n'avoir que les news et les commentaires desactivés :
try {
$news = new NewsFactory;
$news->method();
// ...
// Fin d'affichage de la news, affichage des commentaires :
try {
$comments = new CommentsFactory;
$comments->show();
// ...
} catch ( Exception $e1 ) {
// Signifie que les commentaires seront desactivés
}
} catch ( Exception $e2 ) {
// Signifie que les news et les commentaires sont desactivés
}
?>
Conclusion :
Ca peut marcher pour n'importe quel type de module.
On peut étendre la classe Core pour une utilisation plus poussé des methodes :
if ( Core::module_loaded($modulename) )
Core::Unload_module($modulename);
etc...
Et encore, les possibilités sont immenses !
Si vous avez des suggestions, je prend. Je compte developper un ptit truc sympa avec ca. J'ai de la reserve de code sur l'ordi mais je compte pas encore vous le faire partager... un peu plus tard surement :p
Vous n'êtes pas encore membre ?
inscrivez-vous, c'est gratuit et ça prend moins d'une minute !
Les membres obtiennent plus de réponses que les utilisateurs anonymes.
Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.
Le fait d'être membre vous permet d'avoir des options supplémentaires.