Mise en place du code, jusqu'ici développé en local

mvc/Controller.php

@@ -0,0 +1,103 @@
+<?php
+	/**
+	 * Cette classe sert de mère à tous les controlleurs, elle permet de gérer l'ensemble des fonction necessaires à l'affichage de template, à l'écriture de logs, etc.
+	 */
+	class Controller
+	{
+		protected $id; //Id unique du controller actuel
+		protected $callDate; //Date ou l'on a appelé ce controller
+		protected $userIp; //Adresse Ip de l'utilisateur qui demande l'appel de ce controller
+		public function __construct()
+		{
+			$this->id = uniqid(); //On défini un id unique pour ce controller
+			$this->callDate = (new DateTime())->format('Y-m-d H:i:s');
+			$this->userIp = isset($_SERVER['REMOTE_ADDR']) ? $_SERVER['REMOTE_ADDR'] : '127.0.0.1';
+		}
+
+		/**
+		 * Cette fonction permet d'ecrire des logs
+		 * @param string $log = Log a ecrire
+		 * @return booleen : Vrai si succes, faux sinon
+		 */
+		protected function wlog($log)
+		{
+			if(!LOG_ACTIVATED) //Si on a désactivé les logs
+			{
+				return false; //On retourne faux
+			}
+
+			//On forge le message à logger
+			$message = 'FROM [Controller : ' . $this->id . ' - ' . get_called_class() . '] - ' . str_replace("\0", "", $log);
+
+			if(error_log($message)) //On log, si succes
+			{
+				return true; //On retourne vrai
+			}
+
+			return false;
+		}
+
+		/**
+		 * Cette fonction permet d'afficher un template
+		 * @param string $template : Nom du template à afficher
+		 * @param array $variables : Tableau des variables à passer au script, au format 'nom' => valeur (par défaut array())
+		 * @return booleen, Vrai si possible, faux sinon
+		 */
+		protected function render($template, $variables = array())
+		{
+			foreach($variables as $clef => $value)
+			{
+				$$clef = $value;
+			}
+
+			$chemin_template = PWD_TEMPLATES . $template . '.php';
+			if(file_exists($chemin_template))
+			{
+				require_once($chemin_template);
+				unset($chemin_template);
+				return true;
+			}
+
+			return false;
+		}
+
+		/**
+		 * Cette fonction permet de générer une adresse URL interne au site
+		 * @param string $controller : Nom du controleur à employer (par défaut vide)
+		 * @param string $method : Nom de la méthode à employer (par défaut vide)
+		 * @param string $params : Tableau des paramètres $_GET à employer au format 'nom' => valeur (par défaut array())
+		 * @return string, Url générée
+		 */ 
+		protected function generateUrl($controller = '', $method = '', $params = array())
+		{
+			$url = HTTP_PWD;
+			$url .= ($controller ? $controller . '/' : '');
+			$url .= ($method ? $method . '/' : '');
+			foreach ($params as $clef => $valeur)
+			{
+				$url .= $clef . '_' . rawurlencode($valeur) . '/';	
+			}
+
+			return $url;
+		}
+
+		/**
+		 * Cette fonction permet de récupérer le controleur actuel depuis l'URL
+		 * @return string, nom du controleur actuel
+		 */ 
+		protected function getActualControllerName()
+		{
+			$router = new Router($_SERVER['REQUEST_URI']);
+			return $router->getControllerName();
+		}
+
+		/**
+		 * Cette fonction permet de récupérer la méthode actuel depuis l'URL
+		 * @return string, nom de la méthode actuel
+		 */ 
+		protected function getActualMethodName()
+		{
+			$router = new Router($_SERVER['REQUEST_URI']);
+			return $router->getMethodName();
+		}
+	} 

mvc/Model.php

