Subversion Repositories eFlore/Applications.cel

Rev

Rev 3572 | Only display areas with differences | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 3572 Rev 3573
1 
<?php
 1 
<?php
2 
// declare(encoding='UTF-8');
 2 
// declare(encoding='UTF-8');
3 
/**
 3 
/**
4 
 * Classe mère abstraite contenant les méthodes génériques des services.
 4 
 * Classe mère abstraite contenant les méthodes génériques des services.
5 
 *
 5 
 *
6 
 * @internal   Mininum PHP version : 5.2
 6 
 * @internal   Mininum PHP version : 5.2
7 
 * @category   CEL
 7 
 * @category   CEL
8 
 * @package    Services
 8 
 * @package    Services
9 
 * @subpackage Bibliothèques
 9 
 * @subpackage Bibliothèques
10 
 * @version    0.1
 10 
 * @version    0.1
11 
 * @author     Mathias CHOUET <mathias@tela-botanica.org>
 11 
 * @author     Mathias CHOUET <mathias@tela-botanica.org>
12 
 * @author     Jean-Pascal MILCENT <jpm@tela-botanica.org>
 12 
 * @author     Jean-Pascal MILCENT <jpm@tela-botanica.org>
13 
 * @author     Aurelien PERONNET <aurelien@tela-botanica.org>
 13 
 * @author     Aurelien PERONNET <aurelien@tela-botanica.org>
14 
 * @license    GPL v3 <http://www.gnu.org/licenses/gpl.txt>
 14 
 * @license    GPL v3 <http://www.gnu.org/licenses/gpl.txt>
15 
 * @license    CECILL v2 <http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt>
 15 
 * @license    CECILL v2 <http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt>
16 
 * @copyright  1999-2014 Tela Botanica <accueil@tela-botanica.org>
 16 
 * @copyright  1999-2014 Tela Botanica <accueil@tela-botanica.org>
17 
 */
 17 
 */
18 
// TODO : il faudrait déplacer les méthodes des sections de cette classe dans des classes séparées chargées via un Conteneur.
 18 
// TODO : il faudrait déplacer les méthodes des sections de cette classe dans des classes séparées chargées via un Conteneur.
19 
abstract class Cel {
 19 
abstract class Cel {
20 
	const ARRET_SERVICE = false;
 20 
	const ARRET_SERVICE = false;
21 
 
 21 
 
22 
	const TYPE_OBS = 'observation';
 22 
	const TYPE_OBS = 'observation';
23 
	const TYPE_IMG = 'image';
 23 
	const TYPE_IMG = 'image';
24 
 
 24 
 
25 
	// TODO: delete wrappers
 25 
	// TODO: delete wrappers
26 
	const SQL_MODE_ASSOC = Bdd::SQL_MODE_ASSOC;
 26 
	const SQL_MODE_ASSOC = Bdd::SQL_MODE_ASSOC;
27 
	const SQL_MODE_OBJET = Bdd::SQL_MODE_OBJET;
 27 
	const SQL_MODE_OBJET = Bdd::SQL_MODE_OBJET;
28 
	const SQL_RETOUR_COMPLET = Bdd::SQL_RETOUR_COMPLET;
 28 
	const SQL_RETOUR_COMPLET = Bdd::SQL_RETOUR_COMPLET;
29 
	const SQL_RETOUR_LIGNE = Bdd::SQL_RETOUR_LIGNE;
 29 
	const SQL_RETOUR_LIGNE = Bdd::SQL_RETOUR_LIGNE;
30 
	const SQL_RETOUR_COLONNE = Bdd::SQL_RETOUR_COLONNE;
 30 
	const SQL_RETOUR_COLONNE = Bdd::SQL_RETOUR_COLONNE;
31 
	const SQL_RETOUR_BRUT = Bdd::SQL_RETOUR_BRUT;
 31 
	const SQL_RETOUR_BRUT = Bdd::SQL_RETOUR_BRUT;
32 
 
 32 
 
33 
	public $config;
 33 
	public $config;
34 
	private $ressources;
 34 
	private $ressources;
35 
	protected $parametres = array();
 35 
	protected $parametres = array();
36 
 
 36 
 
37 
	public static $bdd = null;
 37 
	public static $bdd = null;
38 
 
 38 
 
39 
	protected $messages = array();
 39 
	protected $messages = array();
40 
	protected $debug = array();
 40 
	protected $debug = array();
41 
	protected $start;
 41 
	protected $start;
42 
	protected $limit;
 42 
	protected $limit;
43 
 
 43 
 
44 
	static $referentiels_valides = array();
 44 
	static $referentiels_valides = array();
45 
	static $default_referentiel = null;
 45 
	static $default_referentiel = null;
46 
	static $fallback_referentiel = 'autre';
 46 
	static $fallback_referentiel = 'autre';
47 
 
 47 
 
48 
	public function __construct($config) {
 48 
	public function __construct($config) {
49 
		@session_start();
 49 
		@session_start();
50 
		// Tableau contenant la config de Jrest
 50 
		// Tableau contenant la config de Jrest
51 
		$this->config = $config;
 51 
		$this->config = $config;
52 
 
 52 
 
53 
		// Réglages de PHP
 53 
		// Réglages de PHP
54 
		setlocale(LC_ALL, $this->config['settings']['locale']);
 54 
		setlocale(LC_ALL, $this->config['settings']['locale']);
55 
		date_default_timezone_set($this->config['settings']['fuseauHoraire']);
 55 
		date_default_timezone_set($this->config['settings']['fuseauHoraire']);
56
56
57 
		// Chargement des référentiels disponibles
57 
		// Chargement des référentiels disponibles
58 
		self::$referentiels_valides = array_keys($this->config['referentiels']);
 58 
		self::$referentiels_valides = array_keys($this->config['referentiels']);
59 
		self::$default_referentiel = $this->config['cel']['referentiel_defaut'];
 59 
		self::$default_referentiel = $this->config['cel']['referentiel_defaut'];
60
60
61 
		// Connection à la base de données
 61 
		// Connection à la base de données
62 
		if (self::$bdd === null) { // singleton à l'arrache
 62 
		if (self::$bdd === null) { // singleton à l'arrache
63 
			self::$bdd = new Bdd($this->config, 'database_cel');
 63 
			self::$bdd = new Bdd($this->config, 'database_cel');
64 
		}
 64 
		}
65 
 
 65 
 
66 
		// Nettoyage du _GET (sécurité)
 66 
		// Nettoyage du _GET (sécurité)
67 
		$this->collecterParametres();// Récupération de tous les parametres de _GET, nettoyage et mise dans $this->parametres
 67 
		$this->collecterParametres();// Récupération de tous les parametres de _GET, nettoyage et mise dans $this->parametres
68 
		$this->recupererParametresUrl();// Vidage de _GET et création d'attribut de la classe
 68 
		$this->recupererParametresUrl();// Vidage de _GET et création d'attribut de la classe
69 
		$this->definirParametresUrlParDefaut();
 69 
		$this->definirParametresUrlParDefaut();
70 
 
 70 
 
71 
		// Définition de variable générale dans la config
 71 
		// Définition de variable générale dans la config
72 
		$this->config['settings']['baseURLAbsoluDyn'] = 'http://'.$_SERVER['SERVER_NAME'].$this->config['settings']['baseURL'].'%s';
 72 
		$this->config['settings']['baseURLAbsoluDyn'] = 'http://'.$_SERVER['SERVER_NAME'].$this->config['settings']['baseURL'].'%s';
73 
	}
 73 
	}
74 
 
 74 
 
75 
	//+----------------------------------------------------------------------------------------------------------------+
 75 
	//+----------------------------------------------------------------------------------------------------------------+
76 
	protected function connecterPDO($config, $base = 'database_cel') {
 76 
	protected function connecterPDO($config, $base = 'database_cel') {
77 
		return new Bdd($config, $base);
 77 
		return new Bdd($config, $base);
78 
	}
 78 
	}
79 
 
 79 
 
80 
	public static function db() {
 80 
	public static function db() {
81 
		if (! self::$bdd) {
 81 
		if (! self::$bdd) {
82 
			die('ERREUR: aucune base de données de disponible.');
 82 
			die('ERREUR: aucune base de données de disponible.');
83 
		}
 83 
		}
84 
		return self::$bdd;
 84 
		return self::$bdd;
85 
	}
 85 
	}
86 
 
 86 
 
87 
	// TODO: delete wrappers, en attendant que $this->bdd soit remplacé par Cel::db() partout.
 87 
	// TODO: delete wrappers, en attendant que $this->bdd soit remplacé par Cel::db() partout.
88 
	public function __get($prop) {
 88 
	public function __get($prop) {
89 
		$retour = $this->$prop;
 89 
		$retour = $this->$prop;
90 
		if ($prop == 'bdd') {
 90 
		if ($prop == 'bdd') {
91 
			$retour = self::$bdd;
 91 
			$retour = self::$bdd;
92 
		}
 92 
		}
93 
		return $retour;
 93 
		return $retour;
94 
	}
 94 
	}
95 
 
