Code Coverage |
||||||||||
Classes and Traits |
Functions and Methods |
Lines |
||||||||
Total | |
0.00% |
0 / 1 |
|
50.00% |
4 / 8 |
CRAP | |
86.02% |
80 / 93 |
ModuleRequest | |
0.00% |
0 / 1 |
|
50.00% |
4 / 8 |
51.78 | |
86.02% |
80 / 93 |
__construct | |
0.00% |
0 / 1 |
8.06 | |
90.48% |
19 / 21 |
|||
dispatch | |
0.00% |
0 / 1 |
3.10 | |
77.78% |
7 / 9 |
|||
fromString | |
0.00% |
0 / 1 |
12 | |
0.00% |
0 / 8 |
|||
fromPost | |
100.00% |
1 / 1 |
3 | |
100.00% |
6 / 6 |
|||
checkPath | |
100.00% |
1 / 1 |
4 | |
100.00% |
15 / 15 |
|||
checkPermission | |
0.00% |
0 / 1 |
8.01 | |
94.74% |
18 / 19 |
|||
checkParams | |
100.00% |
1 / 1 |
16 | |
100.00% |
14 / 14 |
|||
getFunctionCaller | |
100.00% |
1 / 1 |
1 | |
100.00% |
1 / 1 |
<?php | |
namespace manager; | |
use \manager\Database; | |
class ModuleRequest{ | |
// Constantes | |
public static $config_path = 'f/json/modules/conf'; | |
// Attributs prives utiles (initialisation) | |
private $path; | |
private $params; | |
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") | |
* @param<Array> Tableau associatif contenant les parametres utiles au traitement | |
* @token<String> Token d'acces a l'api (OPTIONNEL) | |
* | |
* @return status<Boolean> Retourne si oui ou non tout s'est bien passe | |
* | |
*/ | |
public function __construct($path=null, $params=null, $token=null){ | |
// 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) | |
$params = (is_array($params)) ? $params : array(); | |
/* [2] Verification du chemin (existence module+methode) | |
=========================================================*/ | |
if( !$this->checkPath($path) ) // Verification de la coherence du chemin + attribution | |
return false; | |
/* [3] Verification des droits | |
=========================================================*/ | |
if( !$this->checkPermission($token) ) // Si on a pas les droits | |
return false; | |
/* [4] Verification des parametres (si @type est defini) | |
=========================================================*/ | |
if( !$this->checkParams($params) ){ // Verification de tous les types | |
$this->error = ManagerError::ParamError; | |
return false; | |
} | |
/* [5] Construction de l'objet | |
=========================================================*/ | |
$this->params = $params; | |
$this->error = ManagerError::Success; | |
return true; // On retourne que tout s'est bien passe | |
} | |
/* EXECUTE LE TRAITEMENT ASSOCIE ET REMPLIE LA REPONSE | |
* | |
* @return answer<ModuleResponse> Retourne une reponse de type <ModuleResponse> 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 ModuleResponse($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 ModuleResponse($this->error); | |
} | |
/* [3] On amorce la methode | |
=========================================================*/ | |
$returned = call_user_func( $this->getFunctionCaller(), $this->params ); | |
/* [4] Gestion de la reponse | |
=========================================================*/ | |
$answer = new ModuleResponse($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(); | |
// On definit $params au cas ou il soit vide | |
$params = $json; | |
// On retire le @path de @params | |
unset($params['path']); | |
return new ModuleRequest($json['path'], $params); | |
} | |
/* 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){ | |
/* [0] Verification de l'authentification | |
=========================================================*/ | |
// On definit le token | |
$token = isset($_SERVER['PHP_AUTH_DIGEST']) ? $_SERVER['PHP_AUTH_DIGEST'] : null; | |
/* [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 | |
$params = $post; | |
// On retire le @path de @params | |
unset($params['path']); | |
/* [3] On retourne une instance de <ModuleRequest> | |
=========================================================*/ | |
// On cree notre requete avec le token | |
return new ModuleRequest($post['path'], $params, $token); | |
} | |
/* 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) | |
=========================================================*/ | |
if( array_key_exists($method, $this->modules[$module]) === false ){ // Si la methode n'est pas specifie dans la conf | |
$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; | |
} | |
/* RETOURNE SI ON A LA PERMISSION D'EXECUTER CETTE METHODE | |
* | |
* @token<String> Token d'acces a l'API (OPTIONNEL) | |
* | |
* @return permission<bool> Retourne si on a les droits ou pas pour executer cette methode | |
* | |
*/ | |
private function checkPermission($token=null){ | |
/* [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']) ) return true; | |
/* [2] Gestion si un @token est defini | |
=========================================================*/ | |
if( Database::check('sha1', $token) ){ | |
/* (1) On verifie que le token est valide */ | |
$checkToken = new Repo('token/check', array($token) ); | |
$token_permissions = $checkToken->answer(); | |
// Si le token est invalide, on retourne une erreur -> FAUX | |
if( $token_permissions === false ){ | |
$this->error = ManagerError::TokenError; | |
return false; | |
} | |
$local_permissions = $token_permissions; | |
/* [3] Gestion si aucun token, avec utilisateur connecté | |
=========================================================*/ | |
}else if( isset($_SESSION['permission']) ) | |
$local_permissions = $_SESSION['permission']; | |
// Si ni token, ni SESSION, erreur | |
else{ | |
$this->error = ManagerError::PermissionError; | |
return false; | |
} | |
/* [4] Verification des droits parmi les permissions donnees | |
=========================================================*/ | |
/* (1) On recupere la liste des permissions possibles */ | |
$permissions = $method['permissions']; | |
/* (2) Si aucune permission n'est definie, on laisse l'acces */ | |
if( count($permissions) == 0 ) return true; | |
/* (3) On verifie qu'il y a au moins une permission ok */ | |
foreach($permissions as $permission) | |
if( in_array($permission, $local_permissions) ) return true; | |
/* [5] On retourne FAUX si aucun droit n'a ete trouve | |
=========================================================*/ | |
$this->error = ManagerError::PermissionError; | |
return false; | |
} | |
/* 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 | |
=========================================================*/ | |
// Si @params n'est pas un tableau | |
if( !is_array($params) ) return false; | |
$method = $this->modules[$this->path['module']][$this->path['method']]; | |
/* [2] Si le type est defini, pour chaque param, on teste | |
=========================================================*/ | |
foreach($method['parameters'] as $name=>$paramsdata){ | |
/* (1) On récupère si le paramètre est optionnel ou pas */ | |
$optional = isset($paramsdata['optional']) && $paramsdata['optional'] === true; | |
/* (2) Récupère si le paramètre est un fichier et définit comme de type 'FILE' */ | |
$isFile = isset($paramsdata['type']) && $paramsdata['type'] == 'FILE' && isset($_FILES[$name]); | |
/* (3) Si le paramètre est obligatoire et qu'il n'est pas donné -> erreur */ | |
if( !isset($params[$name]) && !$optional && !$isFile ) return false; | |
/* (4) Si le type n'est pas defini, on a pas besoin de le vérifier */ | |
if( !isset($paramsdata['type']) ) continue; | |
/* (5) Si le paramètre est optionnel et n'est pas donné */ | |
if( $isFile || $optional && (!isset($params[$name]) || is_null($params[$name])) ){ | |
// On le crée le param optionnel avec la valeur NULL | |
$params[$name] = null; | |
// On donne une référence vers le fichier, si c'en est un | |
if( $isFile ) | |
$params[$name] = &$_FILES[$name]; | |
continue; // On passe au paramètre suivant | |
/* (6) Si le paramètre est renseigné */ | |
}else | |
// 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; | |
} | |
/* 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'] ); | |
} | |
} | |
?> |