@@ -0,0 +1,240 @@
+<?php
+	/**
+	 * Cette classe sert de mère à tous les modèles, elle permet de gérer l'ensemble des fonction necessaires aux requetes en base de données
+	 * @param $bdd : Une instance de PDO
+	 */
+	class Model
+	{
+		//Les constantes des différents types de retours possibles
+		const NO = 0; //Pas de retour
+		const FETCH = 1; //Retour de type fetch
+		const FETCHALL = 2; //Retour de type fetchall
+		const ROWCOUNT = 3; //Retour de type rowCount()
+
+		protected $bdd; //L'instance de PDO à employer	
+	
+		public function __construct(PDO $bdd)
+		{
+			//Si $bdd est bien une instance de PDO
+			$this->bdd = $bdd;
+		}
+
+		public function getBdd()
+		{
+			return $this->bdd;	
+		}
+
+		public function setBdd(PDO $bdd)
+		{
+			$this->bdd = $bdd;
+		}
+
+		/**
+		 * Cette fonction joue une requete depuis une requete et un tableau d'argument
+		 * @param string $query : Requete à jouer
+		 * @param array $datas : Les données pour la requete. Si non fourni, vide par défaut.
+		 * @param const $return_type : Type de retour à utiliser. (Voir les constantes de la classe Model ici présente). Par défaut FETCHALL
+		 * @param const $fetch_mode : Le type de récupération a effectuer. Par défaut FETCH_ASSOC
+		 * @return mixed : Dépend du type spécifié dans $return_type
+		 */
+		public function runQuery($query, $datas = array(), $return_type = self::FETCHALL, $fetch_mode = PDO::FETCH_ASSOC)
+		{
+			$req = $this->bdd->prepare($query);
+			$req->setFetchMode($return_type);
+			$req->execute($datas);
+
+			switch ($return_type)
+			{
+				case self::NO :
+					$return = NULL;
+					break; 
+
+				case self::FETCH :
+					$return = $req->fetch();
+					break; 
+
+				case self::FETCHALL :
+					$return = $req->fetchAll();
+					break; 
+				
+				case self::ROWCOUNT : 
+					$return = $req->rowCount();
+					break;
+			
+				default : //Par défaut on récupère via fetchAll
+					$return = $req->fetchAll();
+			}
+
+			return $return;
+		}
+		
+		/**
+		* Cette fonction vérifie si une table existe
+		* @param string $table : Nom de la table
+		* @return mixed : Vrai si la table existe, faux sinon
+		*/
+		public function tableExist($table)
+		{
+				$query = '
+					SHOW TABLES LIKE :table
+				';
+				
+				$query_datas = array(
+					'table' => $table
+				);
+				
+				$req = $this->bdd->prepare($query);
+				$req->execute($query_datas);
+				$result = $req->fetch();
+				if(count($result))
+				{
+					return true;
+				}
+
+				return false;
+		}
+
+		/**
+		* Cette fonction vérifie si un champs existe dans une table
+		* @param string $field : Nom du champ
+		* @param string $table : Nom de la table
+		* @return mixed : Vrai si le champs existe, faux, si le champs ou la table n'existe pas
+		*/
+		public function fieldExist($field, $table)
+		{
+			if($this->tableExist($table))
+			{
+				$query = '
+					SHOW COLUMNS FROM ' . $table . ' LIKE :field
+				';
+				
+				$query_datas = array(
+					'field' => $field
+				);
+				
+				$req = $this->bdd->prepare($query);
+				$req->execute($query_datas);
+				$result = $req->fetch();
+				if(count($result))
+				{
+					return true;
+				}
+			}
+
+			return false;
+		}
+
+		/**
+		* Cette fonction permet de récupérer les éléments necessaires à une requete 'IN' depuis un tableau php
+		* @param string $values : Tableau PHP des valeurs
+		* @return array : Tableau des éléments nécessaires ('QUERY' => clause 'IN(...)' à ajouter à la query. 'DATAS' => tableau des valeurs à ajouter à celles passées en paramètre à l'execution de la requete
+		*/
+		public function generateInFromArray($values)
+		{
+			$return = array(
+				'QUERY' => '',
+				'PARAMS' => array(),
+			);
+			
+			$flags = array();
+
+			$values = count($values) ? $values : array();
+			
+			foreach ($values as $clef => $value)
+			{
+				$return['PARAMS']['in_value_' . $clef] = $value;
+				$flags[] = ':in_value_' . $clef;
+			}		
+				
+			$return['QUERY'] .= ' IN(' . implode(', ', $flags) . ')';
+			return $return;
+		}
+
+		/**
+		 * Cette requete retourne le dernier id inséré
+		 * return int : le dernier id inséré
+		 */
+		public function lastId()
+		{
+			return	$this->bdd->lastInsertId();
+		}
+
+		/**
+		 * Cette fonction permet de récupérer la liste de toutes les colonnes d'une table de façon propre, appelable via MySQL. Cela permet de faire des requetes plus optimisée qu'avec "*"
+		 * @param string $table : Nom de la table pour laquelle on veux les colonnes
+		 * @return boolean string : Tous les noms des colonnes liées par des ", ". Ex : 'id, nom, prenom". Si la table n'existe pas, on retourne false.
+		 */
+		public function getColumnsForTable($table)
+		{
+			if ($this->tableExist($table))
+			{
+				$query = 'SHOW COLUMNS FROM ' . $table;
+				
+				$datas = array();
+				
+				$fields = $this->runQuery($query, $datas, self::FETCHALL);
+				$fieldsName = array();
+				foreach ($fields as $field)
+				{
+					$fieldsName[] = $field['Field'];
+				}
+
+				return implode(', ', $fieldsName);
+			}
+
+			return false;
+		}
+
+		/**
+		 * Cette fonction permet de récupérer une table complète, éventuellement en la triant par une colonne, éventuellement en limitant le nombre de résultat, ou en sautant certains (notamment pour de la pagination)
+		 * @param string $table : Le nom de la table a récupérer
+		 * @param string $order_by : Le nom de la colonne par laquelle on veux trier les résultats. Si non fourni, tri automatique
+		 * @param string $desc : L'ordre de tri (asc ou desc). Si non défini, ordre par défaut (ASC)
+		 * @param string $limit : Le nombre maximum de résultats à récupérer (par défaut pas le limite)
+		 * @param string $offset : Le nombre de résultats à ignorer (par défaut pas de résultats ignorés)
+		 * @return array : Tableau avec dans chaque case une ligne de la base
+		 */
+		public function getAll($table, $order_by = '', $desc = false, $limit = false, $offset = false)
+		{
+			if ($this->tableExist($table))
+			{
+				$query = "SELECT " . $this->getColumnsForTable($table) . " FROM " . $table;
+
+				if ($order_by)
+				{
+					if ($this->fieldExist($order_by, $table))
+					{
+						$query .= ' ORDER BY '. $order_by;
+						if ($desc) 
+						{
+							$query .= ' DESC';
+						}
+					}
+				}
+
+				if ($limit !== false)
+				{
+					$query .= ' LIMIT :limit';
+					if ($offset !== false)
+					{
+						$query .= ' OFFSET :offset';
+					}
+				}
+
+				$req = $this->bdd->prepare($query);
+
+				if ($limit !== false)
+				{
+					$req->bindParam(':limit', $limit, PDO::PARAM_INT);
+					if ($offset !== false)
+					{
+						$req->bindParam(':offset', $offset, PDO::PARAM_INT);
+					}
+				}
+
+				$req->setFetchMode(PDO::FETCH_ASSOC);
+				$req->execute();
+				return $req->fetchAll();
+			}
+		}
+	} 