 95 
 
96 
	protected function protegerTableau(Array $tableau) {
 96 
	protected function protegerTableau(Array $tableau) {
97 
		foreach ($tableau as $id => $val) {
 97 
		foreach ($tableau as $id => $val) {
98 
			if ($val === null) {
 98 
			if ($val === null) {
99 
				$tableau[$id] = 'NULL';
 99 
				$tableau[$id] = 'NULL';
100 
			} else {
 100 
			} else {
101 
				$tableau[$id] = Cel::db()->proteger($val);
 101 
				$tableau[$id] = Cel::db()->proteger($val);
102 
			}
 102 
			}
103 
		}
 103 
		}
104 
		return $tableau;
 104 
		return $tableau;
105 
	}
 105 
	}
106 
 
 106 
 
107 
	//+----------------------------------------------------------------------------------------------------------------+
 107 
	//+----------------------------------------------------------------------------------------------------------------+
108 
	// TRAITEMENT des URLs et des PARAMÊTRES
 108 
	// TRAITEMENT des URLs et des PARAMÊTRES
109 
 
 109 
 
110 
	private function collecterParametres() {
 110 
	private function collecterParametres() {
111 
		foreach ($_GET as $cle => $valeur) {
 111 
		foreach ($_GET as $cle => $valeur) {
112 
			$p = $this->verifierSecuriteParametreUrl($valeur);
 112 
			$p = $this->verifierSecuriteParametreUrl($valeur);
113 
			$this->parametres[$cle] = is_string($p) ? rawurldecode($p) : $p;
 113 
			$this->parametres[$cle] = is_string($p) ? rawurldecode($p) : $p;
114 
		}
 114 
		}
115 
	}
 115 
	}
116 
 
 116 
 
117 
	private function recupererParametresUrl() {
 117 
	private function recupererParametresUrl() {
118 
		$get_params = array('orderby', 'distinct', 'start', 'limit', 'formatRetour');
 118 
		$get_params = array('orderby', 'distinct', 'start', 'limit', 'formatRetour');
119 
		foreach ($get_params as $get) {
 119 
		foreach ($get_params as $get) {
120 
			if (!isset($_GET[$get])) continue;
 120 
			if (!isset($_GET[$get])) continue;
121 
			$_GET[$get] = $this->verifierSecuriteParametreUrl($_GET[$get]);
 121 
			$_GET[$get] = $this->verifierSecuriteParametreUrl($_GET[$get]);
122 
 
 122 
 
123 
			if (empty($_GET[$get])) {
 123 
			if (empty($_GET[$get])) {
124 
				$_GET[$get] = null;
 124 
				$_GET[$get] = null;
125 
				continue;
 125 
				continue;
126 
			}
 126 
			}
127 
 
 127 
 
128 
			if (!isset($this->$get)) {
 128 
			if (!isset($this->$get)) {
129 
				$this->$get = $_GET[$get];
 129 
				$this->$get = $_GET[$get];
130 
			} else {
 130 
			} else {
131 
				$e = "Impossible d'ajouter l'attribut $get à la classe du service car elle possède déjà un attribut nommé : $get";
 131 
				$e = "Impossible d'ajouter l'attribut $get à la classe du service car elle possède déjà un attribut nommé : $get";
132 
				trigger_error($e, E_USER_WARNING);
 132 
				trigger_error($e, E_USER_WARNING);
133 
			}
 133 
			}
134 
		}
 134 
		}
135 
	}
 135 
	}
136 
 
 136 
 
137 
 
 137 
 
138 
	protected function verifierSecuriteParametreUrl($param) {
 138 
	protected function verifierSecuriteParametreUrl($param) {
139 
		//$verifier = array('NULL', "\n", "\r", "\\", "'", '"', "\x00", "\x1a", ';');
 139 
		//$verifier = array('NULL', "\n", "\r", "\\", "'", '"', "\x00", "\x1a", ';');
140 
		return is_string($param) ? strip_tags($param) : $param;
 140 
		return is_string($param) ? strip_tags($param) : $param;
141 
	}
 141 
	}
142 
 
 142 
 
143 
	private function definirParametresUrlParDefaut() {
 143 
	private function definirParametresUrlParDefaut() {
144 
		if (!isset($this->start)) {
 144 
		if (!isset($this->start)) {
145 
			$this->start = 0;
 145 
			$this->start = 0;
146 
		}
 146 
		}
147 
		if (!isset($this->limit)) {
 147 
		if (!isset($this->limit)) {
148 
			$this->limit = 150;
 148 
			$this->limit = 150;
149 
		}
 149 
		}
150 
	}
 150 
	}
151 
 
 151 
 
152 
	protected function traiterParametres($params_attendu, $params, $pourBDD = true) {
 152 
	protected function traiterParametres($params_attendu, $params, $pourBDD = true) {
153 
		$sortie = array();
 153 
		$sortie = array();
154 
		foreach ($params_attendu as $num => $nom) {
 154 
		foreach ($params_attendu as $num => $nom) {
155 
			if (isset($params[$num]) && $params[$num] != '*') {
 155 
			if (isset($params[$num]) && $params[$num] != '*') {
156 
				if ($pourBDD) {
 156 
				if ($pourBDD) {
157 
					$params[$num] = self::$bdd->quote($params[$num]);
 157 
					$params[$num] = self::$bdd->quote($params[$num]);
158 
				}
 158 
				}
159 
				$sortie[$nom] = $params[$num];
 159 
				$sortie[$nom] = $params[$num];
160 
			}
 160 
			}
161 
		}
 161 
		}
162 
		return $sortie;
 162 
		return $sortie;
163 
	}
 163 
	}
164 
 
 164 
 
165 
	protected function traiterNomMethodeGet($nom) {
 165 
	protected function traiterNomMethodeGet($nom) {
166 
		$methode = 'get';
 166 
		$methode = 'get';
167 
		$methode .= str_replace(' ', '', ucwords(str_replace('-', ' ', strtolower($nom))));
 167 
		$methode .= str_replace(' ', '', ucwords(str_replace('-', ' ', strtolower($nom))));
168 
		return $methode;
 168 
		return $methode;
169 
	}
 169 
	}
170 
 
 170 
 
171 
	//+----------------------------------------------------------------------------------------------------------------+
 171 
	//+----------------------------------------------------------------------------------------------------------------+
172 
	// GESTION de l'ENVOI au NAVIGATEUR
 172 
	// GESTION de l'ENVOI au NAVIGATEUR
173 
 
 173 
 
174 
	protected function envoyerMessageErreur($code, $msg) {
 174 
	protected function envoyerMessageErreur($code, $msg) {
175 
		http_response_code($code);
 175 
		http_response_code($code);
176 
		header("Content-Type: text/plain; charset=utf-8");
 176 
		header("Content-Type: text/plain; charset=utf-8");
177 
		die($msg);
 177 
		die($msg);
178 
	}
 178 
	}
179 
 
 179 
 
180 
	protected function envoyerJson($donnees, $encodage = 'utf-8') {
 180 
	protected function envoyerJson($donnees, $encodage = 'utf-8') {
181 
		$encodage_json = true;
 181 
		$encodage_json = true;
182 
		$this->envoyer($donnees, 'application/json', $encodage, $encodage_json);
 182 
		$this->envoyer($donnees, 'application/json', $encodage, $encodage_json);
183 
	}
 183 
	}
184 
 
 184 
 
185 
	protected function envoyerJsonVar($variable, $donnees = null, $encodage = 'utf-8') {
 185 
	protected function envoyerJsonVar($variable, $donnees = null, $encodage = 'utf-8') {
186 
		$contenu = "var $variable = ".json_encode($donnees);
 186 
		$contenu = "var $variable = ".json_encode($donnees);
187 
		$this->envoyer($contenu, 'text/html', $encodage);
 187 
		$this->envoyer($contenu, 'text/html', $encodage);
188 
	}
 188 
	}
189 
 
 189 
 
190 
	protected function envoyerJsonp($donnees = null, $encodage = 'utf-8') {
 190 
	protected function envoyerJsonp($donnees = null, $encodage = 'utf-8') {
191 
		$contenu = $this->parametres['callback'].'('.json_encode($donnees).');';
 191 
		$contenu = $this->parametres['callback'].'('.json_encode($donnees).');';
192 
		$this->envoyer($contenu, 'text/html', $encodage);
 192 
		$this->envoyer($contenu, 'text/html', $encodage);
193 
	}
 193 
	}
194 
 
