Update api:2.2 with http:1.0
This commit is contained in:
xdrm-brackets
parent
d65860a78c
commit
3b55a56b24
|
|
@ -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"
|
||||
}
|
||||
}
|
||||
|
|
@ -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<mixed>" }
|
||||
}
|
||||
},
|
||||
|
||||
"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<mixed>" }
|
||||
}
|
||||
},
|
||||
|
||||
"DELETE::article": {
|
||||
"description": "Deletes a specific article",
|
||||
"permissions": ["journalist"],
|
||||
"parameters": {
|
||||
"URL_0": { "description": "Article id", "type": "id" }
|
||||
},
|
||||
"output": {}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,60 @@
|
|||
<?php
|
||||
|
||||
namespace api\core;
|
||||
|
||||
use \database\core\Repo;
|
||||
use \error\core\Error;
|
||||
use \error\core\Err;
|
||||
|
||||
class Authentification
|
||||
{
|
||||
|
||||
private static $instance;
|
||||
|
||||
private $userType;
|
||||
private $userId;
|
||||
|
||||
public function __construct()
|
||||
{
|
||||
$token = !empty($_SERVER['PHP_AUTH_DIGEST']) ? $_SERVER['PHP_AUTH_DIGEST'] : false;
|
||||
|
||||
$user = new Repo("AuthentificationRepo/identifyUserByToken", [$token]);
|
||||
$user = $user->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;
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,150 @@
|
|||
<?php
|
||||
|
||||
namespace api\core;
|
||||
|
||||
|
||||
class Checker{
|
||||
|
||||
|
||||
/* VERIFICATIONS DES TYPES UTILES GENERIQUES
|
||||
*
|
||||
* @type<String> Type que l'on veut verifier
|
||||
* @value<mixed*> Valeur a verifier
|
||||
*
|
||||
* @return match<Boolean> 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;
|
||||
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
?>
|
||||
|
|
@ -0,0 +1,31 @@
|
|||
<?php
|
||||
|
||||
namespace api\core;
|
||||
|
||||
|
||||
class ModuleFactory{
|
||||
|
||||
/* INSTANCIE UN MODULE
|
||||
*
|
||||
* @module<String> Nom du module
|
||||
* @arguments<Array> [OPTIONNEL] Arguments à passer au constructeur
|
||||
*
|
||||
* @return instance<Module> 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);
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,589 @@
|
|||
<?php
|
||||
|
||||
namespace api\core;
|
||||
use \database\core\DatabaseDriver;
|
||||
use \api\core\Authentification;
|
||||
use \api\core\ModuleFactory;
|
||||
use \error\core\Error;
|
||||
use \error\core\Err;
|
||||
use \http\core\HttpRequest;
|
||||
|
||||
|
||||
class Request{
|
||||
|
||||
// Constantes
|
||||
public static function config_path(){ return __ROOT__.'/config/modules.json'; }
|
||||
public static $default_options = [
|
||||
'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
|
||||
*
|
||||
* @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 */
|
||||
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<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 après api/ (si existe)
|
||||
* @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 = 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 <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 = __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']) ) 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<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']);
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
||||
?>
|
||||
|
|
@ -0,0 +1,122 @@
|
|||
<?php
|
||||
|
||||
namespace api\core;
|
||||
use \error\core\Error;
|
||||
use \error\core\Err;
|
||||
|
||||
class Response{
|
||||
|
||||
// Attributs prives utiles (initialisation)
|
||||
private $data;
|
||||
public $error;
|
||||
|
||||
|
||||
/* CONSTRUCTEUR D'UNE REPONSE DE MODULE
|
||||
*
|
||||
* @error<ModuleError> 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<String> Le nom de la valeur a ajouter
|
||||
* @value<mixed*> 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<Array> 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<String> Le nom de la valeur a recuperer
|
||||
*
|
||||
* @return value<mixed*> La valeur a cette cle
|
||||
* @return error<null> 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<Array> Les donnees de la reponse
|
||||
*
|
||||
*/
|
||||
public function getAll(){
|
||||
// Sinon, on retourne la valeur associee
|
||||
return $this->data;
|
||||
}
|
||||
|
||||
|
||||
/* SERIALISATION A PARTIR DES DONNEES
|
||||
*
|
||||
* @return json<String> 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);
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
?>
|
||||
|
|
@ -0,0 +1,116 @@
|
|||
<?php
|
||||
|
||||
namespace api\module;
|
||||
|
||||
|
||||
use error\core\Error;
|
||||
use error\core\Err;
|
||||
|
||||
class RESTexample{
|
||||
|
||||
public function __construct(){
|
||||
// Routine to execute before each call to RESTexample's method
|
||||
}
|
||||
|
||||
public function __destruct(){
|
||||
// Routine to execute after each call to RESTexample's method
|
||||
}
|
||||
|
||||
|
||||
|
||||
public function article($argv){
|
||||
extract($argv);
|
||||
|
||||
switch(__HTTP_METHOD__){
|
||||
case 'POST':
|
||||
// POST a new article with variables:
|
||||
$title; // new article's title
|
||||
$content; // new article's content
|
||||
|
||||
// ...
|
||||
// process to create article and get $output_created_id
|
||||
// ...
|
||||
|
||||
if( !$success )
|
||||
return ['error' => 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;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,198 @@
|
|||
<?php
|
||||
|
||||
namespace http\core;
|
||||
|
||||
|
||||
class HttpRequest{
|
||||
|
||||
/* [0] Constants
|
||||
=========================================================*/
|
||||
/* (1) Content-Type */
|
||||
const CT_BINARY = 0; // unknown
|
||||
const CT_TEXT = 1;
|
||||
const CT_JSON = 2;
|
||||
const CT_YAML = 3;
|
||||
const CT_MULTIPART_FORM_DATA = 4;
|
||||
const CT_X_WWW_FORM_URLENCODED = 5;
|
||||
|
||||
|
||||
/* [1] Attributes
|
||||
=========================================================*/
|
||||
private $uri;
|
||||
private $headers;
|
||||
private $method;
|
||||
private $postdata;
|
||||
private $getdata;
|
||||
|
||||
private $type;
|
||||
private $body;
|
||||
|
||||
|
||||
/* [2] Constructs an HTTP Request based on environment
|
||||
*
|
||||
* @return instance<HttpRequest> 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<String> `Content-Type` header value
|
||||
*
|
||||
* @return type<int> 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; }
|
||||
}
|
||||
Loading…
Reference in New Issue