mvc/Router.php

@@ -0,0 +1,201 @@
+<?php
+	/**
+	 * Cette classe gère l'appel des ressources
+	 */
+	class Router
+	{
+		public $route; //Route actuelle
+		public $controllerName; //Nom du controleur obtenu depuis la route de création
+		public $methodName; //Nom de la méthode obtenu depuis la route de création
+		public $params; //Tableau des paramètres GET passé dans la route
+
+		public function __construct($route = '')
+		{
+			if ($route)
+			{
+				$this->route = $route;
+				$this->controllerName = $this->parseController($route);
+				$this->methodName = $this->parseMethod($route);
+				$this->params = $this->parseParams($route);
+			}
+			else
+			{
+				$this->route = '';
+				$this->controllerName = '';
+				$this->methodName = '';
+				$this->params = '';
+			}
+		}
+
+		//Getters et setters
+		public function getRoute()
+		{
+			return $this->route;
+		}
+
+		public function setRoute($value)
+		{
+			$this->route = $route;
+		}
+
+		public function getControllerName()
+		{
+			return $this->controllerName;
+		}
+
+		public function setControllerName($value)
+		{
+			$this->controllerName = $value;
+		}
+
+		public function getMethodName()
+		{
+			return $this->methodName;
+		}
+
+		public function setMethodName($value)
+		{
+			$this->methodName = $value;
+		}
+
+		public function getParams()
+		{
+			return $this->params;
+		}
+
+		public function setParams($value)
+		{
+			$this->params = $value;
+		}
+
+		/**
+		 * Retourne une route avec seulement l'url parsée comme il faut
+		 * @param string $route : La route à analyser
+		 * @return array : Le tableau de la route parsée
+		 */
+		public function parseRoute($route)
+		{
+			$directory_to_remove = strstr(preg_replace('#http(s)?://#', '', HTTP_PWD), '/'); //On retire la partie protocole, et l'adresse du serveur de la partie de la route à ignorer
+			$route = mb_strcut($route, mb_strlen($directory_to_remove)); //On retire la partie à ignorer de la route
+
+			$route = preg_split('#[/?]#', $route); //On explose la route
+
+			foreach($route as $key => $val) //On garde seulement les repertoires non vides
+			{
+				if(empty($val))
+				{
+					unset($route[$key]);
+				}
+			}
+
+			$route = array_values($route); //On remet à 0 les index pour obtenir un tableau propre
+			return $route;
+		}
+
+		/**
+		 * Retrouve le controlleur dans un URL
+		 * @param string $route : la route à analyser
+		 * @return string : Le nom du controleur
+		 */
+		public function parseController($route)
+		{
+			$route = $this->parseRoute($route); //On récupère la route parsé
+			//On lie le bon controlleur
+			if (empty($route[0]) || !file_exists(PWD_CONTROLLER . $route[0] . '.php') || mb_strpos($route[0], 'internal') !== false) //Si on a pas de premier parametre, ou qu'il ne correspond à aucun controlleur
+			{
+				$controllerName = DEFAULT_CONTROLLER; //On défini le nom du controlleur par défaut
+			}
+			else //Sinon, si tout est bon
+			{
+				$controllerName = $route[0]; //On défini le nom du controlleur
+			}
+			
+			return $controllerName;
+		}
+
+		/**
+		 * Retrouve la méthode dans un URL
+		 * @param string $route : la route à analyser
+		 * @return string : Le nom de la methode
+		 */
+		public function parseMethod($route)
+		{
+			$controllerName = $this->parseController($route);
+			require_once(PWD_CONTROLLER . $controllerName . '.php'); //On inclus le controlleur
+			$controller = new $controllerName();
+			$route = $this->parseRoute($route); //On récupère la route parsé
+			//On lie la bonne méthode
+			if (empty($route[1]) || !method_exists($controller, $route[1])) //Si on a pas de second parametre, ou qu'il ne correspond à aucune méthode du controlleur
+			{
+				$method = DEFAULT_METHOD; //On prend la méthode par défaut
+			}
+			else //Sinon, si tout est bon
+			{
+				$method = $route[1]; //On défini la méthode appelée
+			}
+			
+			return $method;
+		}
+
+		/**
+		 * Retrouve les paramètres dans un URL
+		 * @param string $route : la route à analyser
+		 * @return array : La liste des paramètres au format $clef => $valeur
+		 */
+		public function parseParams($route)
+		{
+			$route = $this->parseRoute($route); //On récupère la route parsé
+			$params = array();
+			$already_use_params = array();
+			//On transforme les paramètres $_GET passés par l'url au format clef_value. Ex : prenom_pierre-lin = $_GET['prenom'] => 'pierre-lin'
+			if (count($route) > 2) //Si on a plus de deux paramètres qui ont été passé
+			{
+				unset($route[0], $route[1]); //On supprime le controlleur, et la route, des paramètres, il ne reste que les parametres a passer en GET
+				foreach($route as $param) //On passe sur chaque paramètre a transformer en GET
+				{
+					$param = explode('_', $param, 2); //On récupère le paramètre, via la délimiteur '_', en s'arretant au premier
+
+					//Si on a déjà utilisé cette variable GET
+					if (in_array($param[0], $already_use_params))
+					{
+						if (isset($params[$param[0]]))
+						{
+							$tmp_value = $params[$param[0]];
+							$params[$param[0]] = array($tmp_value);
+							unset($tmp_value);
+						}
+
+						$params[$param[0]][] = (isset($param[1])) ? rawurldecode($param[1]) : NULL;
+					}
+					else
+					{
+						$params[$param[0]] = (isset($param[1])) ? rawurldecode($param[1]) : NULL; //On définit la propriétée GET correspondante
+						$already_use_params[] = $param[0];
+					}
+				}
+			}
+
+			return $params;
+		}
+
+		/**
+		 * Cette fonction permet de charger la page adaptée a partir d'une url
+		 * @param string $route : Route à analyser pour charger une page
+		 * @return void
+		 */
+		public function loadRoute($route)
+		{
+			$_GET = array_merge($_GET, $this->parseParams($route)); //On fusionne les paramètres GET et ceux passés dans la route du controller
+			$controllerName = $this->parseController($route); //On récupère le nom du controleur à appeler
+			$controller = new $controllerName(); //On créer le controleur
+			$beforeMethodName = DEFAULT_BEFORE; //On défini le nom de la fonction before
+			if (method_exists($controller, $beforeMethodName)) //Si une fonction before existe pour ce controller, on l'appel
+			{
+				$controller->$beforeMethodName(); //On appel la fonction before
+			}
+
+			$methodName = $this->parseMethod($route); //On récupère le nom de la méthode
+			$controller->$methodName(); //On appel la méthode	
+		}
+
+	} 