 194 
 
195 
	protected function envoyer($donnees = null, $mime = 'text/html', $encodage = 'utf-8', $json = false) {
 195 
	protected function envoyer($donnees = null, $mime = 'text/html', $encodage = 'utf-8', $json = false) {
196 
		// Traitements des messages d'erreurs et données
 196 
		// Traitements des messages d'erreurs et données
197 
		$sortie = $donnees;
 197 
		$sortie = $donnees;
198 
		if (count($this->messages) != 0) {
 198 
		if (count($this->messages) != 0) {
199 
			$code_http = 500; // Internal Server Error
 199 
			$code_http = 500; // Internal Server Error
200 
			$mime = 'application/json';
 200 
			$mime = 'application/json';
201 
			$json = true;
 201 
			$json = true;
202 
			if (!isset($donnees)) {
 - 
 
203 
				$donnees = new stdClass();
 - 
 
204 
			}
 - 
 
205 
			$donnees->cause = $this->messages;
 202 
			$donnees->cause = $this->messages;
206 
		} else {
 203 
		} else {
207 
			$code_http = 200; // OK
 204 
			$code_http = 200; // OK
208 
			if (is_null($donnees)) {
 205 
			if (is_null($donnees)) {
209 
				$sortie = 'OK';
 206 
				$sortie = 'OK';
210 
			}
 207 
			}
211 
		}
 208 
		}
212 
 
 209 
 
213 
		// Gestion de l'envoie du déboguage
 210 
		// Gestion de l'envoie du déboguage
214 
		$this->envoyerDebogage();
 211 
		$this->envoyerDebogage();
215 
 
 212 
 
216 
		// Encodage au format et JSON et envoie sur la sortie standard
 213 
		// Encodage au format et JSON et envoie sur la sortie standard
217 
		$contenu = $json ? json_encode($sortie) : $sortie;
 214 
		$contenu = $json ? json_encode($sortie) : $sortie;
218 
 
 215 
 
219 
		$this->envoyerContenu($encodage, $mime, $contenu, $code_http);
 216 
		$this->envoyerContenu($encodage, $mime, $contenu, $code_http);
220 
	}
 217 
	}
221 
 
 218 
 
222 
	private function envoyerDebogage() {
 219 
	private function envoyerDebogage() {
223 
		if (!is_array($this->debug)) {
 220 
		if (!is_array($this->debug)) {
224 
			$this->debug[] = $this->debug;
 221 
			$this->debug[] = $this->debug;
225 
		}
 222 
		}
226 
		if (count($this->debug) != 0) {
 223 
		if (count($this->debug) != 0) {
227 
			foreach ($this->debug as $cle => $val) {
 224 
			foreach ($this->debug as $cle => $val) {
228 
				if (is_array($val)) {
 225 
				if (is_array($val)) {
229 
					$this->debug[$cle] = print_r($val, true);
 226 
					$this->debug[$cle] = print_r($val, true);
230 
				}
 227 
				}
231 
			}
 228 
			}
232 
			header('X-DebugJrest-Data:'.json_encode($this->debug));
 229 
			header('X-DebugJrest-Data:'.json_encode($this->debug));
233 
		}
 230 
		}
234 
	}
 231 
	}
235 
 
 232 
 
236 
	private function envoyerContenu($encodage, $mime, $contenu, $code_http=200) {
 233 
	private function envoyerContenu($encodage, $mime, $contenu, $code_http=200) {
237 
		if (!is_null($mime) && !is_null($encodage)) {
 234 
		if (!is_null($mime) && !is_null($encodage)) {
238 
			header("Content-Type: $mime; charset=$encodage");
 235 
			header("Content-Type: $mime; charset=$encodage");
239 
		} else if (!is_null($mime) && is_null($encodage)) {
 236 
		} else if (!is_null($mime) && is_null($encodage)) {
240 
			header("Content-Type: $mime");
 237 
			header("Content-Type: $mime");
241 
		}
 238 
		}
242 
		http_response_code($code_http);
 239 
		http_response_code($code_http);
243 
		print $contenu;
 240 
		print $contenu;
244 
	}
 241 
	}
245 
 
 242 
 
246 
	static function envoyerAuth($message_accueil, $message_echec) {
 243 
	static function envoyerAuth($message_accueil, $message_echec) {
247 
		http_response_code(401);// Unauthorized
 244 
		http_response_code(401);// Unauthorized
248 
		header('WWW-Authenticate: Basic realm="'.mb_convert_encoding($message_accueil, 'ISO-8859-1', 'UTF-8').'"');
 245 
		header('WWW-Authenticate: Basic realm="'.mb_convert_encoding($message_accueil, 'ISO-8859-1', 'UTF-8').'"');
249 
		header('Content-type: text/plain; charset=UTF-8');
 246 
		header('Content-type: text/plain; charset=UTF-8');
250 
		print $message_echec;
 247 
		print $message_echec;
251 
		exit;
 248 
		exit;
252 
	}
 249 
	}
253 
 
 250 
 
254 
	//+----------------------------------------------------------------------------------------------------------------+
 251 
	//+----------------------------------------------------------------------------------------------------------------+
255 
	// GESTION DES CLASSES CHARGÉES À LA DEMANDE
 252 
	// GESTION DES CLASSES CHARGÉES À LA DEMANDE
256 
 
 253 
 
257 
	protected function getRestClient() {
 254 
	protected function getRestClient() {
258 
		if (!isset($this->restClient)) {
 255 
		if (!isset($this->restClient)) {
259 
			$this->restClient = new CelRestClient();
 256 
			$this->restClient = new CelRestClient();
260 
		}
 257 
		}
261 
		return $this->restClient;
 258 
		return $this->restClient;
262 
	}
 259 
	}
263 
 
 260 
 
264 
	//+----------------------------------------------------------------------------------------------------------------+
 261 
	//+----------------------------------------------------------------------------------------------------------------+
265 
	// GESTION DE L'IDENTIFICATION
 262 
	// GESTION DE L'IDENTIFICATION
266 
 
 263 
 
267 
	static function getAuthIdentifiant() {
 264 
	static function getAuthIdentifiant() {
268 
		return isset($_SERVER['PHP_AUTH_USER']) ? $_SERVER['PHP_AUTH_USER'] : null;
 265 
		return isset($_SERVER['PHP_AUTH_USER']) ? $_SERVER['PHP_AUTH_USER'] : null;
269 
	}
 266 
	}
270 
 
 267 
 
271 
	static function getAuthMotDePasse() {
 268 
	static function getAuthMotDePasse() {
272 
		return isset($_SERVER['PHP_AUTH_PW']) ? $_SERVER['PHP_AUTH_PW'] : null;
 269 
		return isset($_SERVER['PHP_AUTH_PW']) ? $_SERVER['PHP_AUTH_PW'] : null;
273 
	}
 270 
	}
274 
 
 271 
 
275 
	public function authentifierAdmin() {
 272 
	public function authentifierAdmin() {
276 
		$message_accueil = "Veuillez vous identifier avec votre compte Tela Botanica.";
 273 
		$message_accueil = "Veuillez vous identifier avec votre compte Tela Botanica.";
277 
		$message_echec = "Accès limité aux administrateurs du CEL.\n".
 274 
		$message_echec = "Accès limité aux administrateurs du CEL.\n".
278 
			"Votre tentative d'identification a échoué.\n".
 275 
			"Votre tentative d'identification a échoué.\n".
279 
			"Actualiser la page pour essayer à nouveau si vous êtes bien inscrit comme administrateur.";
 276 
			"Actualiser la page pour essayer à nouveau si vous êtes bien inscrit comme administrateur.";
280 
		return $this->authentifier($message_accueil, $message_echec, 'Admin');
 277 
		return $this->authentifier($message_accueil, $message_echec, 'Admin');
281 
	}
 278 
	}
282 
 
 279 
 
283 
	public function authentifierUtilisateur() {
 280 
	public function authentifierUtilisateur() {
284 
		$message_accueil = "Veuillez vous identifier avec votre compte Tela Botanica.";
 281 
		$message_accueil = "Veuillez vous identifier avec votre compte Tela Botanica.";
285 
		$message_echec = "Accès limité aux utilisateur du CEL.\n".
 282 
		$message_echec = "Accès limité aux utilisateur du CEL.\n".
286 
			"Inscrivez vous http://www.tela-botanica.org/page:inscription pour le devenir.\n".
 283 
			"Inscrivez vous http://www.tela-botanica.org/page:inscription pour le devenir.\n".
287 
			"Votre tentative d'identification a échoué.\n".
 284 
			"Votre tentative d'identification a échoué.\n".
288 
			"Actualiser la page pour essayer à nouveau si vous êtes déjà inscrit ou contacter 'accueil@tela-botanica.org'.";
 285 
			"Actualiser la page pour essayer à nouveau si vous êtes déjà inscrit ou contacter 'accueil@tela-botanica.org'.";
289 
		return $this->authentifier($message_accueil, $message_echec, 'Utilisateur');
 286 
		return $this->authentifier($message_accueil, $message_echec, 'Utilisateur');
290 
	}
 287 
	}
291 
 
