2016-04-04 09:47:17 +00:00
|
|
|
<?php
|
|
|
|
|
|
|
|
namespace manager;
|
2016-04-12 13:16:10 +00:00
|
|
|
use \manager\Database;
|
2016-04-04 09:47:17 +00:00
|
|
|
|
|
|
|
// FORMAT:
|
|
|
|
//
|
|
|
|
// path: "nomModule/nomMethode"
|
|
|
|
// data1: {donnee1}
|
|
|
|
// data2: {donnee2}
|
|
|
|
// ...
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//
|
|
|
|
|
|
|
|
class ModuleRequest{
|
|
|
|
|
|
|
|
// Constantes
|
|
|
|
public static $config_path = 'f/json/modules/conf';
|
|
|
|
|
|
|
|
|
|
|
|
// Attributs prives utiles (initialisation)
|
|
|
|
private $path;
|
2016-04-12 13:16:10 +00:00
|
|
|
private $params;
|
2016-04-04 09:47:17 +00:00
|
|
|
private $modules;
|
|
|
|
|
|
|
|
// 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")
|
2016-04-12 13:16:10 +00:00
|
|
|
* @param<Array> Tableau associatif contenant les parametres utiles au traitement
|
2016-04-04 09:47:17 +00:00
|
|
|
*
|
|
|
|
* @return status<Boolean> Retourne si oui ou non tout s'est bien passe
|
|
|
|
*
|
|
|
|
*/
|
2016-04-12 13:16:10 +00:00
|
|
|
public function __construct($path=null, $params=null){
|
2016-04-04 09:47:17 +00:00
|
|
|
// Si pas parametre manquant, on quitte
|
|
|
|
if( $path == null ){
|
|
|
|
$this->error = ManagerError::MissingPath;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* [0] On met a jour la configuration
|
|
|
|
=========================================================*/
|
|
|
|
// Modules specifies
|
|
|
|
$this->modules = json_decode( ResourceDispatcher::getResource(self::$config_path), true );
|
|
|
|
|
|
|
|
// Gestion de l'erreur de parsage
|
|
|
|
if( $this->modules == null ){
|
|
|
|
$this->error = ManagerError::ParsingFailed;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* [1] Verification des types des parametres
|
|
|
|
=========================================================*/
|
|
|
|
// Type de @path
|
|
|
|
if( !is_string($path) ){ // Si le type est incorrect
|
|
|
|
$this->error = ManagerError::WrongPathModule;
|
|
|
|
return false; // On retourne FALSE, si erreur
|
|
|
|
}
|
|
|
|
|
|
|
|
// Type de @data (optionnel)
|
2016-04-12 13:16:10 +00:00
|
|
|
$params = (is_array($params)) ? $params : array();
|
2016-04-04 09:47:17 +00:00
|
|
|
|
|
|
|
|
|
|
|
/* [2] Verification du chemin (existence module+methode)
|
|
|
|
=========================================================*/
|
|
|
|
if( !$this->checkPath($path) ) // Verification de la coherence du chemin + attribution
|
|
|
|
return false;
|
|
|
|
|
2016-04-12 13:16:10 +00:00
|
|
|
/* [3] Verification des parametres (si @type est defini)
|
|
|
|
=========================================================*/
|
|
|
|
if( !$this->checkParams($params) ){ // Verification de tous les types
|
|
|
|
$this->error = ManagerError::ParamError;
|
|
|
|
return false;
|
|
|
|
}
|
2016-04-04 09:47:17 +00:00
|
|
|
|
2016-04-12 13:16:10 +00:00
|
|
|
/* [4] Construction de l'objet
|
2016-04-04 09:47:17 +00:00
|
|
|
=========================================================*/
|
2016-04-12 13:16:10 +00:00
|
|
|
$this->params = $params;
|
2016-04-04 09:47:17 +00:00
|
|
|
$this->error = ManagerError::Success;
|
|
|
|
|
|
|
|
return true; // On retourne que tout s'est bien passe
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* EXECUTE LE TRAITEMENT ASSOCIE ET REMPLIE LA REPONSE
|
|
|
|
*
|
|
|
|
* @return answer<ModuleAnswer> Retourne une reponse de type <ModuleAnswer> si tout s'est bien passe
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
public function dispatch(){
|
|
|
|
/* [1] On verifie qu'aucune erreur n'a ete signalee
|
|
|
|
=========================================================*/
|
|
|
|
if( $this->error != ManagerError::Success ) // si il y a une erreur
|
|
|
|
return new ModuleAnswer($this->error); // on la passe a la reponse
|
|
|
|
|
|
|
|
|
|
|
|
/* [2] On verifie que la methode est amorcable
|
|
|
|
=========================================================*/
|
|
|
|
if( !is_callable($this->getFunctionCaller()) ){
|
|
|
|
$this->error = ManagerError::UncallableMethod;
|
|
|
|
return new ModuleAnswer($this->error);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* [3] On amorce la methode
|
|
|
|
=========================================================*/
|
2016-04-12 13:16:10 +00:00
|
|
|
$returned = call_user_func_array( $this->getFunctionCaller(), $this->params );
|
2016-04-04 09:47:17 +00:00
|
|
|
|
|
|
|
|
|
|
|
/* [4] Gestion de la reponse
|
|
|
|
=========================================================*/
|
|
|
|
$answer = new ModuleAnswer($this->error);
|
|
|
|
$answer->appendAll($returned);
|
|
|
|
|
|
|
|
return $answer;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* DESERIALISATION ET CREATION D'UN OBJET
|
|
|
|
*
|
|
|
|
* @jsonString<String> Json au format string contenant les donnees
|
|
|
|
*
|
|
|
|
* @return instance<ModuleRequest> Retourne un objet de type <ModuleRequest>
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
public static function fromString($jsonString){
|
|
|
|
$json = json_decode( $jsonString, true );
|
|
|
|
|
|
|
|
// Verification du parsage
|
|
|
|
if( $json == null )
|
|
|
|
return new ModuleRequest();
|
|
|
|
|
|
|
|
// Verification des parametres
|
|
|
|
if( !isset($json['path']) )
|
|
|
|
return new ModuleRequest();
|
|
|
|
|
2016-04-12 13:16:10 +00:00
|
|
|
// On definit $params au cas ou il soit vide
|
|
|
|
$params = $json;
|
|
|
|
// On retire le @path de @params
|
|
|
|
unset($params['path']);
|
2016-04-04 09:47:17 +00:00
|
|
|
|
2016-04-12 13:16:10 +00:00
|
|
|
return new ModuleRequest($json['path'], $params);
|
2016-04-04 09:47:17 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* DESERIALISATION A PARTIR DES DONNEES POST
|
|
|
|
*
|
|
|
|
* @post<Array> Tableau des donnes $_POST => @path + @data (opt)
|
|
|
|
*
|
|
|
|
* @return instance<ModuleRequest> Retourne un objet de type <ModuleRequest>
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
public static function fromPost($post){
|
2016-04-10 15:40:09 +00:00
|
|
|
/* [0] Verification de l'authentification
|
|
|
|
=========================================================*/
|
|
|
|
/* (1) Si le token n'est pas dans le header */
|
|
|
|
if( !isset($_SERVER['PHP_AUTH_DIGEST']) ){
|
|
|
|
$tmp = new ModuleRequest();
|
|
|
|
$tmp->error = ManagerError::TokenError;
|
|
|
|
return $tmp;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* (2) Si le token n'est pas dans la BDD */
|
|
|
|
$checkToken = new Repo('token/check', array($_SERVER['PHP_AUTH_DIGEST']) );
|
|
|
|
$valid_token = $checkToken->answer();
|
|
|
|
|
|
|
|
if( !$valid_token ){
|
|
|
|
$tmp = new ModuleRequest();
|
|
|
|
$tmp->error = ManagerError::TokenError;
|
|
|
|
return $tmp;
|
|
|
|
}
|
|
|
|
|
2016-04-04 09:47:17 +00:00
|
|
|
/* [1] On verifie que le @path est renseigne
|
|
|
|
=========================================================*/
|
|
|
|
if( !isset($post['path']) )
|
|
|
|
return new ModuleRequest();
|
|
|
|
|
|
|
|
/* [2] On verifie que @data est renseigne
|
|
|
|
=========================================================*/
|
|
|
|
// Si variable n'existe pas, on cree un tableau vide
|
2016-04-12 13:16:10 +00:00
|
|
|
$params = $post;
|
|
|
|
// On retire le @path de @params
|
|
|
|
unset($params['path']);
|
2016-04-04 09:47:17 +00:00
|
|
|
|
|
|
|
/* [3] On retourne une instance de <ModuleRequest>
|
|
|
|
=========================================================*/
|
2016-04-12 13:16:10 +00:00
|
|
|
return new ModuleRequest($post['path'], $params);
|
2016-04-04 09:47:17 +00:00
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* 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
|
|
|
|
$this->error = ManagerError::WrongPathModule;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
// On recupere les donnes de la regex
|
|
|
|
$module = $matches[1];
|
|
|
|
$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
|
|
|
|
$this->error = ManagerError::UnknownModule;
|
|
|
|
return false; // On retourne FALSE, si erreur
|
|
|
|
}
|
|
|
|
|
|
|
|
/* [3] Verification de l'existence de la methode (conf)
|
|
|
|
=========================================================*/
|
2016-04-12 13:16:10 +00:00
|
|
|
if( array_key_exists($method, $this->modules[$module]) === false ){ // Si la methode n'est pas specifie dans la conf
|
2016-04-04 09:47:17 +00:00
|
|
|
$this->error = ManagerError::UnknownMethod;
|
|
|
|
return false; // On retourne FALSE, si erreur
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* [4] Enregistrement du chemin et renvoi de SUCCESS
|
|
|
|
=========================================================*/
|
|
|
|
$this->path = array(
|
|
|
|
'module' => $module,
|
|
|
|
'method' => $method
|
|
|
|
);
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2016-04-12 13:16:10 +00:00
|
|
|
/* VERIFICATION DU TYPE DES PARAMETRES ENVOYES
|
|
|
|
*
|
|
|
|
* @params<Array> Tableau associatif contenant les parametres
|
|
|
|
*
|
|
|
|
* @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
|
|
|
|
=========================================================*/
|
|
|
|
// Si @params n'est pas un tableau
|
|
|
|
if( !is_array($params) ) return false;
|
|
|
|
|
|
|
|
$method = $this->modules[$this->path['module']][$this->path['method']];
|
|
|
|
|
|
|
|
// Si le nombre de parametre en entree et requis est different
|
|
|
|
if( count($method['parameters']) > count($params) ) return false;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* [2] Si le type est defini, pour chaque param, on teste
|
|
|
|
=========================================================*/
|
|
|
|
foreach($method['parameters'] as $name=>$paramsdata){
|
|
|
|
// Si le parametre n'existe pas dans le tableau recu
|
|
|
|
if( !isset($params[$name]) ) return false;
|
|
|
|
|
|
|
|
// Si le type n'est pas defini, on reboucle
|
|
|
|
if( !isset($paramsdata['type']) ) continue;
|
|
|
|
|
|
|
|
// Si la verification est fausse, on retourne faux
|
|
|
|
if( !Database::check($paramsdata['type'], $params[$name]) ) return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* [3] Gestion du retour, si tout s'est bien passe
|
|
|
|
=========================================================*/
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2016-04-04 09:47:17 +00:00
|
|
|
|
|
|
|
/* RENVOI LE CHEMIN D'AMORCAGE DE LA METHODE
|
|
|
|
*
|
|
|
|
* @return path<Array> Retourne le chemin d'amorcage de la requete
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
private function getFunctionCaller(){
|
|
|
|
return array( '\\manager\\module\\'.$this->path['module'], $this->path['method'] );
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
?>
|