Intégration du 'Checker' + Quelques manager

index.php

@@ -7,6 +7,7 @@
 	use \manager\ModuleResponse;
 	use \manager\ManagerError;
 	use \manager\Database;
+	use \manager\Checker;
 	use \manager\MenuManager;
 
 
@@ -31,8 +32,8 @@
 
 	/* (2) Gestion de la connection */
 	$login_vars =                isset($_POST['login-sub']);
-	$login_vars = $login_vars && isset($_POST['login'])    && Database::check('varchar(3,50)', $_POST['login']);
+	$login_vars = $login_vars && isset($_POST['login'])    && Checker::run('varchar(3,50)', $_POST['login']);
-	$login_vars = $login_vars && isset($_POST['password']) && Database::check('text', $_POST['password']);
+	$login_vars = $login_vars && isset($_POST['password']) && Checker::run('text', $_POST['password']);
 
 	// Status de login
 	$_SESSION['login_status'] = 'no';

manager/Checker.php

@@ -0,0 +1,146 @@
+<?php
+
+	namespace manager;
+
+
+	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;
+
+				default:
+					return false;
+					break;
+			}
+
+			return $checker;
+
+		}
+
+
+	}
+?>

manager/Database.php

@@ -164,132 +164,6 @@
 
 
 
-		////////////////////////////////////////////////////////////////
-		//                 _  __ _           _   _
-		// __   _____ _ __(_)/ _(_) ___ __ _| |_(_) ___  _ __  ___
-		// \ \ / / _ \ '__| | |_| |/ __/ _` | __| |/ _ \| '_ \/ __|
-		//  \ V /  __/ |  | |  _| | (_| (_| | |_| | (_) | | | \__ \
-		//   \_/ \___|_|  |_|_| |_|\___\__,_|\__|_|\___/|_| |_|___/
-		//
-		////////////////////////////////////////////////////////////////
-
-
-		/* 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 check($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)
-			=========================================================*/
-			if( preg_match('/^varchar\((\d+), ?(\d+)\)$/', $type, $match) ){
-				// On recupere la taille min
-				$min = (int) $match[1];
-				// On recupere la taille max
-				$max = (int) $match[2];
-
-				// On effectue la verification
-				return $checker && is_string($value) && strlen($value) <= $max && strlen($value) >= $min;
-			}
-
-
-			/* [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::check($elements_type, $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;
-
-				// 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
-				case 'sha1':
-					return $checker && is_string($value) && preg_match('/^[\da-f]{40}$/i', $value);
-					break;
-
-				// Numéro de téléphone
-				case 'number':
-					return $checker && is_string($value) && preg_match('/^(?:0|\+33 ?|0?0?33 ?|)([1-9] ?(?:[0-9] ?){8})$/i', $value);
-					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;
-
-				default:
-					return false;
-					break;
-			}
-
-			return $checker;
-
-		}
-
-
-
-
 
 		/* FONCTION QUI FORMATTE UN NUMÉRO DE TÉLÉPHONE
 		*

manager/ModuleRequest.php

@@ -2,6 +2,7 @@
 
 	namespace manager;
 	use \manager\Database;
+	use \manager\Checker;
 
 
 	class ModuleRequest{
@@ -380,7 +381,7 @@
 
 			/* [2] Gestion si un @token est defini
 			=========================================================*/
-			if( Database::check('sha1', $token) ){
+			if( Checker::run('sha1', $token) ){
 
 
 				/* (1) On verifie que le token est valide */
@@ -478,7 +479,7 @@
 				/* (6) Si le paramètre est renseigné */
 				}else
 					// Si la verification est fausse, on retourne faux
-					if( !Database::check($paramsdata['type'], $params[$name]) )
+					if( !Checker::run($paramsdata['type'], $params[$name]) )
 						return false;
 
 			}

manager/ORM/SQLBuilder.php