 288 
 
292 
	public function controleUtilisateur($id) {
 289 
	public function controleUtilisateur($id) {
293 
		if (@array_key_exists('id_utilisateur', $_SESSION['user']) && empty($_SESSION['user']['id_utilisateur'])) {
 290 
		if (@array_key_exists('id_utilisateur', $_SESSION['user']) && empty($_SESSION['user']['id_utilisateur'])) {
294 
			//cas de la session temporaire, on ne fait rien de particulier
 291 
			//cas de la session temporaire, on ne fait rien de particulier
295 
		} else {
 292 
		} else {
296 
			if (isset($_SESSION['user']) && isset($_SESSION['user']['id_utilisateur']) && !$this->etreAdminCelParId($_SESSION['user']['id_utilisateur']) && $_SESSION['user']['id_utilisateur'] != $id) {
 293 
			if (isset($_SESSION['user']) && isset($_SESSION['user']['id_utilisateur']) && !$this->etreAdminCelParId($_SESSION['user']['id_utilisateur']) && $_SESSION['user']['id_utilisateur'] != $id) {
297 
				// cas d'usurpation d'identité
 294 
				// cas d'usurpation d'identité
298 
				print 'Accès interdit';
 295 
				print 'Accès interdit';
299 
				exit();
 296 
				exit();
300 
			}
 297 
			}
301 
		}
 298 
		}
302 
	}
 299 
	}
303 
 
 300 
 
304 
	public function controleAppelIpAutorisee() {
 301 
	public function controleAppelIpAutorisee() {
305 
		$ipsAutorisees = explode(',', $this->config['jrest_admin']['ip_autorisees']);
 302 
		$ipsAutorisees = explode(',', $this->config['jrest_admin']['ip_autorisees']);
306 
		$remoteIp = filter_input(INPUT_SERVER, 'REMOTE_ADDR', FILTER_VALIDATE_IP);
 303 
		$remoteIp = filter_input(INPUT_SERVER, 'REMOTE_ADDR', FILTER_VALIDATE_IP);
307 
		$serverIp = filter_input(INPUT_SERVER, 'SERVER_ADDR', FILTER_VALIDATE_IP);
 304 
		$serverIp = filter_input(INPUT_SERVER, 'SERVER_ADDR', FILTER_VALIDATE_IP);
308 
		if (in_array($remoteIp, $ipsAutorisees) == false) {
 305 
		if (in_array($remoteIp, $ipsAutorisees) == false) {
309 
			if ($remoteIp != $serverIp) {// ATTENTION : maintenir ce test à l'intérieur du précédent
 306 
			if ($remoteIp != $serverIp) {// ATTENTION : maintenir ce test à l'intérieur du précédent
310 
				$msg = "Accès interdit. \n".
 307 
				$msg = "Accès interdit. \n".
311 
					"Vous n'êtes pas autorisé à accéder à ce service depuis '$remoteIp' !\n";
 308 
					"Vous n'êtes pas autorisé à accéder à ce service depuis '$remoteIp' !\n";
312 
				$this->envoyerMessageErreur(401, $msg);
 309 
				$this->envoyerMessageErreur(401, $msg);
313 
			}
 310 
			}
314 
		}
 311 
		}
315 
		return true;
 312 
		return true;
316 
	}
 313 
	}
317 
 
 314 
 
318 
	public function logger($index,$chaine = 'err') {
 315 
	public function logger($index,$chaine = 'err') {
319 
		if (!class_exists('Log')) {
 316 
		if (!class_exists('Log')) {
320 
			Log::getInstance();
 317 
			Log::getInstance();
321 
		}
 318 
		}
322 
		Log::setCheminLog($this->config['log']['cheminlog']);
 319 
		Log::setCheminLog($this->config['log']['cheminlog']);
323 
		Log::setTimeZone($this->config['log']['timezone']);
 320 
		Log::setTimeZone($this->config['log']['timezone']);
324 
		Log::setTailleMax($this->config['log']['taillemax']);
 321 
		Log::setTailleMax($this->config['log']['taillemax']);
325 
		Log::ajouterEntree($index,$chaine);
 322 
		Log::ajouterEntree($index,$chaine);
326 
	}
 323 
	}
327 
 
 324 
 
328 
	private function authentifier($message_accueil, $message_echec, $type) {
 325 
	private function authentifier($message_accueil, $message_echec, $type) {
329 
		if (!isset($_SERVER['PHP_AUTH_USER'])) {
 326 
		if (!isset($_SERVER['PHP_AUTH_USER'])) {
330 
			self::envoyerAuth($message_accueil, $message_echec); // exit
 327 
			self::envoyerAuth($message_accueil, $message_echec); // exit
331 
		}
 328 
		}
332 
 
 329 
 
333 
		if ($type == 'Utilisateur' && self::getAuthMotDePasse() == 'debug') {
 330 
		if ($type == 'Utilisateur' && self::getAuthMotDePasse() == 'debug') {
334 
			$autorisation = true;
 331 
			$autorisation = true;
335 
		} else {
 332 
		} else {
336 
			$methodeAutorisation = "etre{$type}Autorise";
 333 
			$methodeAutorisation = "etre{$type}Autorise";
337 
			$autorisation = $this->$methodeAutorisation();
 334 
			$autorisation = $this->$methodeAutorisation();
338 
		}
 335 
		}
339 
		if ($autorisation == false) {
 336 
		if ($autorisation == false) {
340 
			self::envoyerAuth($message_accueil, $message_echec);
 337 
			self::envoyerAuth($message_accueil, $message_echec);
341 
		}
 338 
		}
342 
 
 339 
 
343 
		return true;
 340 
		return true;
344 
	}
 341 
	}
345 
 
 342 
 
346 
	public function etreUtilisateurAutorise() {
 343 
	public function etreUtilisateurAutorise() {
347 
		$identifiant = self::getAuthIdentifiant();
 344 
		$identifiant = self::getAuthIdentifiant();
348 
		$mdp = md5(self::getAuthMotDePasse());
 345 
		$mdp = md5(self::getAuthMotDePasse());
349 
		$service = "TestLoginMdp/$identifiant/$mdp";
 346 
		$service = "TestLoginMdp/$identifiant/$mdp";
350 
		$url = sprintf($this->config['settings']['baseURLServicesAnnuaireTpl'], $service);
 347 
		$url = sprintf($this->config['settings']['baseURLServicesAnnuaireTpl'], $service);
351 
		$json = $this->getRestClient()->consulter($url);
 348 
		$json = $this->getRestClient()->consulter($url);
352 
		$existe = json_decode($json);
 349 
		$existe = json_decode($json);
353 
 
 350 
 
354 
		$autorisation = (isset($existe) && $existe) ? true :false;
 351 
		$autorisation = (isset($existe) && $existe) ? true :false;
355 
		return $autorisation;
 352 
		return $autorisation;
356 
	}
 353 
	}
357 
 
 354 
 
358 
	public function etreAdminAutorise() {
 355 
	public function etreAdminAutorise() {
359 
		$identifiant = self::getAuthIdentifiant();
 356 
		$identifiant = self::getAuthIdentifiant();
360 
		$autorisation = ($this->etreUtilisateurAutorise() && $this->etreAdminCel($identifiant)) ? true : false;
 357 
		$autorisation = ($this->etreUtilisateurAutorise() && $this->etreAdminCel($identifiant)) ? true : false;
361 
		return $autorisation;
 358 
		return $autorisation;
362 
	}
 359 
	}
363 
 
 360 
 
364 
	public function etreAdminCelParId($id) {
 361 
	public function etreAdminCelParId($id) {
365 
		// si l'utilisateur s'est déjà identifié, alors les infos
 362 
		// si l'utilisateur s'est déjà identifié, alors les infos
366 
		// sur le fait qu'il est admin ou non sont déjà disponibles
 363 
		// sur le fait qu'il est admin ou non sont déjà disponibles
367 
		if(isset($_SESSION['user']) && isset($_SESSION['user']['admin']) && $_SESSION['user']['id_utilisateur'] == $id) {
 364 
		if(isset($_SESSION['user']) && isset($_SESSION['user']['admin']) && $_SESSION['user']['id_utilisateur'] == $id) {
368 
			$admin = $_SESSION['user']['admin'];
 365 
			$admin = $_SESSION['user']['admin'];
369 
		} else {
 366 
		} else {
370 
			$requete = "SELECT admin FROM cel_utilisateurs_infos WHERE id_utilisateur = ".Cel::db()->proteger($id);
 367 
			$requete = "SELECT admin FROM cel_utilisateurs_infos WHERE id_utilisateur = ".Cel::db()->proteger($id);
371 
			$resultat = Cel::db()->requeter($requete);
 368 
			$resultat = Cel::db()->requeter($requete);
372 
 
 369 
 
373 
			$admin = false;
 370 
			$admin = false;
374 
			if ($resultat && count($resultat) > 0) {
 371 
			if ($resultat && count($resultat) > 0) {
375 
				$admin = ($resultat[0]['admin'] == 1);
 372 
				$admin = ($resultat[0]['admin'] == 1);
376 
			}
 373 
			}
377 
		}
 374 
		}
378 
		return $admin;
 375 
		return $admin;
379 
	}
 376 
	}
380 
 
