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'] ); | |
| } | |
| } | |
| ?> |