571 lines
17 KiB
PHP
571 lines
17 KiB
PHP
|
<?php
|
||
|
|
|
||
|
|
namespace api\core;
|
||
|
|
use \database\core\DatabaseDriver;
|
||
|
|
use \api\core\AuthSystem;
|
||
|
|
use \api\core\ModuleFactory;
|
||
|
|
use \error\core\Error;
|
||
|
|
use \error\core\Err;
|
||
|
|
|
||
|
|
|
||
|
|
class Request{
|
||
|
|
|
||
|
|
// Constantes
|
||
|
|
public static function config_path(){ return __ROOT__.'/config/modules.json'; }
|
||
|
|
private static $default_options = [
|
||
|
|
'download' => false
|
||
|
|
];
|
||
|
|
private static $authsystem = null;
|
||
|
|
|
||
|
|
// Attributs prives utiles (initialisation)
|
||
|
|
private $path;
|
||
|
|
private $params;
|
||
|
|
private $modules;
|
||
|
|
private $options;
|
||
|
|
private $http_method;
|
||
|
|
|
||
|
|
// Contiendra la reponse a la requete
|
||
|
|
public $answer;
|
||
|
|
|
||
|
|
// Contiendra l'etat de la requete
|
||
|
|
public $error;
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/* CONSTRUCTEUR D'UNE REQUETE DE MODULE
|
||
|
|
*
|
||
|
|
* @path<String> Chemin de delegation ("module/methode")
|
||
|
|
* @param<Array> Tableau associatif contenant les parametres utiles au traitement
|
||
|
|
*
|
||
|
|
* @return instance<Request> Instance crée
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
public function __construct($path=null, $params=null){
|
||
|
|
|
||
|
|
return $this->buildRequestObject($path, $params);
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/* CONSTRUCTEUR D'UNE REQUETE DE MODULE (DELEGATION)
|
||
|
|
*
|
||
|
|
* @path<String> Chemin de delegation ("module/methode")
|
||
|
|
* @param<Array> Tableau associatif contenant les parametres utiles au traitement
|
||
|
|
*
|
||
|
|
* @return status<Boolean> Retourne si oui ou non tout s'est bien passe
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
private function buildRequestObject($path=null, $params=null){
|
||
|
|
/* [1] Initialisation
|
||
|
|
=========================================================*/
|
||
|
|
/* (1) Erreur par défaut */
|
||
|
|
$this->error = new Error(Err::Success);
|
||
|
|
|
||
|
|
/* (2) Si pas parametre manquant, on quitte */
|
||
|
|
if( $path == null )
|
||
|
|
return $this->error->set(Err::MissingPath);
|
||
|
|
|
||
|
|
|
||
|
|
/* [2] On met a jour la configuration
|
||
|
|
=========================================================*/
|
||
|
|
/* (1) Vérification existence fichier config */
|
||
|
|
if( !file_exists(self::config_path()) )
|
||
|
|
return $this->error->set(Err::UnreachableResource);
|
||
|
|
|
||
|
|
/* (2) Lecture fichier config */
|
||
|
|
$conf = @file_get_contents(self::config_path());
|
||
|
|
|
||
|
|
/* (3) Si erreur lecture */
|
||
|
|
if( $conf === false )
|
||
|
|
return $this->error->set(Err::UnreachableResource);
|
||
|
|
|
||
|
|
/* (4) Parsage json */
|
||
|
|
$this->modules = json_decode( $conf, true );
|
||
|
|
|
||
|
|
/* (5) Gestion de l'erreur de parsage */
|
||
|
|
if( $this->modules == null )
|
||
|
|
return $this->error->set(Err::ParsingFailed, 'json');
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/* [3] Verification des types des parametres
|
||
|
|
=========================================================*/
|
||
|
|
/* (1) Si path est une <string> */
|
||
|
|
if( !is_string($path) ) // Si le type est incorrect
|
||
|
|
return $this->error->set(Err::WrongPathModule);
|
||
|
|
|
||
|
|
/* (2) Formattage @params en tableau */
|
||
|
|
$params = (is_array($params)) ? $params : [];
|
||
|
|
|
||
|
|
/* (3) On définit en constante la méthode HTTP */
|
||
|
|
if( !isset($_SERVER['REQUEST_METHOD']) )
|
||
|
|
return $this->error->set(Err::UnknownHttpMethod);
|
||
|
|
|
||
|
|
$this->http_method = strtoupper($_SERVER['REQUEST_METHOD']);
|
||
|
|
|
||
|
|
|
||
|
|
/* [4] Verification du chemin (existence module+methode)
|
||
|
|
=========================================================*/
|
||
|
|
if( !$this->checkPath($path) ) // Verification de la coherence du chemin + attribution
|
||
|
|
return false; // checkPath() sets the error itself
|
||
|
|
|
||
|
|
|
||
|
|
/* [5] Verification des droits
|
||
|
|
=========================================================*/
|
||
|
|
if( !$this->checkPermission() ) // Si on a pas les droits
|
||
|
|
return false; // checkPermission() sets the error itself
|
||
|
|
|
||
|
|
|
||
|
|
/* [6] Verification des parametres (si @type est defini)
|
||
|
|
=========================================================*/
|
||
|
|
if( !$this->checkParams($params) ) // Verification de tous les types
|
||
|
|
return false; // checkParams() sets the error itself
|
||
|
|
|
||
|
|
|
||
|
|
/* [7] Récupèration des options
|
||
|
|
=========================================================*/
|
||
|
|
$this->buildOptions();
|
||
|
|
|
||
|
|
|
||
|
|
/* [8] Construction de l'objet (add http method to params)
|
||
|
|
=========================================================*/
|
||
|
|
$this->params = $params;
|
||
|
|
$this->params['HTTP_METHOD'] = $this->http_method;
|
||
|
|
$this->error->set(Err::Success);
|
||
|
|
|
||
|
|
return true; // On retourne que tout s'est bien passe
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/* DEFINIT LE SYSTEME D'AUTHENTIFICATION
|
||
|
|
*
|
||
|
|
* @instance<AuthSystem> Instance de type AuthSystem
|
||
|
|
*
|
||
|
|
* @return success<Boolean> Whether the AuthSystem is valid or not
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
public static function setAuthSystem($instance=null){
|
||
|
|
/* (1) Check instance type */
|
||
|
|
if( !($instance instanceof AuthSystem) )
|
||
|
|
return false;
|
||
|
|
|
||
|
|
/* (2) Store instance */
|
||
|
|
self::$authsystem = $instance;
|
||
|
|
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/* EXECUTE LE TRAITEMENT ASSOCIE ET REMPLIE LA REPONSE
|
||
|
|
*
|
||
|
|
* @return answer<Response> Retourne une reponse de type <Response> si tout s'est bien passe
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
public function dispatch(){
|
||
|
|
/* [0] Si c'est un download, on lance la methode `download()`
|
||
|
|
=========================================================*/
|
||
|
|
if( $this->options['download'] === true )
|
||
|
|
return $this->download();
|
||
|
|
|
||
|
|
|
||
|
|
/* [1] On verifie qu'aucune erreur n'a ete signalee
|
||
|
|
=========================================================*/
|
||
|
|
if( $this->error->get() !== Err::Success ) // si il y a une erreur
|
||
|
|
return new Response($this->error); // on la passe a la reponse
|
||
|
|
|
||
|
|
|
||
|
|
/* [2] On essaie d'instancier le module
|
||
|
|
=========================================================*/
|
||
|
|
$instance = ModuleFactory::getModule($this->path['module']);
|
||
|
|
|
||
|
|
if( $instance instanceof Error ){
|
||
|
|
$this->error->set(Err::UncallableModule, $this->path['module']);
|
||
|
|
return new Response($this->error);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/* [3] On verifie que la methode est amorcable
|
||
|
|
=========================================================*/
|
||
|
|
if( !is_callable([$instance, $this->getModuleMethod()]) ){
|
||
|
|
$this->error->set(Err::UncallableMethod, preg_replace('/\w+::/i', '', $this->path['method']) );
|
||
|
|
return new Response($this->error);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/* [4] On amorce la methode
|
||
|
|
=========================================================*/
|
||
|
|
/* (1) On lance la fonction */
|
||
|
|
$returned = call_user_func( [$instance, $this->getModuleMethod()], $this->params );
|
||
|
|
|
||
|
|
/* (2) On appelle le destructeur (si défini) */
|
||
|
|
$instance = null;
|
||
|
|
|
||
|
|
|
||
|
|
/* [5] Gestion de la reponse
|
||
|
|
=========================================================*/
|
||
|
|
/* (1) On construit la réponse avec l'erreur */
|
||
|
|
$response = new Response($this->error);
|
||
|
|
|
||
|
|
/* (2) On ajoute les données */
|
||
|
|
$response->appendAll($returned);
|
||
|
|
|
||
|
|
// On retourne la réponse
|
||
|
|
return $response;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/* EXECUTE LE TRAITEMENT ASSOCIE ET RENVOIE UN FICHIER AVEC LE HEADER ET LE BODY SPECIFIE
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
public function download(){
|
||
|
|
/* [1] On verifie qu'aucune erreur n'a ete signalee
|
||
|
|
=========================================================*/
|
||
|
|
if( $this->error->get() !== Err::Success ) // si il y a une erreur
|
||
|
|
return new Response($this->error); // on la passe a la reponse
|
||
|
|
|
||
|
|
|
||
|
|
/* [2] On essaie d'instancier le module
|
||
|
|
=========================================================*/
|
||
|
|
$instance = ModuleFactory::getModule($this->path['module']);
|
||
|
|
|
||
|
|
if( $instance === false ){
|
||
|
|
$this->error->set(Err::UncallableModule);
|
||
|
|
return new Response($this->error);
|
||
|
|
}
|
||
|
|
|
||
|
|
/* [3] On verifie que la methode est amorcable
|
||
|
|
=========================================================*/
|
||
|
|
if( !is_callable([$instance, $this->getModuleMethod()]) ){
|
||
|
|
$this->error->set(Err::UncallableMethod);
|
||
|
|
return new Response($this->error);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/* [4] On amorce la methode
|
||
|
|
=========================================================*/
|
||
|
|
/* (1) On lance la fonction */
|
||
|
|
$returned = call_user_func( [$instance, $this->getModuleMethod()], $this->params );
|
||
|
|
|
||
|
|
/* (2) On appelle le destructeur (si défini) */
|
||
|
|
$instance = null;
|
||
|
|
|
||
|
|
|
||
|
|
/* [5] Vérification des erreurs et paramètres
|
||
|
|
=========================================================*/
|
||
|
|
/* (1) Vérification de l'erreur retournée, si pas Success, on retourne l'erreur */
|
||
|
|
if( isset($returned['error']) && $returned['error'] instanceof Error && $returned['error']->get() != Err::Success ){
|
||
|
|
$this->error = $returned['error'];
|
||
|
|
return new Response($this->error);
|
||
|
|
}
|
||
|
|
|
||
|
|
/* (2) Vérification du contenu, si pas défini */
|
||
|
|
if( !isset($returned['body']) ){
|
||
|
|
$this->error->set(Err::ParamError);
|
||
|
|
return new Response($this->error);
|
||
|
|
}
|
||
|
|
|
||
|
|
/* (3) Si @headers n'est pas défini on met par défaut */
|
||
|
|
if( !isset($returned['headers']) || !is_array($returned['headers']) )
|
||
|
|
$returned['headers'] = [];
|
||
|
|
|
||
|
|
$fromAjax = isset($_SERVER['HTTP_X_REQUESTED_WITH']) && strtolower($_SERVER['HTTP_X_REQUESTED_WITH']) == 'xmlhttprequest';
|
||
|
|
|
||
|
|
|
||
|
|
/* [6.1] Si requête ajax on crée un fichier temporaire et on renvoie son URL
|
||
|
|
=========================================================*/
|
||
|
|
if( $fromAjax ){
|
||
|
|
|
||
|
|
|
||
|
|
$tmpfname = '/tmp/download_'.uniqid().'.php';
|
||
|
|
$bodyfname = __ROOT__.'/tmp/content_'.uniqid().'.php';
|
||
|
|
|
||
|
|
/* (1) On crée le fichier temporaire */
|
||
|
|
$tmpfnameroot = __PUBLIC__.$tmpfname;
|
||
|
|
$tmpfile = fopen($tmpfnameroot, 'w');
|
||
|
|
|
||
|
|
fwrite($tmpfile, '<?php'.PHP_EOL);
|
||
|
|
|
||
|
|
/* (2) Script qui écrira les headers */
|
||
|
|
foreach($returned['headers'] as $header=>$value)
|
||
|
|
fwrite($tmpfile, "header(\"$header: $value\");".PHP_EOL);
|
||
|
|
|
||
|
|
/* (3) Script qui écrira le contenu */
|
||
|
|
// 1) On écrit le contenu dans un fichier temporaire (et oui encore)
|
||
|
|
$bodyfile = fopen($bodyfname, 'w');
|
||
|
|
fwrite($bodyfile, $returned['body']);
|
||
|
|
fclose($bodyfile);
|
||
|
|
chmod($bodyfname, 0775);
|
||
|
|
|
||
|
|
fwrite($tmpfile, "readfile('$bodyfname');".PHP_EOL);
|
||
|
|
|
||
|
|
/* (4) Script qui supprimera les fichiers temporaires */
|
||
|
|
fwrite($tmpfile, "unlink('$bodyfname');".PHP_EOL);
|
||
|
|
fwrite($tmpfile, "unlink(__FILE__);".PHP_EOL);
|
||
|
|
|
||
|
|
fwrite($tmpfile, '?>'.PHP_EOL);
|
||
|
|
|
||
|
|
/* (5) On ferme le fichier */
|
||
|
|
fclose($tmpfile);
|
||
|
|
chmod($tmpfnameroot, 0775);
|
||
|
|
|
||
|
|
$response = new Response($this->error);
|
||
|
|
$response->append('link', $tmpfname);
|
||
|
|
|
||
|
|
return $response;
|
||
|
|
|
||
|
|
/* [6.2] Gestion du download direct si pas AJAX
|
||
|
|
=========================================================*/
|
||
|
|
}else{
|
||
|
|
/* (1) On définit les headers */
|
||
|
|
foreach($returned['headers'] as $header=>$value)
|
||
|
|
header($header.': '.$value);
|
||
|
|
|
||
|
|
/* (2) On affiche le contenu */
|
||
|
|
echo $returned['body'];
|
||
|
|
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/* VERIFICATION DU FORMAT ET DE LA COHERENCE DU CHEMIN SPECIFIE
|
||
|
|
*
|
||
|
|
* @path<String> String correspondant au chemin de delegation ("module/methode")
|
||
|
|
*
|
||
|
|
* @return validity<Boolean> Retourne si oui ou non l'objet est correct
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
private function checkPath($path){
|
||
|
|
/* [1] Verification format general
|
||
|
|
=========================================================*/
|
||
|
|
if( !preg_match('@^([\w_-]+)/([\w_-]+)$@i', $path, $matches) ) // Si mauvais format
|
||
|
|
return $this->error->set(Err::WrongPathModule);
|
||
|
|
|
||
|
|
// On recupere les données de la regex
|
||
|
|
$module = $matches[1];
|
||
|
|
$method = $this->http_method.' '.$matches[2];
|
||
|
|
|
||
|
|
|
||
|
|
/* [2] Verification de l'existence du module (conf)
|
||
|
|
=========================================================*/
|
||
|
|
if( !array_key_exists($module, $this->modules) ) // Si le module n'est pas specifie dans la conf
|
||
|
|
return $this->error->set(Err::UnknownModule, $module);
|
||
|
|
|
||
|
|
|
||
|
|
/* [3] Verification de l'existence de la methode (conf)
|
||
|
|
=========================================================*/
|
||
|
|
if( array_key_exists($method, $this->modules[$module]) === false ) // Si la methode n'est pas specifie dans la conf
|
||
|
|
return $this->error->set(Err::UnknownMethod, preg_replace('/\w+ /i', '', $method) );
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/* [4] Enregistrement du chemin et renvoi de SUCCESS
|
||
|
|
=========================================================*/
|
||
|
|
$this->path = [
|
||
|
|
'module' => $module,
|
||
|
|
'method' => $method
|
||
|
|
];
|
||
|
|
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/* RETOURNE SI ON A LA PERMISSION D'EXECUTER CETTE METHODE
|
||
|
|
*
|
||
|
|
* @return permission<bool> Retourne si on a les droits ou pas pour executer cette methode
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
private function checkPermission(){
|
||
|
|
/* [1] On recupere les informations utiles
|
||
|
|
=========================================================*/
|
||
|
|
// On recupere le nom de la methode
|
||
|
|
$method = $this->modules[$this->path['module']][$this->path['method']];
|
||
|
|
|
||
|
|
// Si aucune permission n'est definie
|
||
|
|
if( !isset($method['permissions']) || !is_array($method['permissions']) || count($method['permissions']) < 1 )
|
||
|
|
return true;
|
||
|
|
|
||
|
|
/* [2] Vérification des permissions et de l'authentification
|
||
|
|
=========================================================*/
|
||
|
|
// if no AuthSystem set up, use the default one
|
||
|
|
if( !is_object(self::$authsystem) || !self::$authsystem instanceof AuthSystem ){
|
||
|
|
|
||
|
|
// try to load default AuthSystem
|
||
|
|
if( !file_exists(__BUILD__.'/api/core/AuthSystemDefault.php') )
|
||
|
|
return $this->error->set(Err::UnreachableResource);
|
||
|
|
|
||
|
|
// load default AuthSystem class
|
||
|
|
$classname = '\\api\\core\\AuthSystemDefault';
|
||
|
|
self::$authsystem = new $classname();
|
||
|
|
}
|
||
|
|
|
||
|
|
// Check permission using user-implemented AuthSystem
|
||
|
|
$granted = self::$authsystem::permission( $this->path['module'], $method['permissions'] );
|
||
|
|
|
||
|
|
/* (1) On retourne FAUX si aucun droit n'a ete trouve */
|
||
|
|
if( $granted->get() !== Err::Success ){
|
||
|
|
$this->error = $granted;
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/* On retourne VRAI si la permission est ok */
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/* VERIFICATION DU TYPE DES PARAMETRES ENVOYES
|
||
|
|
*
|
||
|
|
* @params<Array> Tableau associatif contenant les parametres
|
||
|
|
* @params peut se voir rajouter les paramètres optionnels s'ils ne sont pas renseignés (initialisés à NULL)
|
||
|
|
*
|
||
|
|
* @return correct<bool> Retourne si oui ou non les parametres ont le bon type
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
private function checkParams(&$params){
|
||
|
|
/* [1] On verifie qu'il ne manque aucun parametre
|
||
|
|
=========================================================*/
|
||
|
|
/* (1) Si @params n'est pas un tableau */
|
||
|
|
if( !is_array($params) )
|
||
|
|
return $this->error->set(Err::MissingParam);
|
||
|
|
|
||
|
|
/* (2) On récupère les données de la méthode */
|
||
|
|
$method = $this->modules[$this->path['module']][$this->path['method']];
|
||
|
|
|
||
|
|
/* (3) Si pas 'parameters' dans la config */
|
||
|
|
if( !isset($method['parameters']) || !is_array($method['parameters']) )
|
||
|
|
return $this->error->set(Err::ConfigError);
|
||
|
|
|
||
|
|
|
||
|
|
/* [2] Si le type est defini, pour chaque param, on teste
|
||
|
|
=========================================================*/
|
||
|
|
foreach($method['parameters'] as $name=>$paramsdata){
|
||
|
|
|
||
|
|
/* (1) Vérification des données
|
||
|
|
---------------------------------------------------------*/
|
||
|
|
/* (1) Si @name n'est pas une string */
|
||
|
|
if( !is_string($name) )
|
||
|
|
return $this->error->set(Err::ConfigError);
|
||
|
|
|
||
|
|
/* (2) Si @paramsdata n'est pas un tableau */
|
||
|
|
if( !is_array($paramsdata) )
|
||
|
|
return $this->error->set(Err::ConfigError);
|
||
|
|
|
||
|
|
/* (3) So @paramsdata['type] manquant ou incorrect */
|
||
|
|
if( !isset($paramsdata['type']) || !is_string($paramsdata['type']) )
|
||
|
|
return $this->error->set(Err::ConfigError);
|
||
|
|
|
||
|
|
|
||
|
|
/* (2) Gestion des spécifications
|
||
|
|
---------------------------------------------------------*/
|
||
|
|
/* (1) On récupère si le paramètre est optionnel ou pas */
|
||
|
|
$optional = isset($paramsdata['optional']) && $paramsdata['optional'] === true;
|
||
|
|
|
||
|
|
/* (2) Si de type 'FILE' + fichier existe => on enregistre la ref. */
|
||
|
|
if( $paramsdata['type'] == 'FILE' && isset($_FILES[$name]) )
|
||
|
|
$params[$name] = &$_FILES[$name];
|
||
|
|
|
||
|
|
/* (3) Si param obligatoire et manquant -> erreur */
|
||
|
|
if( !isset($params[$name]) && !$optional )
|
||
|
|
return $this->error->set(Err::MissingParam, $name);
|
||
|
|
|
||
|
|
|
||
|
|
/* (3) Gestion des valeurs
|
||
|
|
---------------------------------------------------------*/
|
||
|
|
/* (1) Si le paramètre est optionnel et manquant */
|
||
|
|
if( $optional && !isset($params[$name]) ){
|
||
|
|
|
||
|
|
// On le crée le param optionnel avec la valeur NULL
|
||
|
|
$params[$name] = null;
|
||
|
|
|
||
|
|
/* (2) Si le paramètre est renseigné (sauf FILE) */
|
||
|
|
}elseif( $paramsdata['type'] != 'FILE'){
|
||
|
|
|
||
|
|
// Si la verification est fausse, on retourne faux
|
||
|
|
if( !Checker::run($paramsdata['type'], $params[$name]) )
|
||
|
|
return $this->error->set(Err::WrongParam, $name, $paramsdata['type']);
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
/* [3] Gestion du retour, si tout s'est bien passe
|
||
|
|
=========================================================*/
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/* AJOUT DES OPTIONS A PARTIR DE LA CONFIGURATION
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
private function buildOptions(){
|
||
|
|
/* [0] On récupère les options de la méthode en cours
|
||
|
|
=========================================================*/
|
||
|
|
$method = $this->modules[$this->path['module']][$this->path['method']];
|
||
|
|
|
||
|
|
/* (1) Si 'option' n'est pas défini (ou incorrect), on met les valeurs par défaut */
|
||
|
|
if( !isset($method['options']) || !is_array($method['options']) )
|
||
|
|
return true;
|
||
|
|
|
||
|
|
/* (2) Par défaut on définit les options par défaut */
|
||
|
|
$this->options = self::$default_options;
|
||
|
|
|
||
|
|
/* (3) On récupère les options données */
|
||
|
|
$options = $method['options'];
|
||
|
|
|
||
|
|
|
||
|
|
/* [1] Gestion des différentes options
|
||
|
|
=========================================================*/
|
||
|
|
foreach($options as $option=>$value){
|
||
|
|
/* (1) On ne prend en compte l'option que si elle est dans les options par défaut */
|
||
|
|
if( !isset(self::$default_options[$option]) )
|
||
|
|
continue;
|
||
|
|
|
||
|
|
/* (2) Le type de la valeur doit être le même que celui de la valeur par défaut */
|
||
|
|
if( gettype($value) != gettype(self::$default_options[$option]) )
|
||
|
|
continue;
|
||
|
|
|
||
|
|
/* (3) Si tout est bon, on définit la valeur */
|
||
|
|
$this->options[$option] = $value;
|
||
|
|
}
|
||
|
|
|
||
|
|
return true;
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/* RENVOI LE CHEMIN D'AMORCAGE DE LA METHODE
|
||
|
|
*
|
||
|
|
* @return method<String> Retourne le chemin d'amorcage de la method
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
private function getModuleMethod(){
|
||
|
|
|
||
|
|
/* (1) On essaie de trouver le bon nom */
|
||
|
|
return preg_replace('/([A-Z]+) ([a-zA-Z_]+)/i', '$1_$2', $this->path['method']);
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
?>
|