 377 
 
381 
	public function etreAdminCel($courriel) {
 378 
	public function etreAdminCel($courriel) {
382 
		// si l'utilisateur s'est déjà identifié, alors les infos
 379 
		// si l'utilisateur s'est déjà identifié, alors les infos
383 
		// sur le fait qu'il est admin ou non sont déjà disponibles
 380 
		// sur le fait qu'il est admin ou non sont déjà disponibles
384 
		if(isset($_SESSION['user']) && isset($_SESSION['user']['admin']) && $_SESSION['user']['courriel'] == $courriel) {
 381 
		if(isset($_SESSION['user']) && isset($_SESSION['user']['admin']) && $_SESSION['user']['courriel'] == $courriel) {
385 
			$admin = $_SESSION['user']['admin'];
 382 
			$admin = $_SESSION['user']['admin'];
386 
		} else {
 383 
		} else {
387 
			$requete = "SELECT admin FROM cel_utilisateurs_infos WHERE courriel = ".Cel::db()->proteger($courriel);
 384 
			$requete = "SELECT admin FROM cel_utilisateurs_infos WHERE courriel = ".Cel::db()->proteger($courriel);
388 
			$resultat = Cel::db()->requeter($requete);
 385 
			$resultat = Cel::db()->requeter($requete);
389 
 
 386 
 
390 
			$admin = false;
 387 
			$admin = false;
391 
			if ($resultat && count($resultat) > 0) {
 388 
			if ($resultat && count($resultat) > 0) {
392 
				$admin = ($resultat[0]['admin'] == 1);
 389 
				$admin = ($resultat[0]['admin'] == 1);
393 
			}
 390 
			}
394 
		}
 391 
		}
395 
		return $admin;
 392 
		return $admin;
396 
	}
 393 
	}
397 
 
 394 
 
398 
	public function getInfosComplementairesUtilisateur($id_utilisateur) {
 395 
	public function getInfosComplementairesUtilisateur($id_utilisateur) {
399 
		$infos = array('prenom' => '', 'nom' => '', 'courriel' => '');
 396 
		$infos = array('prenom' => '', 'nom' => '', 'courriel' => '');
400 
		if (is_numeric($id_utilisateur)) {
 397 
		if (is_numeric($id_utilisateur)) {
401 
			$idUtilisateurP = Cel::db()->proteger($id_utilisateur);
 398 
			$idUtilisateurP = Cel::db()->proteger($id_utilisateur);
402 
			$requete = 'SELECT prenom, nom, courriel '.
 399 
			$requete = 'SELECT prenom, nom, courriel '.
403 
				'FROM cel_utilisateurs_infos '.
 400 
				'FROM cel_utilisateurs_infos '.
404 
				"WHERE id_utilisateur = $idUtilisateurP ".
 401 
				"WHERE id_utilisateur = $idUtilisateurP ".
405 
				' -- ' . __FILE__ . ':' . __LINE__;
 402 
				' -- ' . __FILE__ . ':' . __LINE__;
406 
			$resultat = Cel::db()->requeter($requete);
 403 
			$resultat = Cel::db()->requeter($requete);
407 
 
 404 
 
408 
			if ($resultat && count($resultat)) {
 405 
			if ($resultat && count($resultat)) {
409 
				$infos = $resultat[0];
 406 
				$infos = $resultat[0];
410 
			}
 407 
			}
411 
		}
 408 
		}
412 
		return $infos;
 409 
		return $infos;
413 
	}
 410 
	}
414 
 
 411 
 
415 
	public function getInfosComplementairesUtilisateurPourMail($mail_utilisateur) {
 412 
	public function getInfosComplementairesUtilisateurPourMail($mail_utilisateur) {
416 
		$infos = array('prenom' => '', 'nom' => '', 'courriel' => $mail_utilisateur);
 413 
		$infos = array('prenom' => '', 'nom' => '', 'courriel' => $mail_utilisateur);
417 
 
 414 
 
418 
		$mailUtilisateurP = Cel::db()->proteger($mail_utilisateur);
 415 
		$mailUtilisateurP = Cel::db()->proteger($mail_utilisateur);
419 
		$requete = 'SELECT id_utilisateur as id, prenom, nom '.
 416 
		$requete = 'SELECT id_utilisateur as id, prenom, nom '.
420 
			'FROM cel_utilisateurs_infos '.
 417 
			'FROM cel_utilisateurs_infos '.
421 
			"WHERE courriel = $mailUtilisateurP ".
 418 
			"WHERE courriel = $mailUtilisateurP ".
422 
			' -- ' . __FILE__ . ':' . __LINE__;
 419 
			' -- ' . __FILE__ . ':' . __LINE__;
423 
 
 420 
 
424 
		$resultat = Cel::db()->requeter($requete);
 421 
		$resultat = Cel::db()->requeter($requete);
425 
 
 422 
 
426 
		if ($resultat && is_array($resultat) && count($resultat) > 0) {
 423 
		if ($resultat && is_array($resultat) && count($resultat) > 0) {
427 
			$infos = $resultat;
 424 
			$infos = $resultat;
428 
		}
 425 
		}
429 
 
 426 
 
430 
		return $infos;
 427 
		return $infos;
431 
	}
 428 
	}
432 
 
 429 
 
433 
	protected function controlerAccessibiliteWs() {
 430 
	protected function controlerAccessibiliteWs() {
434 
		if (self::ARRET_SERVICE) {
 431 
		if (self::ARRET_SERVICE) {
435 
			$msg = "Les services du CEL sont temporairement désactivées.";
 432 
			$msg = "Les services du CEL sont temporairement désactivées.";
436 
			$this->envoyerMessageErreur(503, $msg);
 433 
			$this->envoyerMessageErreur(503, $msg);
437 
		}
 434 
		}
438 
		return true;
 435 
		return true;
439 
	}
 436 
	}
440 
 
 437 
 
441 
	//+----------------------------------------------------------------------------------------------------------------+
 438 
	//+----------------------------------------------------------------------------------------------------------------+
442 
	// GESTION DE MÉTHODES COMMUNES ENTRE LES SERVICES
 439 
	// GESTION DE MÉTHODES COMMUNES ENTRE LES SERVICES
443 
 
 440 
 
444 
	protected function denullifierTableauValeurCel(&$tableau) {
 441 
	protected function denullifierTableauValeurCel(&$tableau) {
445 
		foreach ($tableau as $k => $v) {
 442 
		foreach ($tableau as $k => $v) {
446 
			if (($v == 'null') || ($v == '000null')) {
 443 
			if (($v == 'null') || ($v == '000null')) {
447 
				$row[$k] = '';
 444 
				$row[$k] = '';
448 
			} else {
 445 
			} else {
449 
				$row[$k] = utf8_decode($v);
 446 
				$row[$k] = utf8_decode($v);
450 
			}
 447 
			}
451 
		}
 448 
		}
452 
		return $tableau;
 449 
		return $tableau;
453 
	}
 450 
	}
454 
 
 451 
 
455 
	protected function getUrlImage($id, $format = 'L') {
 452 
	protected function getUrlImage($id, $format = 'L') {
456 
		$url_tpl = $this->config['settings']['celImgUrlTpl'];
 453 
		$url_tpl = $this->config['settings']['celImgUrlTpl'];
457 
		$id = sprintf('%09s', $id).$format;
 454 
		$id = sprintf('%09s', $id).$format;
458 
		$url = sprintf($url_tpl, $id);
 455 
		$url = sprintf($url_tpl, $id);
459 
		return $url;
 456 
		return $url;
460 
	}
 457 
	}
461 
 
 458 
 
462 
	/**
 459 
	/**
463 
	 * Prend en paramêtre un tableau de courriels et retourne après avoir interrogé un service de l'annuaire
 460 
	 * Prend en paramêtre un tableau de courriels et retourne après avoir interrogé un service de l'annuaire
464 
	 * une tableau avec en clé le courriel et en valeur l'intitulé de la personne à afficher.
 461 
	 * une tableau avec en clé le courriel et en valeur l'intitulé de la personne à afficher.
465 
	 *
 462 
	 *
466 
	 * @param array $courriels un tableau de courriels pour lesquels il faut rechercher les infos d'identité
 463 
	 * @param array $courriels un tableau de courriels pour lesquels il faut rechercher les infos d'identité
467 
	 */
 464 
	 */
468 
	protected function creerAuteurs(Array $courriels) {
 465 
	protected function creerAuteurs(Array $courriels) {
469 
		$auteurs = array();
 466 
		$auteurs = array();
470 
		$identites = $this->recupererUtilisateursIdentite($courriels);
 467 
		$identites = $this->recupererUtilisateursIdentite($courriels);
471 
		if ($identites) {
 468 
		if ($identites) {
472 
			foreach ($identites as $courriel => $infos) {
 469 
			foreach ($identites as $courriel => $infos) {
473 
				$auteurs[$courriel] = $infos['intitule'];
 470 
				$auteurs[$courriel] = $infos['intitule'];
474 
			}
 471 
			}
475 
		}
 472 
		}
476 
		return $auteurs;
 473 
		return $auteurs;
477 
	}
 474 
	}
478 
 