@@ -0,0 +1,388 @@
+<?php
+
+	namespace manager\ORM;
+
+	use \manager\Database;
+	use \manager\ORM\Rows;
+
+
+	class SQLBuilder{
+
+
+		/* CONSTRUIT LA REQUETE FORMATTEE "SELECT" AVEC UNE LISTE DE CHAMPS
+		*
+		* @sqlFields<Array> 										Liste de champs : [table => field => [func, alias] ]
+		*
+		* @return sql<Array> 									Renvoie un tableau formatté
+		*
+		*/
+		public static function SELECT($sqlFields){
+			return $sqlFields;
+		}
+
+
+
+
+
+
+
+		/* CONSTRUIT LA REQUETE FORMATTEE "GROUP BY" AVEC UNE LISTE DE CHAMPS
+		*
+		* @tables<Array> 											Liste de champs : [table => fields]
+		*
+		* @return sql<Array> 										Renvoie un tableau formatté
+		*
+		*/
+		public static function GROUPBY($tables){
+			return $tables;
+		}
+
+
+
+
+
+
+		/* CONSTRUIT LA REQUETE FORMATTEE "FROM" AVEC UNE LISTE DE TABLES
+		*
+		* @tables<Array> 										Liste de tables OU SQL PUR
+		*
+		* @return sql<Array> 									Renvoie un tableau formatté
+		*
+		*/
+		public static function FROM($tables){
+			return $tables;
+		}
+
+
+
+
+
+
+		/* CONSTRUIT LA REQUETE FORMATTEE "UPDATE" AVEC LA TABLE EN QUESTION
+		*
+		* @table<String> 										Table en question
+		*
+		* @return sql<Array> 									Renvoie un tableau formatté
+		*
+		*/
+		public static function UPDATE($table){
+			return $table;
+		}
+
+
+
+
+
+
+		/* CONSTRUIT LA REQUETE FORMATTEE "DELETE" AVEC LA TABLE EN QUESTION
+		*
+		* @table<String> 										Table en question
+		*
+		* @return sql<Array> 									Renvoie un tableau formatté
+		*
+		*/
+		public static function DELETE($table){
+			return $table;
+		}
+
+
+
+
+
+
+		/* CONSTRUIT LA REQUETE TEXTUELLE "IN" AVEC UNE LISTE DE TABLES
+		*
+		* @field<Array> 										Tableau contenant [table, field]
+		* @array<Array>											Valeurs de la clause IN
+		* @offset<int>											Permet de rendre la condition unique (nommage des variables)
+		* @bound<Arary>										Tableau associatif contenant les variables "bindés" -> ajout des champs
+		*
+		* @return sql<String> 									Renvoie le textuel formatté
+		*
+		*/
+		public static function IN($field, $array, $offset=0, &$bound){
+			/* [0] Initialisation
+			=========================================================*/
+			$sql  = '';
+
+			/* [1] On construit la requête
+			=========================================================*/
+			/* (1) Champ */
+			$sql .= $field[0].'.'.$field[1].' IN (';
+
+			/* (2) Valeurs */
+			$c = 0;
+			foreach($array as $i=>$value){
+				if( $c > 0 ) $sql .= ', ';
+
+				$sql .= ':'.$field[0].'_x_'.$field[1].'_'.$offset.'_'.$i;
+
+				$bound[':'.$field[0].'_x_'.$field[1].'_'.$offset.'_'.$i] = $value;
+
+				$c++;
+			}
+
+			return $sql.")";
+		}
+
+
+
+
+
+		/* CONSTRUIT LA REQUETE TEXTUELLE "WHERE" AVEC UNE LISTE DE TABLES
+		*
+		* @field<Array> 										Tableau contenant [table, field]
+		* @valeur<Array>										Valeurs de la clause WHERE [valeur, opérateur]
+		* @offset<int>											Permet de rendre la condition unique (nommage des variables)
+		* @bound<Arary>										Tableau associatif contenant les variables "bindés" -> ajout des champs
+		*
+		* @return sql<String> 									Renvoie le textuel formatté
+		*
+		*/
+		public static function WHERE($field, $value, $offset=0, &$bound){
+			/* [0] Initialisation
+			=========================================================*/
+			$sql  = '';
+
+
+			/* [1] On construit la requête
+			=========================================================*/
+			/* (1) Chamo */
+			$sql .= $field[0].'.'.$field[1].' ';
+
+			/* (2) Opérateur */
+			$sql .= substr($value[1], 2, -2).' ';
+
+			/* (3) Variable */
+			$sql .= ':'.$field[0].'_x_'.$field[1].'_'.$offset;
+
+			$bound[':'.$field[0].'_x_'.$field[1].'_'.$offset] = $value[0];
+
+
+			return $sql;
+		}
+
+
+
+
+
+		/* CONSTRUIT LA REQUETE FORMATTEE "SET" AVEC UNE LISTE DE TABLES
+		*
+		* @values<Array> 										Tableau de la forme [ field=>value, field2=>value2 ]
+		* @bound<Arary>										Tableau associatif contenant les variables "bindés" -> ajout des champs
+		*
+		* @return sql<Array> 									Renvoie un tableau formatté
+		*
+		*/
+		public static function SET($values, &$bound){
+			/* [0] Initialisation
+			=========================================================*/
+			$sql  = [];
+
+
+			/* [1] On construit la requête
+			=========================================================*/
+			$c = 0;
+			foreach($values as $field=>$value){
+				/* (1) Champ */
+				$sql[$c] = $field.' = ';
+
+				/* (2) Variable */
+				$sql[$c] .= ':update_'.$field;
+
+				$bound[':update_'.$field] = $value;
+
+				$c++;
+			}
+
+			return $sql;
+		}
+
+
+
+
+
+		/* CONSTRUIT LA REQUETE FORMATTEE "LIMIT" AVEC UN NOMBRE D'ENTREES
+		*
+		* @count<int> 											Nombre limite
+		*
+		* @return sql<Array> 									Renvoie un sql formatté
+		*
+		*/
+		public static function LIMIT($count=null){
+			/* [0] Initialisation
+			=========================================================*/
+			$sql  = '';
+
+
+			/* [1] On construit la requête
+			=========================================================*/
+			if( intval($count) == $count )
+				$sql = intval($count);
+
+			return $sql;
+		}
+
+
+
+
+
+
+
+
+
+
+
+
+
+		/* CONSTRUIT LA REQUETE A PARTIR D'UNE REQUETTE FORMATTEE
+		*
+		* @request<Arary> 										Requête formattée
+		*
+		* @return sql<String> 									Requête formattée en SQL
+		*
+		*/
+		public static function BUILD($request){
+			/* [0] On initialise le retour
+			=========================================================*/
+			$sql = '';
+
+			/* [1] Gestion dans l'ordre
+			=========================================================*/
+			foreach($request as $clause=>$statements){
+
+				switch($clause){
+
+					/* (1) Clause SELECT
+					---------------------------------------------------------*/
+					case 'SELECT':
+						$sql .= "SELECT ";
+						$c = 0;
+						foreach($statements as $table=>$fields)
+							foreach($fields as $field=>$select){
+
+								/* (1) On construit le nom du champ */
+								$fieldStr = "$table.$field";
+
+								/* (2) On ajout le DISTINCT s'il y a lieu */
+								if( isset($select[1]) && $select[1] )
+									$fieldStr = "DISTINCT $fieldStr";
+
+								/* (3) On ajoute la fonction d'aggrégation s'il y a lieu */
+								if( isset($select[0]) && !is_null($select[0]) )
+									$fieldStr = substr($select[0], 2, -2)."($fieldStr)";
+
+
+								/* (4) On ajoute l'alias */
+								if( isset($select[0]) && !is_null($select[0]) )
+									$fieldStr = "$fieldStr as agg_$field";
+								else
+									$fieldStr = "$fieldStr";
+
+								$sql .= ($c==0) ? "$fieldStr" : ", $fieldStr";
+
+								$c++;
+							}
+
+							$sql .= "\n";
+						break;
+
+					/* (2) Clause FROM
+					---------------------------------------------------------*/
+					case 'FROM':
+							$sql .= 'FROM ';
+
+							$c = 0;
+							foreach($statements as $field){
+								$sql .= ($c==0) ? "$field" : ", $field";
+								$c++;
+							}
+
+							$sql .= "\n";
+						break;
+
+
+					/* (3) Clause WHERE
+					---------------------------------------------------------*/
+					case 'WHERE':
+							$c = 0;
+							foreach($statements as $field){
+								$sql .= ($c==0) ? "WHERE $field\n" : "AND   $field\n";
+								$c++;
+							}
+
+							$sql .= ($c==0) ? '' : "\n";
+						break;
+
+
+
+					/* (4) Clause LIMIT
+					---------------------------------------------------------*/
+					case 'LIMIT':
+							if( is_numeric($statements) )
+								$sql .= 'LIMIT '.intval($statements);
+						break;
+
+
+					/* (5) Clause DELETE
+					---------------------------------------------------------*/
+					case 'DELETE':
+							$sql .= "DELETE FROM $statements\n";
+						break;
+
+
+					/* (6) Clause UPDATE
+					---------------------------------------------------------*/
+					case 'UPDATE':
+							$sql .= "UPDATE $statements\n";
+						break;
+						break;
+
+
+					/* (7) Clause SET
+					---------------------------------------------------------*/
+					case 'SET':
+							$c = 0;
+							foreach($statements as $field){
+								$sql .= ($c>0) ? "\n, $field" : "SET $field";
+								$c++;
+							}
+							$sql .= "\n";
+						break;
+
+					/* (8) Clause GROUP BY
+					---------------------------------------------------------*/
+					case 'GROUPBY':
+							$sql .= 'GROUP BY ';
+
+							$c = 0;
+							foreach($statements as $table=>$fields)
+								foreach($fields as $field){
+									$sql .= ($c==0) ? "$table.$field" : ", $table.$field";
+									$c++;
+								}
+
+							$sql .= "\n";
+						break;
+				}
+
+
+			}
+
+
+
+
+
+
+
+			/* [2] On retourne le résultat
+			=========================================================*/
+			return $sql;
+		}
+
+
+
+	}
+
+
+?>