mvc/autoload.php

@@ -0,0 +1,22 @@
+<?php
+	/**
+	 * Cette fonction permet le chargement automatique des classes. Cela permet de ne pas avoir à instancier chaque classe.
+	 */
+	
+	/**
+	 * Cette fonction inclus le fichier de class
+	 * @param string $class = Nom de la classe a aller chercher
+	 */
+	function autoloader($class)
+	{
+		if (file_exists(PWD_CONTROLLER . $class . '.php'))
+		{
+			require_once(PWD_CONTROLLER . $class . '.php');
+		}
+		else if (file_exists(PWD_MODEL . $class . '.php'))
+		{
+			require_once(PWD_MODEL . $class . '.php');
+		}
+	}
+	
+	spl_autoload_register('autoloader');

mvc/conn_bdd.php

@@ -0,0 +1,19 @@
+<?php
+	//CETTE PAGE GERE LA CONNEXION A LA BASE DE DONNEES
+	$host = 'localhost';
+	$dbname = 'raspisms';
+	$user = 'root';
+	$password = 'DATABASE_PASSWORD';
+
+	try
+	{
+		// On se connecte à MySQL
+		$bdd = new PDO('mysql:host=' . $host . ';dbname=' . $dbname, $user, $password, array(PDO::ATTR_PERSISTENT => TRUE));
+		$bdd->exec("SET CHARACTER SET utf8");
+	}
+	catch(Exception $e)
+	{
+		// En cas d'erreur, on affiche un message et on arrête tout
+		die('Erreur : '.$e->getMessage());
+	}
+?>