 475 
 
479 
	protected function recupererUtilisateursIdentite(Array $courriels) {
 476 
	protected function recupererUtilisateursIdentite(Array $courriels) {
480 
		// Récupération des données au format Json
 477 
		// Récupération des données au format Json
481 
		$service = "utilisateur/identite-par-courriel/".implode(',', $courriels);
 478 
		$service = "utilisateur/identite-par-courriel/".implode(',', $courriels);
482 
		$url = sprintf($this->config['settings']['baseURLServicesAnnuaireTpl'], $service);
 479 
		$url = sprintf($this->config['settings']['baseURLServicesAnnuaireTpl'], $service);
483 
		$json = file_get_contents($url);
 480 
		$json = file_get_contents($url);
484 
		$utilisateurs = json_decode($json, true);
 481 
		$utilisateurs = json_decode($json, true);
485 
		$noms = array();
 482 
		$noms = array();
486 
		foreach ($courriels as $courriel) {
 483 
		foreach ($courriels as $courriel) {
487 
			$courriel = strtolower($courriel);
 484 
			$courriel = strtolower($courriel);
488 
			$info = array('id' => null, 'intitule' => '');
 485 
			$info = array('id' => null, 'intitule' => '');
489 
			if (isset($utilisateurs[$courriel])) {
 486 
			if (isset($utilisateurs[$courriel])) {
490 
				$info['intitule'] = $utilisateurs[$courriel]['intitule'];
 487 
				$info['intitule'] = $utilisateurs[$courriel]['intitule'];
491 
				$info['id'] = $utilisateurs[$courriel]['id'];
 488 
				$info['id'] = $utilisateurs[$courriel]['id'];
492 
			} else {
 489 
			} else {
493 
				$info['intitule'] = $this->tronquerCourriel($courriel);
 490 
				$info['intitule'] = $this->tronquerCourriel($courriel);
494 
			}
 491 
			}
495 
			$noms[$courriel] = $info;
 492 
			$noms[$courriel] = $info;
496 
		}
 493 
		}
497 
		return $noms;
 494 
		return $noms;
498 
	}
 495 
	}
499 
 
 496 
 
500 
	protected function tronquerCourriel($courriel) {
 497 
	protected function tronquerCourriel($courriel) {
501 
		return preg_replace('/[^@]+$/i', '...', $courriel);
 498 
		return preg_replace('/[^@]+$/i', '...', $courriel);
502 
	}
 499 
	}
503 
 
 500 
 
504 
	protected function nettoyerTableau(Array $tableau) {
 501 
	protected function nettoyerTableau(Array $tableau) {
505 
		foreach ($tableau as $cle => $valeur) {
 502 
		foreach ($tableau as $cle => $valeur) {
506 
			if (is_array($valeur)) {
 503 
			if (is_array($valeur)) {
507 
				$valeur = $this->nettoyerTableau($valeur);
 504 
				$valeur = $this->nettoyerTableau($valeur);
508 
			} else {
 505 
			} else {
509 
				$valeur = $this->nettoyerTexte($valeur);
 506 
				$valeur = $this->nettoyerTexte($valeur);
510 
			}
 507 
			}
511 
			$tableau[$cle] = $valeur;
 508 
			$tableau[$cle] = $valeur;
512 
		}
 509 
		}
513 
		return $tableau;
 510 
		return $tableau;
514 
	}
 511 
	}
515 
 
 512 
 
516 
	/**
 513 
	/**
517 
	 * Fonction nettoyant les caractères spéciaux (&,<) et les valeurs nulles du CEL dans un texte comprenant du HTML.
 514 
	 * Fonction nettoyant les caractères spéciaux (&,<) et les valeurs nulles du CEL dans un texte comprenant du HTML.
518 
	 */
 515 
	 */
519 
	protected function nettoyerTexte($txt) {
 516 
	protected function nettoyerTexte($txt) {
520 
		$txt = preg_replace('/&(?!([a-z]+|#[0-9]+|#x[0-9][a-f]+);)/i', '&amp;', $txt);
 517 
		$txt = preg_replace('/&(?!([a-z]+|#[0-9]+|#x[0-9][a-f]+);)/i', '&amp;', $txt);
521 
		// TODO : trouver une regexp qui permet de remplacer les symboles < et > isolés
 518 
		// TODO : trouver une regexp qui permet de remplacer les symboles < et > isolés
522 
		//$txt = preg_replace('/<(?!([a-z][a-z0-9]*)\b[^>]*>(.*?)<\/\1>|\/\s*([a-z][a-z0-9]*)\s*>)/i', '&lt;', $txt);
 519 
		//$txt = preg_replace('/<(?!([a-z][a-z0-9]*)\b[^>]*>(.*?)<\/\1>|\/\s*([a-z][a-z0-9]*)\s*>)/i', '&lt;', $txt);
523 
		//$txt = preg_replace('/(?!<([a-z][a-z0-9]*)\b[^>]*)>(?!(.*?)<\/\1>)/i', '&gt;', $txt);
 520 
		//$txt = preg_replace('/(?!<([a-z][a-z0-9]*)\b[^>]*)>(?!(.*?)<\/\1>)/i', '&gt;', $txt);
524 
		$txt = preg_replace('/(?:000null|null)/i', '', $txt);
 521 
		$txt = preg_replace('/(?:000null|null)/i', '', $txt);
525 
		return $txt;
 522 
		return $txt;
526 
	}
 523 
	}
527 
 
 524 
 
528 
	/**
 525 
	/**
529 
	 * Fonction nettoyant les caractères spéciaux HTML pour les champs de saisie libre du CEL.
 526 
	 * Fonction nettoyant les caractères spéciaux HTML pour les champs de saisie libre du CEL.
530 
	 */
 527 
	 */
531 
	static function protegerCaracteresHtmlDansChamps($donnees) {
 528 
	static function protegerCaracteresHtmlDansChamps($donnees) {
532 
		$champs = array('mots_cles_texte', 'commentaire',
 529 
		$champs = array('mots_cles_texte', 'commentaire',
533 
			'zone_geo', 'lieudit', 'station', 'milieu', 'commentaire', 'nom_sel');
 530 
			'zone_geo', 'lieudit', 'station', 'milieu', 'commentaire', 'nom_sel');
534 
		foreach ($champs as $champ) {
 531 
		foreach ($champs as $champ) {
535 
			if (isset($donnees[$champ])) {
 532 
			if (isset($donnees[$champ])) {
536 
				$donnees[$champ] = htmlspecialchars($donnees[$champ]);
 533 
				$donnees[$champ] = htmlspecialchars($donnees[$champ]);
537 
			}
 534 
			}
538 
		}
 535 
		}
539 
		return $donnees;
 536 
		return $donnees;
540 
	}
 537 
	}
541 
 
 538 
 
542 
	protected function convertirDateHeureMysqlEnTimestamp($date_heure_mysql){
 539 
	protected function convertirDateHeureMysqlEnTimestamp($date_heure_mysql){
543 
		$val = explode(' ', $date_heure_mysql);
 540 
		$val = explode(' ', $date_heure_mysql);
544 
		$date = explode('-', $val[0]);
 541 
		$date = explode('-', $val[0]);
545 
		$heure = explode(':', $val[1]);
 542 
		$heure = explode(':', $val[1]);
546 
		return mktime((int) $heure[0], (int) $heure[1], (int) $heure[2], (int) $date[1], (int) $date[2], (int) $date[0]);
 543 
		return mktime((int) $heure[0], (int) $heure[1], (int) $heure[2], (int) $date[1], (int) $date[2], (int) $date[0]);
547 
	}
 544 
	}
548 
 
 545 
 
549 
	protected function etreNull($valeur) {
 546 
	protected function etreNull($valeur) {
550 
		$etre_null = false;
 547 
		$etre_null = false;
551 
		if ($valeur == '' || $valeur == null || $valeur == '000null' || $valeur == 'null' || $valeur == '*') {
 548 
		if ($valeur == '' || $valeur == null || $valeur == '000null' || $valeur == 'null' || $valeur == '*') {
552 
			$etre_null = true;
 549 
			$etre_null = true;
553 
		}
 550 
		}
554 
		return $etre_null;
 551 
		return $etre_null;
555 
	}
 552 
	}
556 
 
 553 
 
557 
	protected function formaterDate($date_heure_mysql, $format = '%A %d %B %Y à %H:%M') {
 554 
	protected function formaterDate($date_heure_mysql, $format = '%A %d %B %Y à %H:%M') {
558 
		$date_formatee = '';
 555 
		$date_formatee = '';
559 
		if (!$this->etreNull($date_heure_mysql)) {
 556 
		if (!$this->etreNull($date_heure_mysql)) {
560 
			$timestamp = $this->convertirDateHeureMysqlEnTimestamp($date_heure_mysql);
 557 
			$timestamp = $this->convertirDateHeureMysqlEnTimestamp($date_heure_mysql);
561 
			$date_formatee = strftime($format, $timestamp);
 558 
			$date_formatee = strftime($format, $timestamp);
562 
		}
 559 
		}
563 
		return $date_formatee;
 560 
		return $date_formatee;
564 
	}
 561 
	}
565 
 