manager/ORM/Table.php

@@ -0,0 +1,131 @@
+<?php
+
+
+	namespace manager\ORM;
+
+	use \manager\Database;
+	use \manager\ManagerError;
+	use \manager\ORM\Rows;
+
+
+	// CLASSE MAITRE
+	class Table{
+
+		private static $database = 'stefproject';
+
+
+		/* RENVOIE LES DONNEES D'UNE TABLE
+		*
+		* @table<String> 										Nom de la table à selectionner
+		*
+		* @return this<ORM> 									Retourne une instance de l'ORM
+		*
+		*/
+		public static function get($table_name){
+			/* [0] Initialisation des attributs
+			=========================================================*/
+			$schema = [
+				'database' => self::$database,
+				'table'    => null,
+				'columns'  => null
+			];
+
+
+			/* [1] On vérifie que la table existe
+			=========================================================*/
+			/* (1) Requête */
+			$checkTable       = Database::getPDO()->query("SHOW tables FROM ".self::$database);
+			$checkTableResult = Database::delNumeric( $checkTable->fetchAll() );
+
+			/* (2) On met en forme les données */
+			$tables = [];
+			foreach($checkTableResult as $table)
+				$tables[] = $table['Tables_in_'.self::$database];
+
+			/* (3) Si n'existe pas, on renvoie une erreur */
+			if( !in_array($table_name, $tables) )
+				return null;
+
+			/* (4) On enregistre les données */
+			$schema['table'] = $table_name;
+
+
+
+			/* [2] Si la table existe, on récupère les colonnes
+			=========================================================*/
+			/* (1) On récupère les colonnes */
+			$getColumns    = Database::getPDO()->query("SHOW columns FROM ".self::$database.'.'.$table_name);
+			$columnsResult = Database::delNumeric( $getColumns->fetchAll() );
+
+			/* (2) On met en forme les données */
+			$columns = [];
+			foreach($columnsResult as $col){
+				// On formatte le type //
+				$type = $col['Type'];
+				if( preg_match('/^(int|float|varchar|text)/i', $type, $m) )
+					$type = strtolower($m[1]);
+
+				// On ajoute la colonne //
+				$columns[$col['Field']] = [
+					'type'    => $type,
+					'primary' => $col['Key'] == 'PRI'
+				];
+			}
+
+
+			/* (3) Si on trouve rien, on envoie une erreur */
+			if( !is_array($columns) || count($columns) == 0 )
+				return null;
+
+			/* (4) On enregistre les colonnes */
+			$schema['columns'] = $columns;
+
+
+
+			/* [3] On récupère les clés étrangères
+			=========================================================*/
+			/* (1) On récupère le texte du 'CREATE TABLE' */
+			$getCreateTable = Database::getPDO()->query("show create table ".$table_name);
+			$create_table = $getCreateTable->fetch()['Create Table'];
+
+			/* (2) On découpte en lignes */
+			$create_table_lines = explode("\n", $create_table);
+
+			/* (3) Pour chaque ligne, si c'est une contrainte, on l'enregistre dans la colonne associée */
+			foreach($create_table_lines as $i=>$line)
+				if( preg_match('/CONSTRAINT `.+` FOREIGN KEY \(`(.+)`\) REFERENCES `(.+)` \(`(.+)`\)+/i', $line, $m) )
+					$schema['columns'][$m[1]]['references'] = [$m[2], $m[3]];
+
+
+
+			/* [3] On renvoie une instance de 'Rows'
+			=========================================================*/
+			return new Rows($schema);
+
+		}
+
+
+
+	};
+
+
+
+	// // USE CASE :: ACCESS TABLE
+	// ORM::Table  = ORM::Table('user');
+	//
+	// // USE CASE :: getBy{ATTRIBUTE}
+	// ORM::Row    = ORM::Table->getByUsername('someUsername'); // ORM_FETCH by default
+	// ORM::Row    = ORM::Table->getByUsername('someUsername', ORM_FETCH);
+	// ORM::Column = ORM::Table->getByUsername('someUsername', ORM_FETCHALL);
+	//
+	// // USE CASE :: getById -> primary key(s)
+	// ORM::Row    = ORM::Table->getById(5, 7); // because PRIMARY KEY is composed by '5' and '7'
+	//
+	// // USE CASE :: getAll
+	// ORM::Column = ORM::Table->getAll();
+	//
+	// // USE CASE :: select(FIELD)
+	// mixed       = ORM::Row->select('username');
+	//
+	// // USE CASE :: select(FIELD1, FIELD2, ...)
+	// mixed       = ORM::Row->select('id_user', 'username');

