550 lines
16 KiB
PHP
Executable File
550 lines
16 KiB
PHP
Executable File
<?php
|
|
|
|
namespace manager;
|
|
use \manager\Database;
|
|
|
|
|
|
class ModuleRequest{
|
|
|
|
// Constantes
|
|
public static $config_path = 'f/json/modules/conf';
|
|
public static $default_options = array(
|
|
'download' => false
|
|
);
|
|
|
|
// Attributs prives utiles (initialisation)
|
|
private $path;
|
|
private $params;
|
|
private $modules;
|
|
private $options;
|
|
|
|
// 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] Récupèration des options
|
|
=========================================================*/
|
|
$this->buildOptions();
|
|
|
|
|
|
/* [6] 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(){
|
|
/* [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 != 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
|
|
=========================================================*/
|
|
$response = new ModuleResponse($this->error);
|
|
$response->appendAll($returned);
|
|
|
|
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 != 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] 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['ModuleError']) && $returned['ModuleError'] != ManagerError::Success ){
|
|
$this->error = $returned['ModuleError'];
|
|
return new ModuleResponse($this->error);
|
|
}
|
|
|
|
/* (2) Vérification du contenu, si pas défini */
|
|
if( !isset($returned['body']) ){
|
|
$this->error = ManagerError::ParamError;
|
|
return new ModuleResponse($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'] = array();
|
|
|
|
|
|
$fromAjax = isset($_SERVER['HTTP_X_REQUESTED_WITH']) && strtolower($_SERVER['HTTP_X_REQUESTED_WITH']) == 'xmlhttprequest';
|
|
|
|
/* [5] Si la requête vient d'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 = __ROOT__.$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 ModuleResponse(ManagerError::Success);
|
|
$response->append('link', $tmpfname);
|
|
|
|
return $response;
|
|
|
|
/* [6] 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;
|
|
}
|
|
}
|
|
|
|
|
|
/* DESERIALISATION A PARTIR DES DONNEES POST
|
|
*
|
|
* @url<String> Contenu de l'url après api/ (si existe)
|
|
* @post<Array> Tableau des donnes $_POST => @path + @data (opt)
|
|
*
|
|
* @return instance<ModuleRequest> Retourne un objet de type <ModuleRequest>
|
|
*
|
|
*/
|
|
public static function fromPost($url, $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
|
|
=========================================================*/
|
|
/* (1) Si le path est dans @url */
|
|
$pathInUrl = is_string($url[0]) && strlen($url[0]) > 0 && preg_match('#^([\w_-]+)/([\w_-]+)/?$#', $url[0], $urlMatches);
|
|
|
|
// On l'utilise pour le chemin
|
|
if( $pathInUrl )
|
|
$post['path'] = $urlMatches[1].'/'.$urlMatches[2];
|
|
|
|
/* (2) On vérifie dans tous les cas si le path existe */
|
|
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 met les paramètres JSON en JSON (si ils décodent sans erreur)
|
|
=========================================================*/
|
|
foreach($params as $name=>$value){
|
|
$json = json_decode( $value, true );
|
|
// Si aucune erreur, on affecte la valeur
|
|
if( !is_null($json) )
|
|
$params[$name] = $json;
|
|
}
|
|
/* [4] 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;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* 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 path<Array> Retourne le chemin d'amorcage de la requete
|
|
*
|
|
*/
|
|
private function getFunctionCaller(){
|
|
return array( '\\manager\\module\\'.$this->path['module'], $this->path['method'] );
|
|
}
|
|
|
|
|
|
}
|
|
|
|
?>
|