 562 
 
566 
	protected function convertirCodeZoneGeoVersDepartement($code_zone_geo) {
 563 
	protected function convertirCodeZoneGeoVersDepartement($code_zone_geo) {
567 
		$code_departement = '';
 564 
		$code_departement = '';
568 
		if (self::estUnCodeInseeDepartement($code_zone_geo)) {
 565 
		if (self::estUnCodeInseeDepartement($code_zone_geo)) {
569 
			$code_departement = substr(ltrim($code_zone_geo,'INSEE-C:'),0,2);
 566 
			$code_departement = substr(ltrim($code_zone_geo,'INSEE-C:'),0,2);
570 
		}
 567 
		}
571 
		return $code_departement;
 568 
		return $code_departement;
572 
	}
 569 
	}
573 
 
 570 
 
574 
	protected function estUnCodeInseeDepartement($code_a_tester) {
 571 
	protected function estUnCodeInseeDepartement($code_a_tester) {
575 
		return preg_match('/^INSEE-C:(([0-9][0-9])|2A|2B)[0-9]{3}/i',$code_a_tester);
 572 
		return preg_match('/^INSEE-C:(([0-9][0-9])|2A|2B)[0-9]{3}/i',$code_a_tester);
576 
	}
 573 
	}
577 
 
 574 
 
578 
	protected function convertirCodeZoneGeoVersCodeInsee($code_zone_geo) {
 575 
	protected function convertirCodeZoneGeoVersCodeInsee($code_zone_geo) {
579 
		$code_departement = '';
 576 
		$code_departement = '';
580 
		if (self::estUnCodeInseeDepartement($code_zone_geo)) {
 577 
		if (self::estUnCodeInseeDepartement($code_zone_geo)) {
581 
			$code_departement = ltrim($code_zone_geo,'INSEE-C:');
 578 
			$code_departement = ltrim($code_zone_geo,'INSEE-C:');
582 
		}
 579 
		}
583 
		return $code_departement;
 580 
		return $code_departement;
584 
	}
 581 
	}
585 
 
 582 
 
586 
	static function obtenirCodeInseeCommunePourNomEtDepartement($nom_commune, $code_insee) {
 583 
	static function obtenirCodeInseeCommunePourNomEtDepartement($nom_commune, $code_insee) {
587 
		$nomCommuneP = Cel::db()->proteger($nom_commune);
 584 
		$nomCommuneP = Cel::db()->proteger($nom_commune);
588 
		$codeInseeP = Cel::db()->proteger("INSEE-C:$code_insee%");
 585 
		$codeInseeP = Cel::db()->proteger("INSEE-C:$code_insee%");
589 
		$requete = 'SELECT id_zone_geo '.
 586 
		$requete = 'SELECT id_zone_geo '.
590 
			'FROM cel_zones_geo '.
 587 
			'FROM cel_zones_geo '.
591 
			"WHERE nom LIKE $nomCommuneP AND id_zone_geo LIKE $codeInseeP ".
 588 
			"WHERE nom LIKE $nomCommuneP AND id_zone_geo LIKE $codeInseeP ".
592 
			' -- ' . __FILE__ . ':' . __LINE__;
 589 
			' -- ' . __FILE__ . ':' . __LINE__;
593 
		$resultat = Cel::db()->requeter($requete);
 590 
		$resultat = Cel::db()->requeter($requete);
594 
 
 591 
 
595 
		$infos = $code_insee; // Par défaut retourne l'original
 592 
		$infos = $code_insee; // Par défaut retourne l'original
596 
		if ($resultat && count($resultat)) {
 593 
		if ($resultat && count($resultat)) {
597 
			$infos = $resultat[0]['id_zone_geo'];
 594 
			$infos = $resultat[0]['id_zone_geo'];
598 
		}
 595 
		}
599 
		return $infos;
 596 
		return $infos;
600 
	}
 597 
	}
601
598
602 
	public function formaterZoneGeoEtCodePourAffichage($obs) {
 599 
	public function formaterZoneGeoEtCodePourAffichage($obs) {
603 
		$code_lieu = self::convertirCodeZoneGeoVersCodeInsee($obs['ce_zone_geo']);
 600 
		$code_lieu = self::convertirCodeZoneGeoVersCodeInsee($obs['ce_zone_geo']);
604 
		if(empty($code_lieu) && !empty($obs['pays'])) {
 601 
		if(empty($code_lieu) && !empty($obs['pays'])) {
605 
			$code_lieu = $obs['pays'];
 602 
			$code_lieu = $obs['pays'];
606 
		}
 603 
		}
607
604
608 
		if(!empty(trim($obs['zone_geo'])) && !empty(trim($code_lieu))) {
 605 
		if(!empty(trim($obs['zone_geo'])) && !empty(trim($code_lieu))) {
609 
			$code_lieu = ' ('.$code_lieu.') ';
 606 
			$code_lieu = ' ('.$code_lieu.') ';
610 
		}
607 
		}
611 
		return $obs['zone_geo'].$code_lieu;
 608 
		return $obs['zone_geo'].$code_lieu;
612 
	}
 609 
	}
613 
 
 610 
 
614 
	protected function encoderMotCle($mot_cle) {
 611 
	protected function encoderMotCle($mot_cle) {
615 
		return md5(mb_strtolower(trim($mot_cle)));
 612 
		return md5(mb_strtolower(trim($mot_cle)));
616 
	}
 613 
	}
617 
 
 614 
 
618 
	private function protegerMotsCles($mots_cles, $type) {
 615 
	private function protegerMotsCles($mots_cles, $type) {
619 
		$separateur = ($type == self::TYPE_IMG) ? ',' : ';' ;
 616 
		$separateur = ($type == self::TYPE_IMG) ? ',' : ';' ;
620 
		$mots_cles = $this->traiterValeursMultiples($mots_cles, $separateur);
 617 
		$mots_cles = $this->traiterValeursMultiples($mots_cles, $separateur);
621 
		return $mots_cles;
 618 
		return $mots_cles;
622 
	}
 619 
	}
623 
 
 620 
 
624 
	protected function traiterValeursMultiples($valeurs, $separateur_entree = ',' , $separateur_sortie = ',') {
 621 
	protected function traiterValeursMultiples($valeurs, $separateur_entree = ',' , $separateur_sortie = ',') {
625 
		if (! $this->etreNull($valeurs)) {
 622 
		if (! $this->etreNull($valeurs)) {
626 
			$valeurs_a_proteger = explode($separateur_entree,trim(trim($valeurs), $separateur_entree));
 623 
			$valeurs_a_proteger = explode($separateur_entree,trim(trim($valeurs), $separateur_entree));
627 
			foreach ($valeurs_a_proteger as $valeur) {
 624 
			foreach ($valeurs_a_proteger as $valeur) {
628 
				$valeurs_protegees[] = self::$bdd->quote($valeur);
 625 
				$valeurs_protegees[] = self::$bdd->quote($valeur);
629 
			}
 626 
			}
630 
			$valeurs = implode($separateur_sortie, $valeurs_protegees);
 627 
			$valeurs = implode($separateur_sortie, $valeurs_protegees);
631 
		}
 628 
		}
632 
		return ($this->etreNull($valeurs)) ? null : $valeurs;
 629 
		return ($this->etreNull($valeurs)) ? null : $valeurs;
633 
	}
 630 
	}
634 
 
 631 
 
635 
	protected function obtenirSousTaxonsPourNt($referentiel, $nt) {
 632 
	protected function obtenirSousTaxonsPourNt($referentiel, $nt) {
636 
		$sous_taxons = array();
 633 
		$sous_taxons = array();
637 
		// Certains référentiels n'ont pas de nt
 634 
		// Certains référentiels n'ont pas de nt
638 
		if(!empty($nt) && is_numeric($nt) && $nt > 0) {
 635 
		if(!empty($nt) && is_numeric($nt) && $nt > 0) {
639 
			$sous_taxons = $this->obtenirSousTaxons($referentiel, 'nt:'.$nt);
 636 
			$sous_taxons = $this->obtenirSousTaxons($referentiel, 'nt:'.$nt);
640 
		}
 637 
		}
641 
		return $sous_taxons;
 638 
		return $sous_taxons;
642 
	}
 639 
	}
643 
 
 640 
 
644 
	protected function obtenirSousTaxonsPourNn($referentiel, $nn) {
 641 
	protected function obtenirSousTaxonsPourNn($referentiel, $nn) {
645 
		return $this->obtenirSousTaxons($referentiel, $nn);
 642 
		return $this->obtenirSousTaxons($referentiel, $nn);
646 
	}
 643 
	}
647 
 