manager/Repo.php

@@ -6,8 +6,8 @@
 	// FORMAT:
 	//
 	// path:  "nomModule/nomMethode"
-	// data1: {donnee1}
+	// params1: {donnee1}
-	// data2: {donnee2}
+	// params2: {donnee2}
 	// ...
 	//
 	//
@@ -17,12 +17,12 @@
 	class Repo{
 
 		// Constantes
-		public static $config_path = __ROOT__.'/config/repositories.json';
+		public static function config_path(){ return __ROOT__.'/config/repositories.json'; }
 
 
 		// Attributs prives utiles (initialisation)
 		private $path;
-		private $data;
+		private $params; // Paramètres de la requête
 		private $repositories;
 
 		// Contiendra la reponse a la requete
@@ -38,12 +38,13 @@
 		/* CONSTRUCTEUR D'UNE REQUETE DE MODULE
 		*
 		* @path<String>				Chemin de delegation ("repo/methode")
-		* @data<Array>				Tableau contenant les parametres utiles au traitement
+		* @params<Array>			Tableau contenant les parametres utiles au traitement
 		*
 		* @return status<Boolean>	Retourne si oui ou non tout s'est bien passe
 		*
 		*/
-		public function __construct($path=null, $data=null){
+		public function __construct($path=null, $params=null){
+
 			// Si pas parametre manquant, on quitte
 			if( $path == null ){
 				$this->error = ManagerError::MissingPath;
@@ -53,7 +54,7 @@
 			/* [0] On met a jour la configuration
 			=========================================================*/
 			// Modules specifies
-			$this->repositories = json_decode( file_get_contents(self::$config_path), true );
+			$this->repositories = json_decode( file_get_contents(self::config_path()), true );
 
 			// Gestion de l'erreur de parsage
 			if( $this->repositories == null ){
@@ -71,8 +72,8 @@
 				return false; // On retourne FALSE, si erreur
 			}
 
-			// Type de @data (optionnel)
+			// Type de @params (optionnel)
-			$data = (is_array($data)) ? $data : array();
+			$params = (is_array($params)) ? $params : [];
 
 
 			/* [2] Verification du chemin (existence repo+methode)
@@ -84,7 +85,7 @@
 
 			/* [3] Construction de l'objet
 			=========================================================*/
-			$this->data = $data;
+			$this->params = $params;
 			$this->error = ManagerError::Success;
 
 			/* [4] Enregistrement de la reponse
@@ -101,6 +102,9 @@
 
 
 		public function answer(){
+			if( $this->error != ManagerError::Success )
+				return false;
+
 			return $this->answer;
 		}
 
@@ -128,7 +132,7 @@
 
 			/* [3] On amorce la methode
 			=========================================================*/
-			return call_user_func_array( $this->getFunctionCaller(), $this->data );
+			return call_user_func_array( $this->getFunctionCaller(), $this->params );
 		}
 
 
@@ -150,7 +154,7 @@
 
 			// On recupere les donnes de la regex
 			$repository = $matches[1];
-			$method = $matches[2];
+			$method     = $matches[2];
 
 			/* [2] Verification de l'existence du repo (conf)
 			=========================================================*/
@@ -170,10 +174,10 @@
 
 			/* [4] Enregistrement du chemin et renvoi de SUCCESS
 			=========================================================*/
-			$this->path = array(
+			$this->path = [
 				'repo' => $repository,
 				'method' => $method
-			);
+			];
 
 			return true;
 		}
@@ -188,7 +192,7 @@
 		*
 		*/
 		private function getFunctionCaller(){
-			return array( '\\manager\\repo\\'.$this->path['repo'], $this->path['method'] );
+			return [ '\\manager\\repo\\'.$this->path['repo'], $this->path['method'] ];
 		}
 
 

manager/module/token.php

@@ -2,6 +2,7 @@
 
 	namespace manager\module;
 	use \manager\Database;
+	use \manager\Checker;
 	use \manager\sessionManager;
 	use \manager\ManagerError;
 	use \manager\Repo;
@@ -52,7 +53,7 @@
 
 			/* [0] Verification des INPUT
 			=========================================================*/
-			if( !Database::check('varchar(3,50)', $name) || !Database::check('id', $duration) )
+			if( !Checker::run('varchar(3,50)', $name) || !Checker::run('id', $duration) )
 				return array('ModuleError' => ManagerError::ParamError); // erreur de parametre
 
 

manager/repo/category.php

@@ -2,6 +2,7 @@
 
 	namespace manager\repo;
 	use \manager\Database;
+	use \manager\Checker;
 	use \manager\sessionManager;
 
 	class category extends parentRepo{
@@ -20,7 +21,7 @@
 			/* [0] Vérification des INPUT
 			=========================================================*/
 			// Si erreur de type de paramètre, on retourne FALSE
-			if( !Database::check('varchar(0,40)', $intitule) )
+			if( !Checker::run('varchar(0,40)', $intitule) )
 				return false;
 
 			/* [1] Vérification qu'aucune n'a cet intitulé

manager/repo/relation.php

@@ -2,6 +2,7 @@
 
 	namespace manager\repo;
 	use \manager\Database;
+	use \manager\Checker;
 	use \manager\sessionManager;
 
 	class relation extends parentRepo{
@@ -21,9 +22,9 @@
 		public static function create($A, $B, $category){
 			/* [0] Vérification des INPUT
 			=========================================================*/
-			$checkInput = Database::check('id', $A);
+			$checkInput = Checker::run('id', $A);
-			$checkInput = $checkInput && Database::check('id', $B);
+			$checkInput = $checkInput && Checker::run('id', $B);
-			$checkInput = $checkInput && Database::check('id', $category);
+			$checkInput = $checkInput && Checker::run('id', $category);
 
 			// Si erreur de type de paramètre, on retourne FALSE
 			if( !$checkInput )

manager/repo/subject.php

@@ -2,6 +2,7 @@
 
 	namespace manager\repo;
 	use \manager\Database;
+	use \manager\Checker;
 	use \manager\sessionManager;
 	use \manager\Repo;
 
@@ -90,12 +91,12 @@
 		public static function create($username, $firstname, $lastname, $id_facebook, $number){
 			/* [0] Verification et formattage des INPUT
 			=========================================================*/
-			$checkInput =                Database::check('varchar(0,30)', $username);
+			$checkInput =                Checker::run('varchar(0,30)', $username);
-			$checkInput = $checkInput && Database::check('varchar(0,30)', $firstname);
+			$checkInput = $checkInput && Checker::run('varchar(0,30)', $firstname);
-			$checkInput = $checkInput && Database::check('varchar(0,30)', $lastname);
+			$checkInput = $checkInput && Checker::run('varchar(0,30)', $lastname);
 			$checkInput = $checkInput && !!strlen($username.$firstname.$lastname);     // Pseudo, prénom, ou nom, au moins un n'est pas vide
-			$checkInput = $checkInput && ( Database::check('id', $id_facebook) || is_null($id_facebook) );
+			$checkInput = $checkInput && ( Checker::run('id', $id_facebook) || is_null($id_facebook) );
-			$checkInput = $checkInput && ( Database::check('number', $number)  || is_null($number)      );
+			$checkInput = $checkInput && ( Checker::run('number', $number)  || is_null($number)      );
 
 			// Si erreur en entree, on retourne FAUX
 			if( !$checkInput ) return false;
@@ -165,7 +166,7 @@
 		public static function remove($id_subject){
 			/* [0] Vérification des INPUT
 			=========================================================*/
-			if( !Database::check('id', $id_subject) )
+			if( !Checker::run('id', $id_subject) )
 				return false;
 
 			/* [1] On effectue la suppression
@@ -191,9 +192,9 @@
 		public static function link($A, $B, $category){
 			/* [0] Vérification des INPUT
 			=========================================================*/
-			$checkInput = Database::check('id', $A);
+			$checkInput = Checker::run('id', $A);
-			$checkInput = $checkInput && Database::check('id', $B);
+			$checkInput = $checkInput && Checker::run('id', $B);
-			$checkInput = $checkInput && Database::check('varchar(0,40)', $category);
+			$checkInput = $checkInput && Checker::run('varchar(0,40)', $category);
 
 			// Si erreur de type de paramètre, on retourne FALSE
 			if( !$checkInput )

manager/repo/token.php

@@ -5,6 +5,7 @@
 	namespace manager\repo;
 	use \manager\sessionManager;
 	use \manager\Database;
+	use \manager\Checker;
 
 	class token extends parentRepo{
 
@@ -60,7 +61,7 @@
 			/* [0] Verification des INPUT
 			=========================================================*/
 			// si le format est incorrect, on retourne FAUX
-			if( !Database::check('sha1', $token) ) return false;
+			if( !Checker::run('sha1', $token) ) return false;
 
 
 			/* [1] Verification dans la base de donnees
@@ -97,7 +98,7 @@
 		public static function generate($name, $duration){
 			/* [0] Verification des INPUT
 			=========================================================*/
-			if( !Database::check('varchar(3,50)', $name) || !Database::check('id', $duration) ) return false;
+			if( !Checker::run('varchar(3,50)', $name) || !Checker::run('id', $duration) ) return false;
 
 
 			// On definit la date d'expiration du token
@@ -164,7 +165,7 @@
 		public static function remove($id_token){
 			/* [0] Verification des INPUT
 			=========================================================*/
-			if( !Database::check('id', $id_token) ) return false;
+			if( !Checker::run('id', $id_token) ) return false;
 
 
 			/* [1] On verifie l'existance du token

manager/repo/user.php

@@ -2,6 +2,7 @@
 
 	namespace manager\repo;
 	use \manager\Database;
+	use \manager\Checker;
 	use \manager\sessionManager;
 	use \manager\repo\parentRepo;
 
@@ -22,8 +23,8 @@
 		public static function login($login, $password){
 			/* [0] Gestion des INPUT
 			=========================================================*/
-			$checker = Database::check('varchar(3,50)', $login);
+			$checker = Checker::run('varchar(3,50)', $login);
-			$checker = $checker && Database::check('text', $password);
+			$checker = $checker && Checker::run('text', $password);
 
 			// Si les parametres sont incorrects, on retourne une erreur
 			if( !$checker ) return false;
@@ -70,10 +71,10 @@
 		public static function create($login, $password, $mail, $reference, $permission){
 			/* [0] Verification et formattage des INPUT
 			=========================================================*/
-			$checkInput = Database::check('sha1', $password);
+			$checkInput = Checker::run('sha1', $password);
-			$checkInput = $checkInput && Database::check('varchar(3, 30)', $login);
+			$checkInput = $checkInput && Checker::run('varchar(3, 30)', $login);
-			$checkInput = $checkInput && Database::check('mail', $mail);
+			$checkInput = $checkInput && Checker::run('mail', $mail);
-			$checkInput = $checkInput && ( Database::check('id', $reference) || is_null($reference) );
+			$checkInput = $checkInput && ( Checker::run('id', $reference) || is_null($reference) );
 			$checkInput = $checkInput && in_array($permission, array('admin', 'subject'));
 
 			// Si erreur en entree, on retourne FAUX

phpunit/tests/Database_check.php

@@ -7,34 +7,34 @@
 		=========================================================*/
 		/* (1) Taille inferieure correcte */
 		public function testIdSizeInfCorrect(){
-			$this->assertTrue( \manager\Database::check('id', 0) );
+			$this->assertTrue( \manager\Checker::run('id', 0) );
 		}
 		public function testIdSizeInfStringCorrect(){
-			$this->assertTrue( \manager\Database::check('id', '0') );
+			$this->assertTrue( \manager\Checker::run('id', '0') );
 		}
 
 		/* (2) Taille inferieure depassement */
 		public function testIdSizeInfIncorrect(){
-			$this->assertFalse( \manager\Database::check('id', -1) );
+			$this->assertFalse( \manager\Checker::run('id', -1) );
 		}
 		public function testIdSizeInfStringIncorrect(){
-			$this->assertFalse( \manager\Database::check('id', '-1') );
+			$this->assertFalse( \manager\Checker::run('id', '-1') );
 		}
 
 		/* (3) Taille superieure correcte */
 		public function testIdSizeSupCorrect(){
-			$this->assertTrue( \manager\Database::check('id', 2147483647) );
+			$this->assertTrue( \manager\Checker::run('id', 2147483647) );
 		}
 		public function testIdSizeSupStringCorrect(){
-			$this->assertTrue( \manager\Database::check('id', '2147483647') );
+			$this->assertTrue( \manager\Checker::run('id', '2147483647') );
 		}
 
 		/* (3) Taille superieure depassement */
 		public function testIdSizeSupIncorrect(){
-			$this->assertFalse( \manager\Database::check('id', 2147483648) );
+			$this->assertFalse( \manager\Checker::run('id', 2147483648) );
 		}
 		public function testIdSizeSupStringIncorrect(){
-			$this->assertFalse( \manager\Database::check('id', '2147483648') );
+			$this->assertFalse( \manager\Checker::run('id', '2147483648') );
 		}
 
 
@@ -42,11 +42,11 @@
 		=========================================================*/
 		/* (1) Type */
 		public function testVarcharTypeCorrect(){
-			$this->assertTrue( \manager\Database::check('varchar(0,10)', 'string') );
+			$this->assertTrue( \manager\Checker::run('varchar(0,10)', 'string') );
 		}
 		public function testVarcharTypeIncorrect(){
-			$this->assertFalse( \manager\Database::check('varchar(0,10)', 10      ) );
+			$this->assertFalse( \manager\Checker::run('varchar(0,10)', 10      ) );
-			$this->assertFalse( \manager\Database::check('varchar(0,10)', array() ) );
+			$this->assertFalse( \manager\Checker::run('varchar(0,10)', array() ) );
 		}
 
 		/* (2) Borne inferieure */
@@ -54,39 +54,39 @@
 			$min    = rand(1, 50);
 			$string = str_repeat('a', $min-1);
 
-			$this->assertFalse( \manager\Database::check("varchar($min, 255)", $string) );
+			$this->assertFalse( \manager\Checker::run("varchar($min, 255)", $string) );
 		}
 		public function testVarcharEqMin(){
 			$min    = rand(1, 50);
 			$string = str_repeat('a', $min);
 
-			$this->assertTrue( \manager\Database::check("varchar($min, 255)", $string) );
+			$this->assertTrue( \manager\Checker::run("varchar($min, 255)", $string) );
 		}
 		public function testVarcharGtMin(){
 			$min    = rand(1, 50);
 			$string = str_repeat('a', $min+1);
 
-			$this->assertTrue( \manager\Database::check("varchar($min, 255)", $string) );
+			$this->assertTrue( \manager\Checker::run("varchar($min, 255)", $string) );
 		}
 
 		/* (3) Borne superieure */
-		public function testVarcharLtMax(){ 
+		public function testVarcharLtMax(){
 			$max    = rand(1, 255);
 			$string = str_repeat('a', $max-1);
 
-			$this->assertTrue( \manager\Database::check("varchar(0, $max)", $string) );
+			$this->assertTrue( \manager\Checker::run("varchar(0, $max)", $string) );
 		}
-		public function testVarcharEqMax(){ 
+		public function testVarcharEqMax(){
 			$max    = rand(1, 255);
 			$string = str_repeat('a', $max);
 
-			$this->assertTrue( \manager\Database::check("varchar(0, $max)", $string) );
+			$this->assertTrue( \manager\Checker::run("varchar(0, $max)", $string) );
 		}
-		public function testVarcharGtMax(){ 
+		public function testVarcharGtMax(){
 			$max    = rand(1, 255);
 			$string = str_repeat('a', $max+1);
 
-			$this->assertFalse( \manager\Database::check("varchar(0, $max)", $string) );
+			$this->assertFalse( \manager\Checker::run("varchar(0, $max)", $string) );
 		}
 
 
@@ -94,34 +94,34 @@
 		=========================================================*/
 		/* (1) Type */
 		public function testArrayTypeCorrect(){
-			$this->assertTrue( \manager\Database::check('array<text>', array()   ) );
+			$this->assertTrue( \manager\Checker::run('array<text>', array()   ) );
 		}
 		public function testArrayTypeIncorrect(){
-			$this->assertFalse( \manager\Database::check('array<text>', 10       ) );
+			$this->assertFalse( \manager\Checker::run('array<text>', 10       ) );
-			$this->assertFalse( \manager\Database::check('array<text>', 'string' ) );
+			$this->assertFalse( \manager\Checker::run('array<text>', 'string' ) );
 		}
 
 		/* (2) Tests divers */
 		public function testArrayEmpty(){
 			$arr = array();
 
-			$this->assertTrue( \manager\Database::check("array<text>", $arr) );
+			$this->assertTrue( \manager\Checker::run("array<text>", $arr) );
 		}
 		public function testArrayNotEmpty(){
 			$arr = array('a', 'b');
 
-			$this->assertTrue( \manager\Database::check("array<text>", $arr) );
+			$this->assertTrue( \manager\Checker::run("array<text>", $arr) );
 		}
 
 		public function testArrayAllRight(){
 			$arr = array('a', 'aa', 'a', 'bb');
 
-			$this->assertTrue( \manager\Database::check("array<varchar(1,2)>", $arr) );
+			$this->assertTrue( \manager\Checker::run("array<varchar(1,2)>", $arr) );
 		}
 		public function testArrayOneWrong(){
 			$arr = array('a', 'aa', 'a', 'bb', 'aaa');
 
-			$this->assertFalse( \manager\Database::check("array<varchar(1,2)>", $arr) );
+			$this->assertFalse( \manager\Checker::run("array<varchar(1,2)>", $arr) );
 		}
 
 
@@ -133,7 +133,7 @@
 				array(1, 100)
 			);
 
-			$this->assertFalse( \manager\Database::check("array<array<int>>", $arr) );
+			$this->assertFalse( \manager\Checker::run("array<array<int>>", $arr) );
 		}
 
 
@@ -143,25 +143,25 @@
 		/* (1) Size */
 		public function testMailSizeEqCorrect(){
 			$this->assertLessThanOrEqual( 50, strlen('nom-prenom.mot@domaine-d.gouv') );
-			$this->assertTrue( \manager\Database::check('mail', 'nom-prenom.mot@domaine-d.gouv') );
+			$this->assertTrue( \manager\Checker::run('mail', 'nom-prenom.mot@domaine-d.gouv') );
 		}
 
 		public function testMailSizeSupCorrect(){
 			$this->assertGreaterThan( 50, strlen('ab12345678901234567890nom-prenom.mot@domaine-d.gouv') );
-			$this->assertFalse( \manager\Database::check('mail', 'ab12345678901234567890nom-prenom.mot@domaine-d.gouv') );
+			$this->assertFalse( \manager\Checker::run('mail', 'ab12345678901234567890nom-prenom.mot@domaine-d.gouv') );
 		}
 
 		/* (2) Content */
 		public function testMailContentCorrect(){
-			$this->assertTrue( \manager\Database::check('mail', '0nom-prenom.mot@domaine-d.gouv') );
+			$this->assertTrue( \manager\Checker::run('mail', '0nom-prenom.mot@domaine-d.gouv') );
 		}
 
 		public function testMailContentIncorrect1(){
-			$this->assertFalse( \manager\Database::check('mail', '0nom-prenom.mot@domaine-d.gouve') );			
+			$this->assertFalse( \manager\Checker::run('mail', '0nom-prenom.mot@domaine-d.gouve') );
 		}
 
 		public function testMailContentIncorrect2(){
-			$this->assertFalse( \manager\Database::check('mail', '0nom-prenom.mot@domaine-d.g') );			
+			$this->assertFalse( \manager\Checker::run('mail', '0nom-prenom.mot@domaine-d.g') );
 		}
 
 
@@ -172,35 +172,35 @@
 			$password_hash = \manager\sessionManager::sha1('monmotdepasse');
 
 			$this->assertEquals( 40, strlen($password_hash) );
-			$this->assertTrue( \manager\Database::check('sha1', $password_hash) );
+			$this->assertTrue( \manager\Checker::run('sha1', $password_hash) );
 		}
 
 		public function testPasswordSizeInfIncorrect(){
 			$password_hash = 'a';
-			
+
 			$this->assertLessThan( 40, strlen($password_hash) );
-			$this->assertFalse( \manager\Database::check('sha1', $password_hash) );
+			$this->assertFalse( \manager\Checker::run('sha1', $password_hash) );
 		}
 
 		public function testPasswordSizeSupIncorrect(){
 			$password_hash = \manager\sessionManager::sha1('monmotdepasse').'a';
-			
+
 			$this->assertGreaterThan( 40, strlen($password_hash) );
-			$this->assertFalse( \manager\Database::check('sha1', $password_hash) );
+			$this->assertFalse( \manager\Checker::run('sha1', $password_hash) );
 		}
 
 
 		public function testPasswordContentCorrect(){
-			$this->assertTrue( \manager\Database::check('sha1', 'dd629d39c4576731a2bef003c72ff89d6fc2a99a') );
+			$this->assertTrue( \manager\Checker::run('sha1', 'dd629d39c4576731a2bef003c72ff89d6fc2a99a') );
 		}
 
 		public function testPasswordContentIncorrect(){
 			$this->assertContains( 'g', 'dd629d39c4576731a2bef003c72ff89d6fc2a9g' );
-			$this->assertFalse( \manager\Database::check('sha1', 'dd629d39c4576731a2bef003c72ff89d6fc2a9g') );			
+			$this->assertFalse( \manager\Checker::run('sha1', 'dd629d39c4576731a2bef003c72ff89d6fc2a9g') );
 		}
 
 
 
 	}
 
-?>
+?>