mvc/constants.php

@@ -0,0 +1,33 @@
+<?php
+	/*
+		Ce fichier défini les constantes du MVC
+	*/
+
+	//On définit les chemins
+        define('PWD', '/var/www/RaspiSMS/'); //On défini le chemin de base du site
+	define('HTTP_PWD', (isset($_SERVER['HTTPS']) ? 'https' : 'http') . '://' . (isset($_SERVER['SERVER_NAME']) ? $_SERVER['SERVER_NAME'] : 'localhost') . '/RaspiSMS/'); //On défini l'adresse url du site
+
+	define('PWD_IMG', PWD . 'img/'); //Chemin dossier des images
+	define('HTTP_PWD_IMG', HTTP_PWD . 'img/'); //URL dossier des images
+
+	define('PWD_CSS', PWD . 'css/'); //Chemin dossier des css
+	define('HTTP_PWD_CSS', HTTP_PWD . 'css/'); //URL dossier des css
+
+	define('PWD_JS', PWD . 'js/'); //Chemin dossier des js
+	define('HTTP_PWD_JS', HTTP_PWD . 'js/'); //URL dossier des js
+
+	define('PWD_CONTROLLER', PWD . 'controllers/'); //Dossier des controllers
+	define('PWD_MODEL', PWD . 'model/'); //Dossier des models
+	define('PWD_TEMPLATES', PWD . 'templates/'); //Dossier des templates
+	
+	define('PWD_SCRIPTS', PWD . 'scripts/'); //URL dossier des scripts appelables via les commandes
+	define('PWD_RECEIVEDS', PWD . 'receiveds/'); //URL dossier des sms reçus via les commandes
+
+
+	//On défini les controlleurs et methodes par défaut
+	define('DEFAULT_CONTROLLER', 'dashboard'); //Nom controller appelé par défaut
+	define('DEFAULT_METHOD', 'byDefault'); //Nom méthode appelée par défaut
+	define('DEFAULT_BEFORE', 'before'); //Nom méthode before par défaut
+
+	//Réglages des logs
+	define('LOG_ACTIVATED', 1); //On active les logs

