Intégration du 'Checker' + Quelques manager
This commit is contained in:
xdrm-brackets
parent
bc7bc68c7d
commit
acc2d9767e
|
|
@ -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['password']) && Database::check('text', $_POST['password']);
|
||||
$login_vars = $login_vars && isset($_POST['login']) && Checker::run('varchar(3,50)', $_POST['login']);
|
||||
$login_vars = $login_vars && isset($_POST['password']) && Checker::run('text', $_POST['password']);
|
||||
|
||||
// Status de login
|
||||
$_SESSION['login_status'] = 'no';
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
?>
|
||||
|
|
@ -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
|
||||
*
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
||||
}
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load Diff
|
|
@ -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;
|
||||
}
|
||||
|
||||
|
||||
|
||||
}
|
||||
|
||||
|
||||
?>
|
||||
|
|
@ -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');
|
||||
|
|
@ -6,8 +6,8 @@
|
|||
// FORMAT:
|
||||
//
|
||||
// path: "nomModule/nomMethode"
|
||||
// data1: {donnee1}
|
||||
// data2: {donnee2}
|
||||
// params1: {donnee1}
|
||||
// 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)
|
||||
$data = (is_array($data)) ? $data : array();
|
||||
// Type de @params (optionnel)
|
||||
$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'] ];
|
||||
}
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -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é
|
||||
|
|
|
|||
|
|
@ -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 = $checkInput && Database::check('id', $B);
|
||||
$checkInput = $checkInput && Database::check('id', $category);
|
||||
$checkInput = Checker::run('id', $A);
|
||||
$checkInput = $checkInput && Checker::run('id', $B);
|
||||
$checkInput = $checkInput && Checker::run('id', $category);
|
||||
|
||||
// Si erreur de type de paramètre, on retourne FALSE
|
||||
if( !$checkInput )
|
||||
|
|
|
|||
|
|
@ -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 = $checkInput && Database::check('varchar(0,30)', $firstname);
|
||||
$checkInput = $checkInput && Database::check('varchar(0,30)', $lastname);
|
||||
$checkInput = Checker::run('varchar(0,30)', $username);
|
||||
$checkInput = $checkInput && Checker::run('varchar(0,30)', $firstname);
|
||||
$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 && ( Database::check('number', $number) || is_null($number) );
|
||||
$checkInput = $checkInput && ( Checker::run('id', $id_facebook) || is_null($id_facebook) );
|
||||
$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 = $checkInput && Database::check('id', $B);
|
||||
$checkInput = $checkInput && Database::check('varchar(0,40)', $category);
|
||||
$checkInput = Checker::run('id', $A);
|
||||
$checkInput = $checkInput && Checker::run('id', $B);
|
||||
$checkInput = $checkInput && Checker::run('varchar(0,40)', $category);
|
||||
|
||||
// Si erreur de type de paramètre, on retourne FALSE
|
||||
if( !$checkInput )
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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 && Database::check('text', $password);
|
||||
$checker = Checker::run('varchar(3,50)', $login);
|
||||
$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 = $checkInput && Database::check('varchar(3, 30)', $login);
|
||||
$checkInput = $checkInput && Database::check('mail', $mail);
|
||||
$checkInput = $checkInput && ( Database::check('id', $reference) || is_null($reference) );
|
||||
$checkInput = Checker::run('sha1', $password);
|
||||
$checkInput = $checkInput && Checker::run('varchar(3, 30)', $login);
|
||||
$checkInput = $checkInput && Checker::run('mail', $mail);
|
||||
$checkInput = $checkInput && ( Checker::run('id', $reference) || is_null($reference) );
|
||||
$checkInput = $checkInput && in_array($permission, array('admin', 'subject'));
|
||||
|
||||
// Si erreur en entree, on retourne FAUX
|
||||
|
|
|
|||
|
|
@ -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\Database::check('varchar(0,10)', array() ) );
|
||||
$this->assertFalse( \manager\Checker::run('varchar(0,10)', 10 ) );
|
||||
$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\Database::check('array<text>', 'string' ) );
|
||||
$this->assertFalse( \manager\Checker::run('array<text>', 10 ) );
|
||||
$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') );
|
||||
}
|
||||
|
||||
|
||||
|
||||
}
|
||||
|
||||
?>
|
||||
?>
|
||||
|
|
|
|||
Loading…
Reference in New Issue