 644 
 
648 
	private function obtenirSousTaxons($referentiel, $requete) {
 645 
	private function obtenirSousTaxons($referentiel, $requete) {
649 
		$sous_taxons = array();
 646 
		$sous_taxons = array();
650 
		$url_service_taxon = str_replace('{referentiel}', $referentiel, $this->config['eflore']['url_service_taxon']);
 647 
		$url_service_taxon = str_replace('{referentiel}', $referentiel, $this->config['eflore']['url_service_taxon']);
651 
		$url = $url_service_taxon.'/'.$requete.'/relations/hierarchie';
 648 
		$url = $url_service_taxon.'/'.$requete.'/relations/hierarchie';
652 
		$res = json_decode(file_get_contents($url),true);
 649 
		$res = json_decode(file_get_contents($url),true);
653 
		if($res && !empty($res)) {
 650 
		if($res && !empty($res)) {
654 
			$sous_taxons = array_pop($res);
 651 
			$sous_taxons = array_pop($res);
655 
		}
 652 
		}
656 
		return $sous_taxons;
 653 
		return $sous_taxons;
657 
	}
 654 
	}
658 
 
 655 
 
659 
	protected function supprimerVersionDuReferentiel($referentiel) {
 656 
	protected function supprimerVersionDuReferentiel($referentiel) {
660 
		$referentiel_parties = explode(':', $referentiel);
 657 
		$referentiel_parties = explode(':', $referentiel);
661 
		$referentiel_parties = explode('_', $referentiel_parties[0]);
 658 
		$referentiel_parties = explode('_', $referentiel_parties[0]);
662 
		return $referentiel_parties[0];
 659 
		return $referentiel_parties[0];
663 
	}
 660 
	}
664 
 
 661 
 
665 
	protected function getUrlEflore($referentiel, $nn) {
 662 
	protected function getUrlEflore($referentiel, $nn) {
666 
		$urlEflore = null;
 663 
		$urlEflore = null;
667 
		if (! $this->etreNull($nn)) {
 664 
		if (! $this->etreNull($nn)) {
668 
			$code_referentiel = $this->supprimerVersionDuReferentiel($referentiel);
 665 
			$code_referentiel = $this->supprimerVersionDuReferentiel($referentiel);
669 
			if($code_referentiel == '') {
 666 
			if($code_referentiel == '') {
670 
				$code_referentiel = 'bdtfx';
 667 
				$code_referentiel = 'bdtfx';
671 
			}
 668 
			}
672 
			$urlEflore = sprintf($this->config['settings']['efloreUrlTpl'], $code_referentiel, $nn, 'illustration');
 669 
			$urlEflore = sprintf($this->config['settings']['efloreUrlTpl'], $code_referentiel, $nn, 'illustration');
673 
		}
 670 
		}
674 
		return $urlEflore;
 671 
		return $urlEflore;
675 
	}
 672 
	}
676 
 
 673 
 
677 
	protected function nePasInterpreterXml($txt) {
 674 
	protected function nePasInterpreterXml($txt) {
678 
		return '<![CDATA['.$txt.']]>';
 675 
		return '<![CDATA['.$txt.']]>';
679 
	}
 676 
	}
680 
 
 677 
 
681 
	//+----------------------------------------------------------------------------------------------------------------+
 678 
	//+----------------------------------------------------------------------------------------------------------------+
682 
	// GESTION DES SQUELETTES PHP
 679 
	// GESTION DES SQUELETTES PHP
683 
 
 680 
 
684 
	/**
 681 
	/**
685 
	 * Méthode prenant en paramètre un chemin de fichier squelette et un tableau associatif de données,
 682 
	 * Méthode prenant en paramètre un chemin de fichier squelette et un tableau associatif de données,
686 
	 * en extrait les variables, charge le squelette et retourne le résultat des deux combinés.
 683 
	 * en extrait les variables, charge le squelette et retourne le résultat des deux combinés.
687 
	 *
 684 
	 *
688 
	 * @param String $fichier	le chemin du fichier du squelette
 685 
	 * @param String $fichier	le chemin du fichier du squelette
689 
	 * @param Array  $donnees	un tableau associatif contenant les variables a injecter dans le squelette.
 686 
	 * @param Array  $donnees	un tableau associatif contenant les variables a injecter dans le squelette.
690 
	 *
 687 
	 *
691 
	 * @return boolean false si le squelette n'existe pas, sinon la chaine résultat.
 688 
	 * @return boolean false si le squelette n'existe pas, sinon la chaine résultat.
692 
	 */
 689 
	 */
693 
	public static function traiterSquelettePhp($fichier, Array $donnees = array()) {
 690 
	public static function traiterSquelettePhp($fichier, Array $donnees = array()) {
694 
		$sortie = false;
 691 
		$sortie = false;
695 
		if (file_exists($fichier)) {
 692 
		if (file_exists($fichier)) {
696 
			// Extraction des variables du tableau de données
 693 
			// Extraction des variables du tableau de données
697 
			extract($donnees);
 694 
			extract($donnees);
698 
			// Démarage de la bufferisation de sortie
 695 
			// Démarage de la bufferisation de sortie
699 
			ob_start();
 696 
			ob_start();
700 
			// Si les tags courts sont activés
 697 
			// Si les tags courts sont activés
701 
			if ((bool) @ini_get('short_open_tag') === true) {
 698 
			if ((bool) @ini_get('short_open_tag') === true) {
702 
				// Simple inclusion du squelette
 699 
				// Simple inclusion du squelette
703 
				include $fichier;
 700 
				include $fichier;
704 
			} else {
 701 
			} else {
705 
				// Sinon, remplacement des tags courts par la syntaxe classique avec echo
 702 
				// Sinon, remplacement des tags courts par la syntaxe classique avec echo
706 
				$html_et_code_php = self::traiterTagsCourts($fichier);
 703 
				$html_et_code_php = self::traiterTagsCourts($fichier);
707 
				// Pour évaluer du php mélangé dans du html il est nécessaire de fermer la balise php ouverte par eval
 704 
				// Pour évaluer du php mélangé dans du html il est nécessaire de fermer la balise php ouverte par eval
708 
				$html_et_code_php = '?>'.$html_et_code_php;
 705 
				$html_et_code_php = '?>'.$html_et_code_php;
709 
				// Interprétation du html et du php dans le buffer
 706 
				// Interprétation du html et du php dans le buffer
710 
				echo eval($html_et_code_php);
 707 
				echo eval($html_et_code_php);
711 
			}
 708 
			}
712 
			// Récupèration du contenu du buffer
 709 
			// Récupèration du contenu du buffer
713 
			$sortie = ob_get_contents();
 710 
			$sortie = ob_get_contents();
714 
			// Suppression du buffer
 711 
			// Suppression du buffer
715 
			@ob_end_clean();
 712 
			@ob_end_clean();
716 
		} else {
 713 
		} else {
717 
			$msg = "Le fichier du squelette '$fichier' n'existe pas.";
 714 
			$msg = "Le fichier du squelette '$fichier' n'existe pas.";
718 
			trigger_error($msg, E_USER_WARNING);
 715 
			trigger_error($msg, E_USER_WARNING);
719 
		}
 716 
		}
720 
		// Retourne le contenu
 717 
		// Retourne le contenu
721 
		return $sortie;
 718 
		return $sortie;
722 
	}
 719 
	}
723 
 
 720 
 
724 
	/**
 721 
	/**
725 
	 * Fonction chargeant le contenu du squelette et remplaçant les tags court php (<?= ...) par un tag long avec echo.
 722 
	 * Fonction chargeant le contenu du squelette et remplaçant les tags court php (<?= ...) par un tag long avec echo.
726 
	 *
 723 
	 *
727 
	 * @param String $chemin_squelette le chemin du fichier du squelette
 724 
	 * @param String $chemin_squelette le chemin du fichier du squelette
728 
	 *
 725 
	 *
729 
	 * @return string le contenu du fichier du squelette php avec les tags courts remplacés.
 726 
	 * @return string le contenu du fichier du squelette php avec les tags courts remplacés.
730 
	 */
 727 
	 */
731 
	private static function traiterTagsCourts($chemin_squelette) {
 728 
	private static function traiterTagsCourts($chemin_squelette) {
732 
		return file_get_contents($chemin_squelette);
 729 
		return file_get_contents($chemin_squelette);
733 
		// $contenu = file_get_contents($chemin_squelette);
 730 
		// $contenu = file_get_contents($chemin_squelette);
734 
		// // Remplacement de tags courts par un tag long avec echo
 731 
		// // Remplacement de tags courts par un tag long avec echo
735 
		// $contenu = str_replace('<?=', '<?php echo ',  $contenu);
 732 
		// $contenu = str_replace('<?=', '<?php echo ',  $contenu);
736 
		// // Ajout systématique d'un point virgule avant la fermeture php
 733 
		// // Ajout systématique d'un point virgule avant la fermeture php
737 
		/*$contenu = preg_replace("/;*\s*\?>/", "; ?>", $contenu);*/
 734 
		/*$contenu = preg_replace("/;*\s*\?>/", "; ?>", $contenu);*/
738 
		// return $contenu;
 735 
		// return $contenu;
739 
	}
 736 
	}
740 
}
 737 
}
741 
?>
 738 
?>