SMMP/manager/Database.php

<?php

	namespace manager;


	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 = ManagerError::Success;

			}catch(Exception $e){
				// On signale qu'il y a une erreur
				self::$error = ManagerError::PDOConnection;
			}
		}


		/* retourne une instance de la classe */
		public static function getInstance(){
			if( self::$instance == null || self::$error != ManagerError::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);
		}

	}
?>