| New file |
|---|
| 0,0 → 1,431 |
|---|
| <?php |
| abstract class WidgetCommun { |
| |
| protected $config = null; |
| protected $parametres = null; |
| protected $messages = array(); |
| protected $debug = array(); |
| |
| public function __construct($config, $parametres) { |
| $this->config = $config; |
| $this->parserFichierIni($config['chemins']['widgetCourantDossier'].'config.ini'); |
| $this->parametres = $parametres; |
| } |
| |
| /** |
| * Parse le fichier ini donné en paramètre |
| * @param string $fichier_ini nom du fichier ini à parser |
| * @return boolean true si le fichier ini a été trouvé. |
| */ |
| private function parserFichierIni($fichier_ini) { |
| $retour = false; |
| if (file_exists($fichier_ini)) { |
| $ini = parse_ini_file($fichier_ini, true); |
| $this->fusionner($ini); |
| $retour = true; |
| } |
| return $retour; |
| } |
| |
| /** |
| * fusionne un tableau de paramètres avec le tableau de config global |
| * @param array $ini le tableau à fusionner |
| */ |
| private function fusionner(array $ini) { |
| $this->config = array_merge($this->config, $ini); |
| } |
| |
| protected function traiterNomMethodeExecuter($nom) { |
| $methode = 'executer'; |
| $methode .= str_replace(' ', '', ucwords(str_replace('-', ' ', strtolower($nom)))); |
| return $methode; |
| } |
| |
| //+----------------------------------------------------------------------------------------------------------------+ |
| // GESTION des CLASSES CHARGÉES à la DEMANDE |
| |
| protected function getDao() { |
| if (! isset($this->dao)) { |
| $this->dao = new Dao(); |
| } |
| return $this->dao; |
| } |
| |
| //+----------------------------------------------------------------------------------------------------------------+ |
| // GESTION DE MÉTHODES COMMUNES ENTRE LES SERVICES |
| |
| protected function getUrlImage($id, $format = 'L') { |
| $url_tpl = $this->config['chemins']['celImgUrlTpl']; |
| $id = sprintf('%09s', $id).$format; |
| $url = sprintf($url_tpl, $id); |
| return $url; |
| } |
| |
| protected function encoderMotCle($mot_cle) { |
| return md5(mb_strtolower($mot_cle)); |
| } |
| |
| private function protegerMotsCles($mots_cles, $type) { |
| $separateur = ($type == self::TYPE_IMG) ? ',' : ';' ; |
| $mots_cles_a_proteger = explode($separateur,rtrim(trim($mots_cles), $separateur)); |
| foreach ($mots_cles_a_proteger as $mot) { |
| $mots_cles_proteges[] = $this->bdd->quote($mot); |
| } |
| $mots_cles = implode(',', $mots_cles_proteges); |
| return $mots_cles; |
| } |
| |
| protected function tronquerCourriel($courriel) { |
| $courriel = preg_replace('/[^@]+$/i', '...', $courriel); |
| return $courriel; |
| } |
| |
| protected function nettoyerTableau($tableau) { |
| foreach ($tableau as $cle => $valeur) { |
| if (is_array($valeur)) { |
| $valeur = $this->nettoyerTableau($valeur); |
| } else { |
| $valeur = $this->nettoyerTexte($valeur); |
| } |
| $tableau[$cle] = $valeur; |
| } |
| return $tableau; |
| } |
| |
| protected function nettoyerTexte($txt) { |
| $txt = preg_replace('/&(?!([a-z]+|#[0-9]+|#x[0-9][a-f]+);)/i', '&', $txt); |
| $txt = preg_replace('/^(?:000null|null)$/i', '', $txt); |
| return $txt; |
| } |
| |
| protected function etreVide($valeur) { |
| $vide = false; |
| if ($valeur == '' || $valeur == 'null'|| $valeur == '000null' || $valeur == '0') { |
| $vide = true; |
| } |
| return $vide; |
| } |
| |
| protected function formaterDate($date_heure_mysql, $format = '%A %d %B %Y à %H:%M') { |
| $date_formatee = ''; |
| if (!$this->etreVide($date_heure_mysql)) { |
| $timestamp = $this->convertirDateHeureMysqlEnTimestamp($date_heure_mysql); |
| $date_formatee = strftime($format, $timestamp); |
| } |
| return $date_formatee; |
| } |
| |
| protected function convertirDateHeureMysqlEnTimestamp($date_heure_mysql){ |
| $val = explode(' ', $date_heure_mysql); |
| $date = explode('-', $val[0]); |
| $heure = explode(':', $val[1]); |
| return mktime((int) $heure[0], (int) $heure[1], (int) $heure[2], (int) $date[1], (int) $date[2], (int) $date[0]); |
| } |
| |
| //+----------------------------------------------------------------------------------------------------------------+ |
| // GESTION DE L'IDENTIFICATION et des UTILISATEURS |
| |
| protected function getAuthIdentifiant() { |
| $id = (isset($_SERVER['PHP_AUTH_USER'])) ? $_SERVER['PHP_AUTH_USER'] : null; |
| return $id; |
| } |
| |
| protected function getAuthMotDePasse() { |
| $mdp = (isset($_SERVER['PHP_AUTH_PW'])) ? $_SERVER['PHP_AUTH_PW'] : null; |
| return $mdp; |
| } |
| |
| protected function authentifierAdmin() { |
| $message_accueil = "Veuillez vous identifier avec votre compte Tela Botanica."; |
| $message_echec = "Accès limité aux administrateurs du CEL.\n". |
| "Votre tentative d'identification a échoué.\n". |
| "Actualiser la page pour essayer à nouveau si vous êtes bien inscrit comme administrateur."; |
| return $this->authentifier($message_accueil, $message_echec, 'Admin'); |
| } |
| |
| protected function authentifierUtilisateur() { |
| $message_accueil = "Veuillez vous identifier avec votre compte Tela Botanica."; |
| $message_echec = "Accès limité aux utilisateur du CEL.\n". |
| "Inscrivez vous http://www.tela-botanica.org/page:inscription pour le devenir.\n". |
| "Votre tentative d'identification a échoué.\n". |
| "Actualiser la page pour essayer à nouveau si vous êtes déjà inscrit ou contacter 'accueil@tela-botanica.org'."; |
| return $this->authentifier($message_accueil, $message_echec, 'Utilisateur'); |
| } |
| |
| private function authentifier($message_accueil, $message_echec, $type) { |
| $id = $this->getAuthIdentifiant(); |
| if (!isset($id)) { |
| $this->envoyerAuth($message_accueil, $message_echec); |
| } else { |
| if ($type == 'Utilisateur' && $this->getAuthMotDePasse() == 'debug') { |
| $autorisation = true; |
| } else { |
| $methodeAutorisation = "etre{$type}Autorise"; |
| $autorisation = $this->$methodeAutorisation(); |
| } |
| if ($autorisation == false) { |
| $this->envoyerAuth($message_accueil, $message_echec); |
| } |
| } |
| return true; |
| } |
| |
| protected function etreUtilisateurAutorise() { |
| $identifiant = $this->getAuthIdentifiant(); |
| $mdp = md5($this->getAuthMotDePasse()); |
| $url = sprintf($this->config['authentification']['serviceUrlTpl'], $identifiant, $mdp); |
| $json = $this->getDao()->consulter($url); |
| $existe = json_decode($json); |
| |
| $autorisation = (isset($existe) && $existe) ? true :false; |
| return $autorisation; |
| } |
| |
| protected function etreAdminAutorise($identifiant) { |
| $identifiant = $this->getAuthIdentifiant(); |
| $autorisation = ($this->etreUtilisateurAutorise() && $this->etreAdminCel($identifiant)) ? true : false; |
| return $autorisation; |
| } |
| |
| protected function etreAdminCel($courriel) { |
| $admins = $this->config['authentification']['administrateurs']; |
| $courriels_autorises = explode(',', $admins); |
| |
| $autorisation = (in_array($courriel, $courriels_autorises)) ? true : false ; |
| return $autorisation; |
| } |
| |
| /** |
| * Prend en paramêtre un tableau de courriels et retourne après avoir intérogé un service we de l'annuaire |
| * une tableau avec en clé le courriel et en valeur, un tableau associatif : |
| * - nom : le nom de l'utilisateur |
| * - prenom : le prénom de l'utilisateur. |
| * @param array $courriels un tableau de courriels pour lesquels il faut recherche le prénom et nom. |
| */ |
| protected function recupererUtilisateursNomPrenom(Array $courriels) { |
| // Récupération des données au format Json |
| $service = "utilisateur/prenom-nom-par-courriel/".implode(',', $courriels); |
| $url = sprintf($this->config['chemins']['baseURLServicesAnnuaireTpl'], $service); |
| $json = $this->getDao()->consulter($url); |
| return (array) json_decode($json); |
| } |
| |
| protected function recupererUtilisateursIdentite(Array $courriels) { |
| // Récupération des données au format Json |
| $service = "utilisateur/identite-par-courriel/".implode(',', $courriels); |
| $url = sprintf($this->config['chemins']['baseURLServicesAnnuaireTpl'], $service); |
| $json = $this->getDao()->consulter($url); |
| $utilisateurs = json_decode($json); |
| foreach ($courriels as $courriel) { |
| $info = array('id' => null, 'intitule' => ''); |
| if (isset($utilisateurs->$courriel)) { |
| $info['intitule'] = $utilisateurs->$courriel->intitule; |
| $info['id'] = $utilisateurs->$courriel->id; |
| } else { |
| $info['intitule'] = $this->tronquerCourriel($courriel); |
| } |
| $noms[$courriel] = $info; |
| } |
| return $noms; |
| } |
| |
| //+----------------------------------------------------------------------------------------------------------------+ |
| // GESTION de l'ENVOIE au NAVIGATEUR |
| |
| protected function envoyerJsonp($donnees = null, $encodage = 'utf-8') { |
| $contenu = $_GET['callback'].'('.json_encode($donnees).');'; |
| $this->envoyer($contenu, 'text/html', $encodage); |
| } |
| |
| protected function envoyer($donnees = null, $mime = 'text/html', $encodage = 'utf-8') { |
| // Traitements des messages d'erreurs et données |
| if (count($this->messages) != 0) { |
| header('HTTP/1.1 500 Internal Server Error'); |
| $mime = 'text/html'; |
| $encodage = 'utf-8'; |
| $sortie = '<html>'. |
| '<head><title>Messages</title></head>'. |
| '<body><pre>'.implode("\n", $this->messages).'</pre><body>'. |
| '</html>'; |
| } else { |
| $sortie = $donnees; |
| if (is_null($donnees)) { |
| $sortie = 'OK'; |
| } |
| } |
| |
| // Gestion de l'envoie du déboguage |
| $this->envoyerDebogage(); |
| |
| // Envoie sur la sortie standard |
| $this->envoyerContenu($encodage, $mime, $sortie); |
| } |
| |
| private function envoyerDebogage() { |
| if (!is_array($this->debug)) { |
| $this->debug[] = $this->debug; |
| } |
| if (count($this->debug) != 0) { |
| foreach ($this->debug as $cle => $val) { |
| if (is_array($val)) { |
| $this->debug[$cle] = print_r($val, true); |
| } |
| } |
| header('X-DebugJrest-Data:'.json_encode($this->debug)); |
| } |
| } |
| |
| private function envoyerContenu($encodage, $mime, $contenu) { |
| if (!is_null($mime) && !is_null($encodage)) { |
| header("Content-Type: $mime; charset=$encodage"); |
| } else if (!is_null($mime) && is_null($encodage)) { |
| header("Content-Type: $mime"); |
| } |
| print_r($contenu); |
| } |
| |
| private function envoyerAuth($message_accueil, $message_echec) { |
| header('HTTP/1.0 401 Unauthorized'); |
| header('WWW-Authenticate: Basic realm="'.mb_convert_encoding($message_accueil, 'ISO-8859-1', 'UTF-8').'"'); |
| header('Content-type: text/plain; charset=UTF-8'); |
| print $message_echec; |
| exit(0); |
| } |
| |
| //+----------------------------------------------------------------------------------------------------------------+ |
| // GESTION DES SQUELETTES (PHP, TXT...) |
| |
| /** |
| * Méthode prenant en paramètre un tableau associatif, les clés seront recherchées dans le texte pour être |
| * remplacer par la valeur. Dans le texte, les clés devront être entre accolades : {} |
| * |
| * @param String $txt le texte où chercher les motifs. |
| * @param Array $donnees un tableau associatif contenant les motifs à remplacer. |
| * |
| * @return String le texte avec les motifs remplacer par les valeurs du tableau. |
| */ |
| protected static function traiterSqueletteTxt($txt, Array $donnees = array()) { |
| $motifs = array(); |
| $valeurs = array(); |
| foreach ($donnees as $cle => $valeur) { |
| if (strpos($cle, '{') === false && strpos($cle, '}') === false) { |
| $motifs = '{'.$cle.'}'; |
| $valeurs = $valeur; |
| } |
| } |
| $txt = str_replace($motifs, $valeurs, $txt); |
| return $txt; |
| } |
| |
| /** |
| * Méthode prenant en paramètre un chemin de fichier squelette et un tableau associatif de données, |
| * en extrait les variables, charge le squelette et retourne le résultat des deux combinés. |
| * |
| * @param String $fichier le chemin du fichier du squelette |
| * @param Array $donnees un tableau associatif contenant les variables a injecter dans le squelette. |
| * |
| * @return boolean false si le squelette n'existe pas, sinon la chaine résultat. |
| */ |
| protected static function traiterSquelettePhp($fichier, Array $donnees = array()) { |
| $sortie = false; |
| if (file_exists($fichier)) { |
| // Extraction des variables du tableau de données |
| extract($donnees); |
| // Démarage de la bufferisation de sortie |
| ob_start(); |
| // Si les tags courts sont activés |
| if ((bool) @ini_get('short_open_tag') === true) { |
| // Simple inclusion du squelette |
| include $fichier; |
| } else { |
| // Sinon, remplacement des tags courts par la syntaxe classique avec echo |
| $html_et_code_php = self::traiterTagsCourts($fichier); |
| // Pour évaluer du php mélangé dans du html il est nécessaire de fermer la balise php ouverte par eval |
| $html_et_code_php = '?>'.$html_et_code_php; |
| // Interprétation du html et du php dans le buffer |
| echo eval($html_et_code_php); |
| } |
| // Récupèration du contenu du buffer |
| $sortie = ob_get_contents(); |
| // Suppression du buffer |
| @ob_end_clean(); |
| } else { |
| $msg = "Le fichier du squelette '$fichier' n'existe pas."; |
| trigger_error($msg, E_USER_WARNING); |
| } |
| // Retourne le contenu |
| return $sortie; |
| } |
| |
| /** |
| * Fonction chargeant le contenu du squelette et remplaçant les tags court php (<?= ...) par un tag long avec echo. |
| * |
| * @param String $chemin_squelette le chemin du fichier du squelette |
| * |
| * @return string le contenu du fichier du squelette php avec les tags courts remplacés. |
| */ |
| private static function traiterTagsCourts($chemin_squelette) { |
| $contenu = file_get_contents($chemin_squelette); |
| // Remplacement de tags courts par un tag long avec echo |
| $contenu = str_replace('<?=', '<?php echo ', $contenu); |
| // Ajout systématique d'un point virgule avant la fermeture php |
| $contenu = preg_replace("/;*\s*\?>/", "; ?>", $contenu); |
| return $contenu; |
| } |
| |
| //+----------------------------------------------------------------------------------------------------------------+ |
| // UTILITAIRES |
| |
| /** |
| * Permet de trier un tableau multi-dimenssionnel en gardant l'ordre des clés. |
| * |
| * @param Array $array le tableau à trier |
| * @param Array $cols tableau indiquant en clé la colonne à trier et en valeur l'ordre avec SORT_ASC ou SORT_DESC |
| * @author cagret at gmail dot com |
| * @see http://fr.php.net/manual/fr/function.array-multisort.php Post du 21-Jun-2009 12:38 |
| */ |
| public static function trierTableauMd($array, $cols) { |
| $colarr = array(); |
| foreach ($cols as $col => $order) { |
| $colarr[$col] = array(); |
| foreach ($array as $k => $row) { |
| $colarr[$col]['_'.$k] = strtolower(self::supprimerAccents($row[$col])); |
| } |
| } |
| $params = array(); |
| foreach ($cols as $col => $order) { |
| $params[] =& $colarr[$col]; |
| $params = array_merge($params, (array)$order); |
| } |
| call_user_func_array('array_multisort', $params); |
| $ret = array(); |
| $keys = array(); |
| $first = true; |
| foreach ($colarr as $col => $arr) { |
| foreach ($arr as $k => $v) { |
| if ($first) { |
| $keys[$k] = substr($k,1); |
| } |
| $k = $keys[$k]; |
| if (!isset($ret[$k])) { |
| $ret[$k] = $array[$k]; |
| } |
| $ret[$k][$col] = $array[$k][$col]; |
| } |
| $first = false; |
| } |
| return $ret; |
| } |
| |
| private static function supprimerAccents($str, $charset='utf-8') |
| { |
| $str = htmlentities($str, ENT_NOQUOTES, $charset); |
| |
| $str = preg_replace('#&([A-za-z])(?:acute|cedil|circ|grave|orn|ring|slash|th|tilde|uml);#', '\1', $str); |
| $str = preg_replace('#&([A-za-z]{2})(?:lig);#', '\1', $str); // pour les ligatures e.g. 'œ' |
| $str = preg_replace('#&[^;]+;#', '', $str); // supprime les autres caractères |
| |
| return $str; |
| } |
| } |
| ?> |