SMMP/build/api/core/Request.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
		public 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 instance<Request>	Instance crée
		*
		*/
		public function __construct($path=null, $params=null){

			return $this->buildRequestObject($path, $params);

		}



		/* CONSTRUCTEUR D'UNE REQUETE DE MODULE (DELEGATION)
		*
		* @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
		*
		*/
		private function buildRequestObject($path=null, $params=null){
			/* [1] Initialisation
			=========================================================*/
			/* (1) Erreur par défaut */
			$this->error = new Error(Err::Success);

			/* (2) Si pas parametre manquant, on quitte */
			if( $path == null )
				return $this->error->set(Err::MissingPath);


			/* [2] On met a jour la configuration
			=========================================================*/
			/* (1) Vérification existence fichier config */
			if( !file_exists(self::config_path()) )
				return $this->error->set(Err::UnreachableResource);

			/* (2) Lecture fichier config */
			$conf = @file_get_contents(self::config_path());

			/* (3) Si erreur lecture */
			if( $conf === false )
				return $this->error->set(Err::UnreachableResource);

			/* (4) Parsage json */
			$this->modules = json_decode( $conf, true );

			/* (5) Gestion de l'erreur de parsage */
			if( $this->modules == null )
				return $this->error->set(Err::ParsingFailed, 'json');



			/* [3] Verification des types des parametres
			=========================================================*/
			/* (1) Si path est une <string> */
			if( !is_string($path) )  // Si le type est incorrect
				return $this->error->set(Err::WrongPathModule);

			/* (2) Formattage @params en tableau */
			$params = (is_array($params)) ? $params : [];

			/* (3) On définit en constante la méthode HTTP */
			if( !isset($_SERVER['REQUEST_METHOD']) )
				return $this->error->set(Err::UnknownHttpMethod);

			$this->http_method = strtoupper($_SERVER['REQUEST_METHOD']);


			/* [4] Verification du chemin (existence module+methode)
			=========================================================*/
			if( !$this->checkPath($path) ) // Verification de la coherence du chemin + attribution
				return false; // checkPath() sets the error itself


			/* [5] Verification des droits
			=========================================================*/
			if( !$this->checkPermission() ) // Si on a pas les droits
				return false; // checkPermission() sets the error itself


			/* [6] Verification des parametres (si @type est defini)
			=========================================================*/
			if( !$this->checkParams($params) ) // Verification de tous les types
				return false; // checkParams() sets the error itself


			/* [7] Récupèration des options
			=========================================================*/
			$this->buildOptions();


			/* [8] 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;

			return true;
		}



		/* 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 = __PUBLIC__.$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")
		*
		* @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){

			/* [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();

			$data = $_POST;

			/* [2] 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
				return $this->error->set(Err::WrongPathModule);

			// 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
				return $this->error->set(Err::UnknownModule, $module);


			/* [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
				return $this->error->set(Err::UnknownMethod, preg_replace('/\w+::/i', '', $method) );



			/* [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
			=========================================================*/
			// if no AuthSystem set up, use the default one
			if( !is_object(self::$authsystem) || !self::$authsystem instanceof AuthSystem ){

				// try to load default AuthSystem
				if( !file_exists(__BUILD__.'/api/core/AuthSystemDefault.php') )
					return $this->error->set(Err::UnreachableResource);

				// load default AuthSystem class
				$classname =  '\\api\\core\\AuthSystemDefault';
				self::$authsystem = new $classname();
			}

			// Check permission using user-implemented AuthSystem
			$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
			=========================================================*/
			/* (1) Si @params n'est pas un tableau */
			if( !is_array($params) )
				return $this->error->set(Err::MissingParam);

			/* (2) On récupère les données de la méthode */
			$method = $this->modules[$this->path['module']][$this->path['method']];

			/* (3) Si pas 'parameters' dans la config */
			if( !isset($method['parameters']) || !is_array($method['parameters']) )
				return $this->error->set(Err::ConfigError);


			/* [2] Si le type est defini, pour chaque param, on teste
			=========================================================*/
			foreach($method['parameters'] as $name=>$paramsdata){

				/* (1) Vérification des données
				---------------------------------------------------------*/
				/* (1) Si @name n'est pas une string */
				if( !is_string($name) )
					return $this->error->set(Err::ConfigError);

				/* (2) Si @paramsdata n'est pas un tableau */
				if( !is_array($paramsdata) )
					return $this->error->set(Err::ConfigError);

				/* (3) So @paramsdata['type] manquant ou incorrect */
				if( !isset($paramsdata['type']) || !is_string($paramsdata['type']) )
					return $this->error->set(Err::ConfigError);


				/* (2) Gestion des spécifications
				---------------------------------------------------------*/
				/* (1) On récupère si le paramètre est optionnel ou pas */
				$optional = isset($paramsdata['optional']) && $paramsdata['optional'] === true;

				/* (2) Si de type 'FILE' + fichier existe => on enregistre la ref. */
				if( $paramsdata['type'] == 'FILE' && isset($_FILES[$name]) )
					$params[$name] = &$_FILES[$name];

				/* (3) Si param obligatoire et manquant -> erreur */
				if( !isset($params[$name]) && !$optional )
					return $this->error->set(Err::MissingParam, $name);


				/* (3) Gestion des valeurs
				---------------------------------------------------------*/
				/* (1) Si le paramètre est optionnel et manquant */
				if( $optional && !isset($params[$name]) ){

					// On le crée le param optionnel avec la valeur NULL
					$params[$name] = null;

				/* (2) Si le paramètre est renseigné (sauf FILE) */
				}elseif( $paramsdata['type'] != 'FILE'){

					// Si la verification est fausse, on retourne faux
					if( !Checker::run($paramsdata['type'], $params[$name]) )
						return $this->error->set(Err::WrongParam, $name, $paramsdata['type']);

				}

			}

			/* [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']);
		}


	}

?>