From 3b55a56b2456e1772acfe1870d2f026c47a9336d Mon Sep 17 00:00:00 2001 From: xdrm-brackets Date: Wed, 7 Dec 2016 11:53:46 +0100 Subject: [PATCH] Update api:2.2 with http:1.0 --- exporter/packages.json | 125 ++-- src/config/api/2.2/modules.json | 60 ++ src/modules/api/2.2/core/Authentification.php | 60 ++ src/modules/api/2.2/core/Checker.php | 150 +++++ src/modules/api/2.2/core/ModuleFactory.php | 31 + src/modules/api/2.2/core/Request.php | 589 ++++++++++++++++++ src/modules/api/2.2/core/Response.php | 122 ++++ src/modules/api/2.2/module/RESTexample.php | 116 ++++ src/modules/http/1.0/core/HttpRequest.php | 198 ++++++ 9 files changed, 1394 insertions(+), 57 deletions(-) create mode 100644 src/config/api/2.2/modules.json create mode 100644 src/modules/api/2.2/core/Authentification.php create mode 100644 src/modules/api/2.2/core/Checker.php create mode 100644 src/modules/api/2.2/core/ModuleFactory.php create mode 100644 src/modules/api/2.2/core/Request.php create mode 100644 src/modules/api/2.2/core/Response.php create mode 100644 src/modules/api/2.2/module/RESTexample.php create mode 100644 src/modules/http/1.0/core/HttpRequest.php diff --git a/exporter/packages.json b/exporter/packages.json index d26f577..4ec4086 100644 --- a/exporter/packages.json +++ b/exporter/packages.json @@ -1,58 +1,69 @@ { - "available": { - "error": { - "1.0": [], - "2.0": [] - }, - "api": { - "1.0": { - "error": [ - "1.0" - ] - }, - "2.0": { - "error": [ - "2.0" - ] - } - }, - "orm": { - "0.8.1": { - "database": [ - "1.0" - ] - }, - "0.8.2": { - "database": [ - "2.0" - ] - } - }, - "database": { - "1.0": { - "error": [ - "1.0" - ] - }, - "2.0": { - "error": [ - "2.0" - ] - } - }, - "lightdb": { - "1.0": [] - }, - "router": { - "1.0": [] - } - }, - "installed": { - "api": "2.0", - "error": "2.0", - "database": "2.0", - "orm": "0.8.2", - "lightdb": "1.0", - "router": "1.0" - } -} + "available": { + "error": { + "1.0": [], + "2.0": [] + }, + "http": { + "1.0": [] + }, + "api": { + "1.0": { + "error": [ + "1.0" + ] + }, + "2.0": { + "error": [ + "2.0" + ] + }, + "2.1": { + "error": [ + "2.0" + ], + "http": [ + "1.0" + ] + } + }, + "orm": { + "0.8.1": { + "database": [ + "1.0" + ] + }, + "0.8.2": { + "database": [ + "2.0" + ] + } + }, + "database": { + "1.0": { + "error": [ + "1.0" + ] + }, + "2.0": { + "error": [ + "2.0" + ] + } + }, + "lightdb": { + "1.0": [] + }, + "router": { + "1.0": [] + } + }, + "installed": { + "api": "2.1", + "error": "2.0", + "http": "1.0", + "orm": "0.8.2", + "database": "2.0", + "router": "1.0" + } +} \ No newline at end of file diff --git a/src/config/api/2.2/modules.json b/src/config/api/2.2/modules.json new file mode 100644 index 0000000..a982879 --- /dev/null +++ b/src/config/api/2.2/modules.json @@ -0,0 +1,60 @@ +{ + + "RESTexample": { + "POST::article": { + "description": "Posts a new article", + "permissions": ["journalist"], + "parameters": { + "title": { "description": "Article's title", "type": "varchar(5,100)" }, + "content": { "description": "Article's content", "type": "text" } + }, + "output": { + "created_id": { "description": "Id of the created article", "type": "id" } + } + }, + + "GET::article": { + "description": "Gets all or a specific article", + "permissions": ["viewer", "journalist"], + "parameters": { + "URL_0": { "description": "Article id", "type": "id", "optional": true } + }, + "output": { + "articles": { "description": "List of selected articles", "type": "array" } + } + }, + + "VIEW::article": { + "description": "Gets a specific article into a json file (download)", + "permissions": ["viewer", "journalist"], + "options": { "download": true }, + "parameters": { + "URL_0": { "description": "Article id", "type": "id" } + }, + "output": { + "article": { "description": "Selected article as JSON file", "type": "text" } + } + }, + + "PUT::article": { + "description": "Updates a specific article", + "permissions": ["journalist"], + "parameters": { + "URL_0": { "description": "Article id", "type": "id" }, + "content": { "description": "Article's content", "type": "text" } + }, + "output": { + "article": { "description": "Returns updated article", "type": "array" } + } + }, + + "DELETE::article": { + "description": "Deletes a specific article", + "permissions": ["journalist"], + "parameters": { + "URL_0": { "description": "Article id", "type": "id" } + }, + "output": {} + } + } +} diff --git a/src/modules/api/2.2/core/Authentification.php b/src/modules/api/2.2/core/Authentification.php new file mode 100644 index 0000000..03903d7 --- /dev/null +++ b/src/modules/api/2.2/core/Authentification.php @@ -0,0 +1,60 @@ +answer(); + + if( $user != false ){ + $this->userType = $user["Type"]; + $this->userId = $user["Id"]; + } + + new Repo("AuthentificationRepo/updateToken",[$token]); + + new Repo("AuthentificationRepo/purgeOldTokens",[]); + + self::$instance = $this; + } + + public function getUserType(){ + return $this->userType; + } + + public function getUserId(){ + return $this->userId; + } + + public static function permission(array $perm){ + if(in_array(self::$instance->userType,$perm)){ + return new Error(Err::Success); + } + + return new Error(Err::TokenError); + } + + /** + * @return Authentification + */ + public static function getInstance(){ + return self::$instance; + } + + + } diff --git a/src/modules/api/2.2/core/Checker.php b/src/modules/api/2.2/core/Checker.php new file mode 100644 index 0000000..7b4f3c0 --- /dev/null +++ b/src/modules/api/2.2/core/Checker.php @@ -0,0 +1,150 @@ + Type que l'on veut verifier + * @value Valeur a verifier + * + * @return match Retourne si oui ou non la valeur @value est du bon type @type + * + */ + public static function run($type, $value){ + $checker = true; + + /* [0] On verifie que $value n'est pas nul + =========================================================*/ + if( is_null($value) ) return false; + + + + /* [1] Si de type VARCHAR(min, max, flags) + =========================================================*/ + if( preg_match('/^varchar\((\d+), ?(\d+)((?:, ?\w+)+)?\)$/', $type, $match) ){ + // On recupere la taille min + $min = (int) $match[1]; + // On recupere la taille max + $max = (int) $match[2]; + + // On recupere le sous-type si défini + $flags = isset($match[3]) ? explode(',', substr($match[3], 1)) : null; + + // On effectue la verification de taille + $lenCheck = $checker && is_string($value) && strlen($value) <= $max && strlen($value) >= $min; + + // On vérifie les FLAGS s'il est donné + if( is_array($flags) ) + foreach( $flags as $flag ) + $lenCheck = $lenCheck && self::run($flag, $value); + + return $lenCheck; + } + + + /* [2] Si de type ARRAY(type_elements) + =========================================================*/ + if( preg_match('/^array<(.+)>$/', $type, $match) ){ + + // Si c'est pas un tableau on retourne une erreur + if( !is_array($value) ) + return false; + + + $elements_type = $match[1]; + + // On verifie le type pour chaque element + foreach($value as $element) + // Si erreur dans au moins 1 element, on retourne que c'est incorrect + if( !self::run($elements_type, trim($element) ) ) + return false; + + // Si aucune erreur, on retourne que tout est bon + return true; + } + + + /* [n] Sinon, tous les autres types definis + =========================================================*/ + switch($type){ + // Quoi que ce soit + case 'mixed': + return $checker && !is_null($value); + break; + + // Entier positif (id dans BDD) + case 'id': + return $checker && is_numeric($value) && $value <= 2147483647 && $value >= 0; + break; + + // Code RFID + case 'rfid': + return $checker && is_string($value) && preg_match('/^[\dA-F]{2}(\-[\dA-F]{2}){3,5}$/i', $value); + break; + + // String quelconque (peut etre vide) + case 'text': + return $checker && is_string($value); + + // Adresse mail (255 caracteres max) + case 'mail': + return $checker && is_string($value) && strlen($value) <= 50 && preg_match('/^[\w\.-]+@[\w\.-]+\.[a-z]{2,4}$/i', $value); + break; + + // Hash sha1/md5 + case 'hash': + return $checker && is_string($value) && preg_match('/^[\da-f]+$/i', $value) && (strlen($value) == 40 || strlen($value) == 64); + break; + + case 'alphanumeric': + return $checker && is_string($value) && preg_match('/^[\w\.-]+$/ui', $value); + break; + + case 'letters': + return $checker && is_string($value) && preg_match('/^[a-z -]+$/i', $value); + break; + + case 'status': + return $checker && is_numeric($value) && floor($value) == $value && $value >= 0 && $value <= 100; + break; + + // Tableau non vide + case 'array': + return $checker && is_array($value) && count($value) > 0; + break; + + // Boolean + case 'boolean': + return $checker && is_bool($value); + break; + + // Objet non vide + case 'object': + return $checker && is_object($value) && count((array) $value) > 0; + break; + + // Chaine JSON (on vérifie via le parser) + case 'json': + return $checker && is_string($value) && json_decode($value, true) !== NULL; + break; + + case 'numeric': + return $checker && (is_numeric($value) || $value == null || $value == 'null'); + break; + + default: + return false; + break; + } + + return $checker; + + } + + + } +?> diff --git a/src/modules/api/2.2/core/ModuleFactory.php b/src/modules/api/2.2/core/ModuleFactory.php new file mode 100644 index 0000000..527d5e9 --- /dev/null +++ b/src/modules/api/2.2/core/ModuleFactory.php @@ -0,0 +1,31 @@ + Nom du module + * @arguments [OPTIONNEL] Arguments à passer au constructeur + * + * @return instance Instance du module en question + * + */ + public static function getModule($module, $arguments=[]){ + /* (1) On gère les arguments */ + $arguments = is_array($arguments) ? $arguments : []; + + /* (1) On vérifie que la classe existe */ + if( !file_exists(__BUILD__."/api/module/$module.php") ) + return false; + + /* (2) On récupère la classe */ + $class_name = "\\api\\module\\$module"; + + /* (3) On retourne une instance */ + return new $class_name($arguments); + } + + } diff --git a/src/modules/api/2.2/core/Request.php b/src/modules/api/2.2/core/Request.php new file mode 100644 index 0000000..b352037 --- /dev/null +++ b/src/modules/api/2.2/core/Request.php @@ -0,0 +1,589 @@ + 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 Chemin de delegation ("module/methode") + * @param Tableau associatif contenant les parametres utiles au traitement + * + * @return status 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 */ + define('__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 + =========================================================*/ + $this->params = $params; + $this->error->set(Err::Success); + + return true; // On retourne que tout s'est bien passe + + } + + + + /* EXECUTE LE TRAITEMENT ASSOCIE ET REMPLIE LA REPONSE + * + * @return answer Retourne une reponse de type 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, '$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 Contenu de l'url après api/ (si existe) + * @post [opt] Tableau des donnes + * + * @return instance Retourne un objet de type + * + * @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 = count($url) > 0 && is_string($url[0]) && strlen($url[0]) > 0 && preg_match('#^([\w_-]+/[\w_-]+)(?:/?|/((?:\w+/)*(?:\w+/?)))$#', $url[0], $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 + =========================================================*/ + return new Request($data['path'], $params); + } + + + + + + /* VERIFICATION DU FORMAT ET DE LA COHERENCE DU CHEMIN SPECIFIE + * + * @path String correspondant au chemin de delegation ("module/methode") + * + * @return validity 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 = __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 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']) ) return true; + + + + /* [2] Vérification des permissions et de l'authentification + =========================================================*/ + if(!empty($method['permissions'])){ + $granted = Authentification::permission($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 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 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 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']); + } + + + } + +?> diff --git a/src/modules/api/2.2/core/Response.php b/src/modules/api/2.2/core/Response.php new file mode 100644 index 0000000..840f91b --- /dev/null +++ b/src/modules/api/2.2/core/Response.php @@ -0,0 +1,122 @@ + Erreur passee par la requete (si existe) + * + */ + public function __construct($error=null){ + if( !( $error instanceof Error ) ) + $error = new Error(Err::Success); + + $this->data = []; + $this->error = $error; + } + /* AJOUTE UNE DONNEE A LA REPONSE + + + * + * @key Le nom de la valeur a ajouter + * @value La valeur a ajouter + * + */ + public function append($key, $value){ + // Ajoute une entree pour la cle @key et de valeur @value + $this->data[$key] = $value; + + return $this; + } + + + /* AJOUTE TOUTES LES DONNEES A LA REPONSE + * + * @dataset Le tableau associatif correspondant a la reponse + * + */ + public function appendAll($dataset){ + // Si ce n'est pas un tableau, on ne fais rien + if( !is_array($dataset) ) + return $this; + + // Si une valeur contient une erreur + if( array_key_exists('error', $dataset) && $dataset['error'] instanceof Error){ + // On definit cette erreur + $this->error = $dataset['error']; + // On enleve cette entree des donnees + unset($dataset['error']); + } + + // Ajoute une entree pour la cle @key et de valeur @value + $this->data = $dataset; + + return $this; + } + /* RECUPERE UNE DONNEE DE LA REPONSE + + + * + * @key Le nom de la valeur a recuperer + * + * @return value La valeur a cette cle + * @return error Retourne NULL si aucune valeur pour cette cle + * + */ + public function get($key){ + // Si la valeur de cle @key n'existe pas, on retourne NULL + if( !isset($this->data[$key]) ) + return null; + + // Sinon, on retourne la valeur associee + return $this->data[$key]; + } + + + /* RECUPERE TOUTES LES DONNEES DE LA REPONSE + * + * @return data Les donnees de la reponse + * + */ + public function getAll(){ + // Sinon, on retourne la valeur associee + return $this->data; + } + + + /* SERIALISATION A PARTIR DES DONNEES + * + * @return json Retourne les donnees serialisees + * + */ + public function serialize(){ + + // Code Http + $this->error->setHttpCode(); + + // Type de contenu + header('Content-Type: application/json; charset=utf-8'); + + // On rajoute l'erreur au message + $returnData = array_merge([ + 'error' => $this->error->get(), + 'ErrorDescription' => $this->error->explicit() + ], + $this->data + ); + + return json_encode($returnData); + + } + } + +?> diff --git a/src/modules/api/2.2/module/RESTexample.php b/src/modules/api/2.2/module/RESTexample.php new file mode 100644 index 0000000..decfdec --- /dev/null +++ b/src/modules/api/2.2/module/RESTexample.php @@ -0,0 +1,116 @@ + new Error(Err::ModuleError)]; // or other `Err` constant + + return ['created_id' => $output_created_id]; + break; + + case 'GET': + // GET all/an article with the variable: + $URL_0; // id of article ; if not given -> null + + // ... + // process to get articles and get $output_get_articles + // ... + + if( !$success ) + return ['error' => new Error(Err::ModuleError)]; // or other `Err` constant + + return ['articles' => $output_get_articles]; + break; + + case 'VIEW': + // VIEW a specific article (download json file) with the variable: + $URL_0; // id of article ; if not given -> null + + // ... + // process to get articles and get $output_get_articles + // ... + + if( !$success ) + return ['error' => new Error(Err::ModuleError)]; // or other `Err` constant + + // will download, but if AJAX will give a `link` to the file + return [ + 'headers' => [ + 'Content-Type' => 'application/json; charset=utf-8', + 'Content-Disposition' => 'attachment; filename=export'.date('_d_m_Y', time()).'.json', + 'Pragma' => 'no-cache', + 'Expires' => '0' + ], + 'body' => json_encode($output_get_articles) + ]; + break; + + case 'PUT': + // UPDATE an article with new content with variables: + $URL_0; // id of article to update + $title; // new article's title + $content; // new article's content + + // ... + // process to get $output_updated_article + // ... + + if( !$success ) + return ['error' => new Error(Err::ModuleError)]; // or other `Err` constant + + return ['article' => $output_updated_article]; + break; + + case 'DELETE': + // DELETEs an article with the variable: + $URL_0; // id of the article to remove + + // ... + // process to delete article + // ... + + if( !$success ) + return ['error' => new Error(Err::ModuleError)]; // or other `Err` constant + + return []; // returns success + break; + + // if no match -> error + default: + return ['error' => new Error(Err::UnknownHttpMethod)]; + break; + } + + } + + +} diff --git a/src/modules/http/1.0/core/HttpRequest.php b/src/modules/http/1.0/core/HttpRequest.php new file mode 100644 index 0000000..de3a294 --- /dev/null +++ b/src/modules/http/1.0/core/HttpRequest.php @@ -0,0 +1,198 @@ + auto-filled HTTP Request + * + =========================================================*/ + public function __construct(){ + /* [1] Define URI & Status Code & method + =========================================================*/ + $this->uri = $_SERVER['REQUEST_URI']; + $this->method = $_SERVER['REQUEST_METHOD']; + + + /* [2] Define headers + =========================================================*/ + $this->headers = \getallheaders(); + + + /* [3] Define default datasets (GET, POST) + =========================================================*/ + $this->getdata = $_GET; + $this->postdata = $_POST; + + + /* [4] Define BODY & its type + =========================================================*/ + /* (1) Default: set plain/text body */ + $this->body = \file_get_contents('php://input'); + + /* (2) Fetch content type */ + $this->type = self::getContentType($this->headers['Content-Type']); + + + /* [5] Parse BODY data -> POST + =========================================================*/ + $this->parseBody(); + } + + + + /* GET CONSTANT CT_* FROM `Content-Type` HEADER + * + * @pContentType `Content-Type` header value + * + * @return type Constant value + * + */ + private static function getContentType($pContentType=null){ + /* [1] Checks argv + =========================================================*/ + if( is_null($pContentType) ) + $pContentType = $_SERVER['CONTENT_TYPE']; + + + /* [2] Checks types + =========================================================*/ + /* (1) Form Data Types + ---------------------------------------------------------*/ + /* (1) multipart/form-data */ + if( preg_match('/^multipart\/form\-data; boundary=(.+)$/i', $pContentType) ) + return self::CT_MULTIPART_FORM_DATA; + + /* (2) application/x-www-form-urlencoded */ + if( preg_match('/^application\/x\-www\-form\-urlencoded/i', $pContentType) ) + return self::CT_X_WWW_FORM_URLENCODED; + + + /* (2) Data types + ---------------------------------------------------------*/ + /* (1) Basic JSON content type */ + if( preg_match('/^application\/json/i', $pContentType) ) + return self::CT_JSON; + + /* (2) Basic YAML content type */ + if( preg_match('/^application\/yaml/i', $pContentType) ) + return self::CT_YAML; + + /* (3) Basic TEXT content type */ + if( preg_match('/text\/[a-z]+/', $pContentType) ) + return self::CT_TEXT; + + + /* (3) Default Type + ---------------------------------------------------------*/ + return self::CT_BINARY; + + } + + + + /* PARSES BODY DATA + * + */ + private function parseBody(){ + /* [1] If empty body -> do nothing + =========================================================*/ + if( strlen($this->body) === 0 ) + return true; + + + /* [2] Management for each ContentType + =========================================================*/ + switch($this->type){ + + /* (1) multipart/form-data -> parse for not-POST methods + ---------------------------------------------------------*/ + case self::CT_MULTIPART_FORM_DATA: + /* (1) Fetch the boundary */ + if( !preg_match('/boundary=(.+)$/i', $this->headers['Content-Type'], $match) ) + return false; + + $boundary = $match[1]; + + /* (2) Break body into parts */ + $splitter = "/(?:\n|\r\n|--)*$boundary(?:\n|\r\n|--)?/im"; + $parts = preg_split($splitter, $this->body); + + /* (3) Process parts */ + foreach($parts as $part) + if( preg_match('/^Content\-Disposition: form\-data; name=\"([^"]+)\"(?:\n|\r\n){2}(.+)$/mi', $part, $match) ) + $this->postdata[$match[1]] = $match[2]; + + /* (4) Erases body */ + $this->body = ''; + break; + + + /* (2) application/x-www-form-urlencoded -> parse for not-POST methods + ---------------------------------------------------------*/ + case self::CT_X_WWW_FORM_URLENCODED: + /* Auto parse builtin-php function */ + parse_str($this->body, $this->postdata); + + /* Erases body */ + $this->body = ''; + break; + + + /* (3) application/json -> parse if no error + ---------------------------------------------------------*/ + case self::CT_JSON: + /* (1) Decode body content */ + $decoded = json_decode($this->body, true); + + /* (2) If error -> do nothing */ + if( is_null($decoded) ) + return; + + /* (3) Parse body into body */ + $this->body = $decoded; + break; + + + /* (4) application/yaml -> parse if no error + ---------------------------------------------------------*/ + case self::CT_YAML: + + break; + } + } + + + public function BODY(){ return $this->body; } + public function POST(){ return $this->postdata; } + public function GET(){ return $this->getdata; } + public function HEADERS(){ return $this->headers; } + public function METHOD(){ return $this->method; } + public function URI(){ return $this->uri; } + }