mvc/pingback.php

@@ -0,0 +1,23 @@
+<?php 
+	/*
+		Ce fichier permet d'envoyer l'adresse IP du modèle MVC au premier démarrage.
+		Il sera détruit immédiatement après.
+		Il est légitime que vous vous posiez la question de savoir pourquoi votre IP est envoyée à un serveur central.
+		
+		Ce modèle MVC est distrubué sous license GNU/GPL, gratuitement. Le seul bénèfice que nous retirons de ce système, en dehors du plaisir d'aider la communauté, et l'expérience qu'il nous apporte.
+		Afin de pouvoir justifier de cette expérience, notamment sur un CV, nous devons êtres à même de donner une estimation du nombre de serveurs faisant tourner notre système MVC.
+		De plus, cela nous permet de connaître à des fin statistiques le nombre d'installations.
+		Afin que tout le monde puisse se rendre compte de l'étendue de la communauté utilisant ce système, la liste de ces serveurs est disponible à l'adresse ajani.fr/mvc.
+		
+		Aucune autre données que vôtre adresse IP/URL ne seront récupérées. Cette adresse ne sera jamais utilisées dans un autre cadre que celui décrit ci-dessus.
+		Vous avez notre parole, nous espérons avoir votre confiance.
+	*/
+	$url = $_SERVER['HTTP_HOST'];
+	$path = $_SERVER['REQUEST_URI'];
+	
+	$url = rawurlencode($url);
+	$path = rawurlencode($path);
+?>
+	<img src="<?php echo htmlspecialchars('http://ajani.fr/mvc/save.php?url=' . $url . '&path=' . $path, ENT_QUOTES); ?>" style="display:none;" />
+<?php
+	@file_put_contents(PWD . 'mvc/pingback.php', '<?php #File remove');

mvc/secho.php

@@ -0,0 +1,55 @@
+<?php
+	/*
+	Cette fonction affiche une chaine en échappant les entités HTML.
+	Le HTML pure est échappé.
+	Si le texte fourni n'existe pas, on retourne faux.
+
+	SYNTAXE : escapehtml(string &$text_source[, boolean $no_nl2br = false[, boolean $escape_quotes = false]])
+
+	ARGUMENTS : 
+		Obligatoires : 
+			- string &$text_source : Une variable passé par référence qui sera utilisé comme texte source
+		Optionnels : 
+			- boolean $no_nl2br : Par défaut à faux -> les retours à la lignes sont transformé en <br/>. A vrai -> ils sont conservés tels quels
+			- boolean $escape_quotes : Par défaut à faux -> les guillemets ne sont pas échappés. A vrai -> ils sont transformés en entitées HTML
+			- boolean $authorize_null : Par défaut à vrai -> Les valeurs '', 0, null, ou false sont considérées comme définies. A faux -> considérées comme non définies
+
+	RETOUR : Cette fonction retourne le texte transformé en cas de success, false sinon
+	*/
+
+	function secho(&$text_source, $no_nl2br = false, $escape_quotes = false, $authorize_null = true) //On utilise une reference, si la variable n'existe pas, ça ne lévera pas d'erreur
+	{
+		if ($authorize_null) //Si on les variables null, false ou '' doivent être prises comme définies
+		{
+			if(!isset($text_source)) //Si la variable n'existe pas
+			{
+				return false; //On retourne faux
+			}
+		}
+		else
+		{
+			if(empty($text_source)) //Si la variable n'existe pas OU est vide
+			{
+				return false; //On retourne faux
+			}
+		}
+		
+		//On met dans une nouvelle variable le texte, pour ne pas le modifier	
+		$text = $text_source;
+		
+		if($escape_quotes)
+		{
+			$text = htmlspecialchars($text, ENT_QUOTES); //On échappe le html
+		}
+		else
+		{
+			$text = htmlspecialchars($text); //On échappe le html
+		}
+
+		if(!$no_nl2br) //Si doit activer la transformation des retours à la ligne
+		{
+			$text = nl2br($text); //On affiche la variable
+		}
+
+		echo $text; //On retourne le texte echappé
+	}