618 lines
18 KiB
PHP
618 lines
18 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;
|
|
use \http\core\HttpRequest;
|
|
|
|
|
|
class Request{
|
|
|
|
// Constantes
|
|
private 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 status<Boolean> Retourne si oui ou non tout s'est bien passe
|
|
*
|
|
*/
|
|
public function __construct($path=null, $params=null){
|
|
/* [1] Fetch HttpRequest correct data
|
|
=========================================================*/
|
|
/* (1) Parse HttpRequest data because php doesn't parse it for non-POST HTTP method */
|
|
$httprequest = new HttpRequest();
|
|
$_POST = $httprequest->POST();
|
|
|
|
|
|
/* [2] Initialisation
|
|
=========================================================*/
|
|
/* (1) Erreur par défaut */
|
|
$this->error = new Error(Err::Success);
|
|
|
|
/* (2) Si pas parametre manquant, on quitte */
|
|
if( $path == null ){
|
|
$this->error->set(Err::MissingPath);
|
|
return false;
|
|
}
|
|
|
|
|
|
/* [3] On met a jour la configuration
|
|
=========================================================*/
|
|
/* (1) Section Title */
|
|
$this->modules = json_decode( file_get_contents(self::config_path()), true );
|
|
|
|
/* (2) Gestion de l'erreur de parsage */
|
|
if( $this->modules == null ){
|
|
$this->error->set(Err::ParsingFailed, 'json');
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
/* [4] Verification des types des parametres
|
|
=========================================================*/
|
|
/* (1) Section Title */
|
|
if( !is_string($path) ){ // Si le type est incorrect
|
|
$this->error->set(Err::WrongPathModule);
|
|
return false; // On retourne FALSE, si erreur
|
|
}
|
|
|
|
/* (2) Section Title */
|
|
$params = (is_array($params)) ? $params : [];
|
|
|
|
/* (3) On définit en constante la méthode HTTP */
|
|
$this->http_method = strtoupper($_SERVER['REQUEST_METHOD']);
|
|
|
|
|
|
/* [5] Verification du chemin (existence module+methode)
|
|
=========================================================*/
|
|
if( !$this->checkPath($path) ) // Verification de la coherence du chemin + attribution
|
|
return false;
|
|
|
|
|
|
/* [6] Verification des droits
|
|
=========================================================*/
|
|
if( !$this->checkPermission() ) // Si on a pas les droits
|
|
return false;
|
|
|
|
|
|
/* [7] Verification des parametres (si @type est defini)
|
|
=========================================================*/
|
|
if( !$this->checkParams($params) ) // Verification de tous les types
|
|
return false;
|
|
|
|
|
|
/* [8] Récupèration des options
|
|
=========================================================*/
|
|
$this->buildOptions();
|
|
|
|
|
|
/* [9] 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;
|
|
}
|
|
|
|
|
|
|
|
/* 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 === false ){
|
|
$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 = __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 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;
|
|
}
|
|
}
|
|
|
|
|
|
/* DESERIALISATION A PARTIR DE L'URL ET DES DONNEES POST (OPT)
|
|
*
|
|
* @url<String> Contenu de l'url formatté (commence à "/module/methode")
|
|
* @post<Array> [opt] Tableau des donnes
|
|
*
|
|
* @return instance<Request> Retourne un objet de type <Request>
|
|
*
|
|
* @note
|
|
* 1. `path` peut être dans l'url : /method/module
|
|
* `path` peut être dans les données $_POST
|
|
* 2. les données peuvent être dans l'url : /module/method/data1/data2/...
|
|
* les données peuvent être dans les données $_POST
|
|
*
|
|
*/
|
|
public static function remote($url, $data=null){
|
|
is_null($data) && ($data = []);
|
|
|
|
|
|
/* [1] On verifie que le @path est renseigne
|
|
=========================================================*/
|
|
/* (1) Si le path est dans @url */
|
|
$pathInUrl = is_string($url) && preg_match('#^/?([\w_-]+/[\w_-]+)(?:/?|/((?:\w+/)*(?:\w+/?)))$#', $url, $urlMatches);
|
|
|
|
/* (2) On récupère le @path + les arguments dans l'URL */
|
|
if( $pathInUrl ){
|
|
// {1} On ajoute le @path aux données //
|
|
$data['path'] = $urlMatches[1];
|
|
|
|
// {2} On ajoute les arguments d'URL aux données //
|
|
if( count($urlMatches) > 2 ){
|
|
|
|
$urlParams = explode('/', trim($urlMatches[2], '/'));
|
|
foreach($urlParams as $k=>$v)
|
|
$data["URL_$k"] = $v;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
/* (2) On vérifie dans tous les cas si le path existe */
|
|
if( !isset($data['path']) )
|
|
return new Request();
|
|
|
|
|
|
|
|
/* [3] On met les paramètres en JSON
|
|
=========================================================*/
|
|
/* (1) On initialise les paramètres*/
|
|
$params = [];
|
|
|
|
/* (2) On met tous les paramètres en json (sauf @path) */
|
|
foreach($data as $name=>$value){
|
|
if( $name === 'path' )
|
|
continue;
|
|
|
|
// {1} On met en JSON //
|
|
$json = json_decode( $value, true );
|
|
|
|
// {2} Si ok -> on remplace //
|
|
if( !is_null($json) )
|
|
$params[$name] = $json;
|
|
|
|
// {3} Sinon, on laisse tel quel //
|
|
else
|
|
$params[$name] = $value;
|
|
}
|
|
|
|
/* [4] On retourne une instance de <Request>
|
|
=========================================================*/
|
|
return new Request($data['path'], $params);
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* 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->set(Err::WrongPathModule);
|
|
return false;
|
|
}
|
|
|
|
// 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
|
|
$this->error->set(Err::UnknownModule, $module);
|
|
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->set(Err::UnknownMethod, preg_replace('/\w+::/i', '', $method) );
|
|
return false; // On retourne FALSE, si erreur
|
|
}
|
|
|
|
|
|
|
|
/* [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
|
|
=========================================================*/
|
|
var_dump(self::$authsystem);
|
|
die('error line 466');
|
|
// if no AuthSystem set up, deny by default
|
|
//if( !self::$authsystem instanceof AuthSystem )
|
|
// return false;
|
|
|
|
// Check permission using user-implemented AuthSystem
|
|
$granted = self::$authsystem::permission();
|
|
//$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
|
|
=========================================================*/
|
|
// Si @params n'est pas un tableau
|
|
if( !is_array($params) ){
|
|
$this->error->set(Err::ConfigError);
|
|
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 ){
|
|
$this->error->set(Err::MissingParam, $name);
|
|
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( !Checker::run($paramsdata['type'], $params[$name]) ){
|
|
$this->error->set(Err::WrongParam, $name, $paramsdata['type']);
|
|
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 method<String> Retourne le chemin d'amorcage de la method
|
|
*
|
|
*/
|
|
private function getModuleMethod(){
|
|
/* (1) On essaie de trouver le bon nom */
|
|
return preg_replace('/\w+::/i', '', $this->path['method']);
|
|
}
|
|
|
|
|
|
}
|
|
|
|
?>
|