447 lines
12 KiB
PHP
Executable File
447 lines
12 KiB
PHP
Executable File
<?php
|
|
|
|
namespace database\core;
|
|
use \error\core\Error;
|
|
|
|
|
|
class Database{
|
|
|
|
/* ATTRIBUTS STATIQUES */
|
|
public static function config_path(){
|
|
return [
|
|
'local' => __ROOT__.'/config/database-local.json',
|
|
'remote' => __ROOT__.'/config/database.json'
|
|
];
|
|
}
|
|
|
|
private static $pdo;
|
|
private static $instance;
|
|
|
|
|
|
/* ATTRIBUTS */
|
|
private $host;
|
|
private $dbname;
|
|
private $username;
|
|
private $password;
|
|
|
|
public static $error;
|
|
|
|
|
|
public function __construct($host, $dbname, $username, $password){
|
|
$this->host = $host;
|
|
$this->dbname = $dbname;
|
|
$this->username = $username;
|
|
$this->password = $password;
|
|
|
|
try{
|
|
self::$pdo = new \PDO('mysql:host='.$this->host.';dbname='.$this->dbname, $this->username, $this->password);
|
|
|
|
// On signale que tout s'est bien passe
|
|
self::$error = Error::Success;
|
|
|
|
}catch(Exception $e){
|
|
// On signale qu'il y a une erreur
|
|
self::$error = Error::PDOConnection;
|
|
}
|
|
}
|
|
|
|
|
|
/* retourne une instance de la classe */
|
|
public static function getInstance(){
|
|
if( self::$instance == null || self::$error != Error::Success ){ // Si aucune instance existante OU erreur de connection
|
|
|
|
// chargement de la configuration du server SQL
|
|
if( !checkdnsrr($_SERVER['SERVER_NAME'], 'NS') )
|
|
$conf = json_decode( file_get_contents(self::config_path()['local']), true );
|
|
else
|
|
$conf = json_decode( file_get_contents(self::config_path()['remote']), true );
|
|
|
|
// creation de l'instance en fonction des parametres
|
|
self::$instance = new DataBase($conf['host'], $conf['dbname'], $conf['user'], $conf['password']);
|
|
|
|
}
|
|
|
|
return self::$instance;
|
|
}
|
|
|
|
/* retourne la connection statique */
|
|
public static function getPDO(){
|
|
$instance = self::getInstance();
|
|
|
|
return self::$pdo;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
public function getConfig(){
|
|
return [
|
|
'host' => $this->host,
|
|
'username' => $this->username
|
|
];
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*************************************************************/
|
|
/* _____ ______ _ _ ______ _____ _ */
|
|
/* / ____| ____| \ | | ____| __ \ /\ | | */
|
|
/* | | __| |__ | \| | |__ | |__) | / \ | | */
|
|
/* | | |_ | __| | . ` | __| | _ / / /\ \ | | */
|
|
/* | |__| | |____| |\ | |____| | \ \ / ____ \| |____ */
|
|
/* \_____|______|_| \_|______|_| \_\/_/ \_\______| */
|
|
/* */
|
|
/*************************************************************/
|
|
|
|
/* SUPPRIME LES VALEURS À CLÉS NUMÉRIQUES DANS UN FETCH D'UNE TABLE DE LA BDD
|
|
*
|
|
* @fetchData<Array> le résultat d'une $requeteSQL->fetchAll()
|
|
* @oneDimension<Boolean> FAUX <=> fetchAll ; VRAI <=> fetch
|
|
*
|
|
* @return newFetchData<Array> retourne le tableau donné en paramètre mais sans les valeurs à clés numériques
|
|
*
|
|
*/
|
|
public static function delNumeric($fetchData, $oneDimension=false){
|
|
// On quitte si ce n'est pas un tableau
|
|
if( !is_array($fetchData) )
|
|
return [];
|
|
|
|
$nextEquivalent = false; // Vaut VRAI si le prochain est peut-etre un equivalent numerique
|
|
|
|
/* [1] 2 dimensions
|
|
===============================================*/
|
|
if( !$oneDimension && isset($fetchData[0]) && is_array($fetchData[0]) ){
|
|
|
|
// on supprime les doublons des entrées (indice numérique)
|
|
for( $i = 0 ; $i < count($fetchData) ; $i++ ) // pour toutes les lignes
|
|
foreach($fetchData[$i] as $col => $val){ // pour toutes les entrées
|
|
|
|
if( !\mb_detect_encoding($val, 'UTF-8') )
|
|
$fetchData[$i][$col] = utf8_encode($val);
|
|
|
|
if( is_int($col) ){ // Si indice numerique
|
|
if( $nextEquivalent ) // Si suit un indice textuel
|
|
unset( $fetchData[$i][$col] ); // on supprime l'indice
|
|
|
|
$nextEquivalent = false; // Dans tous les cas, on dit que le prochain ne pourra pas etre supprime si numerique
|
|
|
|
}else // Si l'indice n'est pas un entier
|
|
$nextEquivalent = true; // On signale qu'il y aura peut etre un indice numerique suivant
|
|
|
|
}
|
|
|
|
/* [2] 1 dimensions
|
|
===============================================*/
|
|
}else{
|
|
|
|
// on supprime les doublons des entrées (indice numérique)
|
|
foreach($fetchData as $i=>$val){ // pour toutes les entrées
|
|
|
|
if( !\mb_detect_encoding($val, 'UTF-8') )
|
|
$fetchData[$i] = utf8_encode($val);
|
|
|
|
if( is_int($i) ){ // Si indice numerique
|
|
if( $nextEquivalent ) // Si suit un indice textuel
|
|
unset( $fetchData[$i] ); // on supprime l'indice
|
|
|
|
$nextEquivalent = false; // Dans tous les cas, on dit que le prochain ne pourra pas etre supprime si numerique
|
|
|
|
}else // Si l'indice n'est pas un entier
|
|
$nextEquivalent = true; // On signale qu'il y aura peut etre un indice numerique suivant
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return $fetchData;
|
|
}
|
|
|
|
|
|
|
|
|
|
/* GESTION DE L'AUTO-TYPAGE D'UN TABLEAU A UN/PLUSIEURS NIVEAU(X) OU D'UNE VALEUR
|
|
*
|
|
* @data<mixed> Tableau de données/Valeur
|
|
*
|
|
* @return autoTyped<Array> Tableau/Valeur auto-typé(e)
|
|
*
|
|
*/
|
|
public static function autotype($data){
|
|
$autotyped = $data;
|
|
|
|
/* [0] Gestion des types simples
|
|
=========================================================*/
|
|
if( !is_array($autotyped) ){
|
|
|
|
/* (1) Si Numérique Entier -> INT */
|
|
if( preg_match('/^(0|([1-9][0-9]*))$/i', $autotyped) )
|
|
return intval($autotyped);
|
|
|
|
/* (2) Si Numérique Décimal -> FLOAT */
|
|
else if( preg_match('/^(0|(?:[1-9][0-9]*))[\.\,]([0-9]+)$/i', $autotyped, $m) )
|
|
return floatval("${m[1]}.${m[2]}");
|
|
|
|
/* (3) Sinon on retourne la même chose */
|
|
else
|
|
return $autotyped;
|
|
|
|
/* [1] Gestion des types composés
|
|
=========================================================*/
|
|
}else{
|
|
|
|
/* (1) Pour chaque valeur, on applique récursivement */
|
|
foreach($autotyped as $k=>$v){
|
|
|
|
// Si on met '_nomColonne', on ne le traite pas
|
|
if( is_string($k) && $k[0] == '_' ) continue;
|
|
|
|
$autotyped[$k] = self::autotype($v);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
/* [2] On retourne le résultat auto-typé
|
|
=========================================================*/
|
|
return $autotyped;
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////
|
|
// _ __ _ _ _
|
|
// __ _____ _ __(_)/ _(_) ___ __ _| |_(_) ___ _ __ ___
|
|
// \ \ / / _ \ '__| | |_| |/ __/ _` | __| |/ _ \| '_ \/ __|
|
|
// \ 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, 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::check($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::check($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]{40}$/i', $value);
|
|
break;
|
|
|
|
case 'alphanumeric':
|
|
case 'user.username':
|
|
case 'group.name':
|
|
return $checker && is_string($value) && preg_match('/^[\w-]+$/i', $value);
|
|
break;
|
|
|
|
case 'user.firstname':
|
|
case 'user.lastname':
|
|
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;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* FONCTION QUI FORMATTE UN NUMÉRO DE TÉLÉPHONE
|
|
*
|
|
* @number<String> Numéro de téléphone en +336/336/06/0336/00336
|
|
*
|
|
* @return formatted<String> Numéro formatté (06), on FALSE si erreur
|
|
*
|
|
*/
|
|
public static function formatNumber($number){
|
|
// On met en <string> quel que soit le type
|
|
$number = (string) $number;
|
|
|
|
// On supprime tous les espaces
|
|
$number = str_replace(' ', '', $number);
|
|
|
|
// On formatte le numéro
|
|
if( preg_match("/^(?:\+33|0?0?33|0)(.+)/", $number, $m) )
|
|
$number = '0'.$m[1];
|
|
|
|
// On retourne le numéro formatté
|
|
return $number;
|
|
}
|
|
|
|
|
|
public static function readableNumber($number){
|
|
/* (1) On formatte le numéro si c'est pas fait */
|
|
$formatted = self::formatNumber($number);
|
|
|
|
for( $i = 1 ; $i < strlen($formatted) ; $i++ )
|
|
if( ($i-2) % 3 == 0 )
|
|
$formatted = substr($formatted, 0, $i).' '.substr($formatted, $i);
|
|
|
|
return $formatted;
|
|
}
|
|
|
|
|
|
////////////////////////////////////
|
|
// _ _
|
|
// __| | __ _| |_ ___ ___
|
|
// / _` |/ _` | __/ _ \/ __|
|
|
// | (_| | (_| | || __/\__ \
|
|
// \__,_|\__,_|\__\___||___/
|
|
//
|
|
////////////////////////////////////
|
|
// 1) Convertis une date en en francais explicite
|
|
public static function frDate($date){
|
|
/* [1] On definit les traductions
|
|
=========================================================*/
|
|
// Jours de la semaine
|
|
$days = ["Lundi", "Mardi", "Mercredi", "Jeudi", "Vendredi", "Samedi", "Dimanche"];
|
|
// Mois de l'annee
|
|
$months = ["Janvier", "Février", "Mars", "Avril", "Mai", "Juin", "Juillet", "Août", "Septembre", "Octobre", "Novembre", "Décembre"];
|
|
|
|
/* [2] On recupere le timestamp et les indices
|
|
=========================================================*/
|
|
$time = strtotime($date); // timestamp
|
|
$daynum = intval( date('N', $time)-1 ); // jour dans la semaine
|
|
$monthnum = intval( date('n', $time)-1 ); // numero du mois dans l'annee
|
|
|
|
|
|
/* [3] On recupere les infos independemment
|
|
=========================================================*/
|
|
$result = [
|
|
$days[$daynum], // nom de jour
|
|
date('j', $time), // jour du mois
|
|
$months[$monthnum], // nom du mois
|
|
date('Y', $time), // annee
|
|
];
|
|
|
|
|
|
return implode(" ", $result);
|
|
}
|
|
|
|
}
|
|
?>
|