Subversion Repositories eFlore/Applications.cel

Rev

Rev 2312 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
1654 aurelien 1
<?php
1656 raphael 2
 
3
/**
4
* @category  PHP
5
* @package   jrest
6
* @author    Raphaël Droz <raphael@tela-botania.org>
7
* @copyright 2013 Tela-Botanica
8
* @license   http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt Licence CECILL
9
* @license GPL v3 <http://www.gnu.org/licenses/gpl.txt>
10
*/
1759 raphael 11
define('SEPARATEUR_IMAGES', " / ");
1791 raphael 12
define('PREFIX_CHAMPS_ETENDUS', "ext:");
1835 raphael 13
// utilisé par formaterUrlUser() [ nécessaire pour le widget d'export)
14
define('USER_BASEURL', 'http://www.tela-botanica.org/profil:%d');
1656 raphael 15
 
1654 aurelien 16
Class FormateurGroupeColonne {
1656 raphael 17
 
1702 raphael 18
	// cache pour les données des fonctions
1656 raphael 19
	static $cache = Array();
20
 
1702 raphael 21
	// test sur la table cel_references, mis à TRUE si la table existe
22
	static $is_table = false;
23
 
1714 raphael 24
	// les groupes de champs utilisables
25
	static $fieldGroups = array(
26
		'standard',
27
		'avance',
28
		'etendu',
1835 raphael 29
		'baseflor',
30
		'auteur'
1714 raphael 31
	);
32
 
1702 raphael 33
	// les données baseflor à récupérer: colonnes présentes dans cel_references
34
	// et intitulés associés
35
	static $baseflor_col = array(
36
		"ve_lumiere" => "Lumière",
37
		"ve_temperature" => "Température",
38
		"ve_continentalite" => "Continentalité",
39
		"ve_humidite_atmos" => "Humidité Atmosphérique",
40
		"ve_humidite_edaph" => "Humidité",
41
		"ve_reaction_sol" => "Réaction (pH)",
42
		"ve_nutriments_sol" => "Nutriments",
43
		"ve_salinite" => "Salinité",
44
		"ve_texture_sol" => "Texture" ,
45
		"ve_mat_org_sol" => "Matière Organique",
46
		"catminat_code" => "Code Catminat",
47
		"syntaxon" => "Syntaxon",
48
	);
49
 
1741 raphael 50
	// TODO: dirty, ordre des champs étendus... souhaité pour florilèges:
51
	static $ordre_champ_etendus_Florileges = array(
52
		"personneStructure",
53
		"personneService",
54
		"personneFonction",
55
		"adresse",
56
		"latitudeDebutRue",
57
		"longitudeDebutRue",
58
		"latitudeFinRue",
59
		"longitudeFinRue",
60
		"typoUrbaine",
61
		"revetementSol",
62
		"presenceZoneVegetalise",
63
		"hauteurBatimentAvoisinant",
64
		"intensiteGestion",
65
		"periodiciteTraitementPhyto",
66
		"dateArretTraitementPhyto",
67
		"itineraireGestion",
68
		"dateDerniereIntervention",
69
		"hauteurPlante",
70
		"resistanceTraitementPhyto",
71
		"vitesseCroissance",
72
		"perceptionTechnicien",
73
		"perceptionRiverainMauvaise",
74
	);
75
 
1714 raphael 76
	static function colGroupsValidation($groupe_de_champs = 'standard,avance') {
77
		if(! $groupe_de_champs) return FALSE;
78
		if(is_string($groupe_de_champs)) {
79
			$groupe_de_champs = array_flip(explode(',', $groupe_de_champs));
80
		}
81
		elseif(is_array($groupe_de_champs)) {
82
			$groupe_de_champs = array_flip($groupe_de_champs);
83
		}
84
		else {
85
			return NULL;
86
		}
87
		$groupe_de_champs = array_intersect_key(array_flip(self::$fieldGroups),
88
												$groupe_de_champs);
89
		if(!$groupe_de_champs) return FALSE;
90
		// toujours ajouter standard
91
		$groupe_de_champs['standard'] = TRUE;
92
		return implode(',', array_keys($groupe_de_champs));
93
	}
94
 
1654 aurelien 95
	/*
96
	* @param $fieldSets: un liste de noms de colonnes ou de sets de colonnes
97
	*		séparés par des virgules
98
	* 		eg: "espece" ou "champs-etendus", ...
99
	*
100
	* @return: un tableau associatif déjà ordonné
101
	* 		clé: abbrev [machine-name] de la colonne (eg: "espece" ou "mot-clef")
102
	* 		valeur: des données relative à cette colonne, cf GenColInfo
103
	*
1757 raphael 104
	* Si la colonne n'utilise pas de fonction de récupération particulière
105
	* (ie: si le champ exportés [ou importé] correspond exactement au champ dans la base de donnée)
106
	* Alors 'abbrev' doit avoir la même valeur que le nom de la colonne dans la table mysql `cel_obs`.
1654 aurelien 107
	*
108
	*/
109
	static function nomEnsembleVersListeColonnes($groupe_de_champs = 'standard') {
110
		if(! $groupe_de_champs) $groupe_de_champs = 'standard';
1711 raphael 111
		if(is_string($groupe_de_champs)) {
112
			$groupe_de_champs = array_flip(explode(',', $groupe_de_champs));
113
		}
114
		elseif(is_array($groupe_de_champs)) {
115
			$groupe_de_champs = array_flip($groupe_de_champs);
116
		}
117
		else {
118
			return NULL;
119
		}
1714 raphael 120
		$groupe_de_champs = array_intersect_key(array_flip(self::$fieldGroups),
1711 raphael 121
												$groupe_de_champs);
122
		if(!$groupe_de_champs) return NULL;
123
 
1656 raphael 124
		$colonnes = Array();
2143 jpm 125
 
1654 aurelien 126
		if(isset($groupe_de_champs['standard'])) {
127
			$colonnes += Array(
1757 raphael 128
				'nom_sel'			=> self::GenColInfo(Array('abbrev' => 'nom_sel',
129
															  'nom' => 'Espèce')),
130
				'nom_sel_nn'		=> self::GenColInfo(Array('abbrev' => 'nom_sel_nn',
131
															  'nom' => 'Numéro nomenclatural',
132
															  'importable' => FALSE)),
133
				'nom_ret'			=> self::GenColInfo(Array('abbrev' => 'nom_ret',
134
															  'nom' => 'Nom retenu',
135
															  'importable' => FALSE)),
136
				'nom_ret_nn'		=> self::GenColInfo(Array('abbrev' => 'nom_ret_nn',
137
															  'nom' => 'Numéro nomenclatural nom retenu',
138
															  'importable' => FALSE)),
139
				'nt'				=> self::GenColInfo(Array('abbrev' => 'nt',
140
															  'nom' => 'Numéro taxonomique',
141
															  'importable' => FALSE)),
142
				'famille'			=> self::GenColInfo(Array('abbrev' => 'famille',
143
															  'nom' => 'Famille',
144
															  'importable' => FALSE)),
145
				'nom_referentiel'	=> self::GenColInfo(Array('abbrev' => 'nom_referentiel',
146
															  'nom' => 'Referentiel taxonomique')),
147
				'zone_geo'			=> self::GenColInfo(Array('abbrev' => 'zone_geo',
148
															  'nom' => 'Commune')),
149
				'ce_zone_geo'		=> self::GenColInfo(Array('abbrev' => 'ce_zone_geo',
150
															  'nom' => 'Identifiant Commune',
151
															  'fonction' => 'convertirCodeZoneGeoVersDepartement')),
152
				'date_observation'	=> self::GenColInfo(Array('abbrev' => 'date_observation',
153
															  'nom' => 'Date',
154
															  'fonction' => 'formaterDate')),
155
				'lieudit'			=> self::GenColInfo(Array('abbrev' => 'lieudit',
156
															  'nom' => 'Lieu-dit')),
157
				'station'			=> self::GenColInfo(Array('abbrev' => 'station',
158
															  'nom' => 'Station')),
159
				'milieu'			=> self::GenColInfo(Array('abbrev' => 'milieu',
160
															  'nom' => 'Milieu')),
161
				'commentaire'		=> self::GenColInfo(Array('abbrev' => 'commentaire',
162
															  'nom' => 'Notes')),
163
				'latitude'			=> self::GenColInfo(Array('abbrev' => 'latitude',
164
															  'nom' => 'Latitude',
165
															  'extra' => 1,
166
															  'fonction' => 'trim0')),
167
				'longitude'			=> self::GenColInfo(Array('abbrev' => 'longitude',
168
															  'nom' => 'Longitude',
169
															  'extra' => 1,
170
															  'fonction' => 'trim0')),
171
				'altitude'			=> self::GenColInfo(Array('abbrev' => 'altitude',
172
															  'nom' => 'Altitude',
1816 raphael 173
															  'extra' => 1)), // pas de trim0 car INT(5) en DB
1757 raphael 174
				'geodatum'			=> self::GenColInfo(Array('abbrev' => 'geodatum',
175
															  'nom' => 'Référentiel Géographique',
176
															  'extra' => 1,
177
															  'importable' => FALSE)),
1654 aurelien 178
			);
179
		}
2143 jpm 180
 
1654 aurelien 181
		if(isset($groupe_de_champs['avance'])) {
1656 raphael 182
			$colonnes += array(
1757 raphael 183
				// TODO: importable = FALSE car pas de merge de données importées
184
				'ordre'				=> self::GenColInfo(Array('abbrev' => 'ordre',
185
															  'nom' => 'Ordre',
186
															  'extra' => 1,
187
															  'importable' => FALSE)),
188
				'id_observation'	=> self::GenColInfo(Array('abbrev' => 'id_observation',
189
															  'nom' => 'Identifiant',
190
															  'extra' => 1,
191
															  'importable' => FALSE)),
1656 raphael 192
 
1757 raphael 193
				'mots_cles_texte'	=> self::GenColInfo(Array('abbrev' => 'mots_cles_texte',
194
															  'nom' => 'Mots Clés',
195
															  'extra' => 1)),
196
				'date_creation'		=> self::GenColInfo(Array('abbrev' => 'date_creation',
197
															  'nom' => 'Date Création',
198
															  'extra' => 1,
199
															  'importable' => FALSE)),
200
				'date_modification'	=> self::GenColInfo(Array('abbrev' => 'date_modification',
201
															  'nom' => 'Date Modification',
202
															  'extra' => 1,
203
															  'importable' => FALSE)),
1656 raphael 204
 
1757 raphael 205
				// rappel transmission = 1, signifie simplement "public"
206
				// des données importées peuvent être d'emblée "publiques"
207
				// "importable" = TRUE
208
				'transmission'		=> self::GenColInfo(Array('abbrev' => 'transmission',
209
															  'nom' => 'Transmis',
210
															  'extra' => 1,
211
															  'fonction' => 'boolOuiNon')),
212
				'date_transmission'	=> self::GenColInfo(Array('abbrev' => 'date_transmission',
213
															  'nom' => 'Date Transmission',
214
															  'extra' => 1,
215
															  'importable' => FALSE)),
216
				'abondance'			=> self::GenColInfo(Array('abbrev' => 'abondance',
217
															  'nom' => 'Abondance',
218
															  'extra' => 1)),
219
				'certitude'			=> self::GenColInfo(Array('abbrev' => 'certitude',
220
															  'nom' => 'Certitude',
221
															  'extra' => 1)),
222
				'phenologie'		=> self::GenColInfo(Array('abbrev' => 'phenologie',
223
															  'nom' => 'Phénologie',
224
															  'extra' => 1)),
2143 jpm 225
 
1757 raphael 226
				// XXX: getImages() dépend du contexte de Cel, et doit être appelée comme cas particulier
227
				// cf ExportXLS::traiterLigneObservation()
228
				'images'			=> self::GenColInfo(Array('abbrev' => 'images',
229
															  'nom' => 'Image(s)',
230
															  'extra' => 1,
231
															  'fonction_data' => NULL /* cas particulier 'getImages' */,
232
															  'importable' => TRUE,
233
															  //'preload' => array(__CLASS__, 'getImages_preload')//TODO
234
				)),
1656 raphael 235
 
1757 raphael 236
				/* 'nom_commun'			=> self::GenColInfo(Array('abbrev' => 'nom_commun',
237
				   'nom' => 'Nom Commun',
238
				   'extra' => 1,
239
				   'fonction_data' => 'getNomCommun',
240
				   'importable' => FALSE),
1685 raphael 241
 
1757 raphael 242
				   'nom-commun'			=> self::GenColInfo(Array('abbrev' => 'nom-commun',
243
				   'nom' => 'Nom Commun',
244
				   'extra' => 1,
245
				   'fonction_data' => 'getNomCommun_v2'),
246
 
247
				   'nom-commun'			=> self::GenColInfo(Array('abbrev' => 'nom-commun',
248
				   'nom' => 'Nom Commun',
249
				   'extra' => 1,
250
				   'fonction_data' => 'getNomCommun_v3'),
251
				   'importable' => FALSE), */
252
				'nom-commun'		=> self::GenColInfo(Array('abbrev' => 'nom-commun',
253
															  'nom' => 'Nom Commun',
254
															  'extra' => 1,
255
															  'fonction_data' => NULL /* cas particu 'getNomCommun_v4' */,
256
															  'preload' => array(__CLASS__, 'getNomCommun_preload')))
1702 raphael 257
			);
258
		}
1685 raphael 259
 
1702 raphael 260
		if(isset($groupe_de_champs['baseflor'])) {
261
			$colonnes += array(
262
				// champ dynamique
1757 raphael 263
				'baseflor'			=> self::GenColInfo(Array('abbrev' => 'baseflor',
264
															  'nom' => '',
265
															  'extra' => 1,
266
															  'importable' => FALSE,
267
															  'preload' => array(__CLASS__, 'baseflor_preload'),
268
															  'dyna' => array(__CLASS__, 'baseflor_ligne'))),
1654 aurelien 269
			);
1702 raphael 270
		}
1656 raphael 271
 
1714 raphael 272
		if(isset($groupe_de_champs['etendu'])) {
273
			$colonnes += array(
274
				// champ dynamique
1757 raphael 275
				'etendu'			=> self::GenColInfo(Array('abbrev' => 'etendu',
276
															  'nom' => '',
277
															  'extra' => 1,
278
															  'importable' => FALSE,
279
															  'preload' => array(__CLASS__, 'champsEtendus_preload'),
280
															  'dyna' => array(__CLASS__, 'champsEtendus_ligne'))),
1714 raphael 281
			);
282
		}
1835 raphael 283
 
284
		if(isset($groupe_de_champs['auteur'])) {
285
			$colonnes += array(
286
				'observateur'	=> self::GenColInfo(Array('abbrev' => 'observateur',
287
														  'nom' => 'Observateur',
288
														  'extra' => 1,
289
														  'fonction_data' => 'formaterUrlUser',
290
														  'importable' => FALSE)),
291
			);
292
		}
293
 
1654 aurelien 294
		return $colonnes;
295
	}
1694 raphael 296
 
297
	static function preload($colonnes, $cel, $ids) {
298
		$result = array();
299
		foreach($colonnes as $abbrev => $colonne) {
300
			if(!$colonne['preload']) continue;
1702 raphael 301
			$result[$abbrev] = call_user_func($colonne['preload'], $cel, $ids);
1694 raphael 302
		}
303
		return $result;
304
	}
2143 jpm 305
 
1656 raphael 306
	public static function getIntitulesColonnes($colonnes) {
1702 raphael 307
		// array_filter pour supprimer les colonnes "dynamique" n'ayant pas défini $nom (cf GenColInfo())
308
		return array_filter(array_map(array('FormateurGroupeColonne', 'retournerNomItem'), $colonnes));
1654 aurelien 309
	}
2143 jpm 310
 
1671 aurelien 311
	public static function retournerNomItem(&$item) {
312
		return $item['nom'];
313
	}
1694 raphael 314
 
1656 raphael 315
	public static function getLigneObservation(&$obs, &$colonnes, $cel = false) {
1654 aurelien 316
		$ligne_formatee = array();
317
		foreach($colonnes as $abbrev => $colonne) {
318
			$valeur = null;
1702 raphael 319
			if($colonne['extra'] == 2 || ! is_null($colonne['dyna'])) continue;
2143 jpm 320
 
1835 raphael 321
			// valeur directe depuis cel_obs ?
1654 aurelien 322
			if(isset($obs[$abbrev])) $valeur = $obs[$abbrev];
2143 jpm 323
 
1835 raphael 324
			// pré-processeur des champs
1654 aurelien 325
			if(function_exists($colonne['fonction'])) {
326
				$valeur = $colonne['fonction']($valeur);
327
			} elseif(method_exists(__CLASS__, $colonne['fonction'])) {
328
				$valeur = call_user_func(array(__CLASS__, $colonne['fonction']), $valeur);
329
			} elseif($colonne['fonction']) {
330
				die("méthode {$colonne['fonction']} introuvable");
331
			}
332
			// fonction pour obtenir des champs (étendus)
333
			elseif(function_exists($colonne['fonction_data'])) {
334
				$valeur = $colonne['fonction_data']($obs);
335
			}
1687 raphael 336
			elseif(method_exists(__CLASS__, $colonne['fonction_data'])) {
1654 aurelien 337
				$valeur = call_user_func(array(__CLASS__, $colonne['fonction_data']), $obs);
338
			}
2143 jpm 339
 
1654 aurelien 340
			// // cette section devrait être vide:
341
			// // cas particuliers ingérable avec l'architecture actuelle:
342
			if(false && $abbrev == 'date_observation' && $valeur == "0000-00-00") {
343
				/* blah */
344
			}
1765 raphael 345
			// ici à cause du passage de $cel ($this->utilisateur)
1656 raphael 346
			if($abbrev == 'images') {
1765 raphael 347
				$valeur = FormateurGroupeColonne::getImages($obs, $cel->id_utilisateur);
1656 raphael 348
			}
1685 raphael 349
			if($abbrev == 'nom-commun') {
1765 raphael 350
				$valeur = FormateurGroupeColonne::getNomCommun_v4($obs);
1685 raphael 351
			}
2143 jpm 352
 
1654 aurelien 353
			if($valeur == null) {
354
				$valeur = "";
355
			}
2143 jpm 356
 
1654 aurelien 357
			// // fin de section "cas particuliers"
358
			$ligne_formatee[] = $valeur;
359
		}
1694 raphael 360
 
1835 raphael 361
		// uniquement les champs dynamiques
1702 raphael 362
		foreach($colonnes as $abbrev => $colonne) {
363
			$valeur = null;
364
			if(is_null($colonne['dyna'])) continue;
1706 raphael 365
			// XXX: PHP-5.3
366
			call_user_func_array($colonne['dyna'],
1765 raphael 367
								 array($obs, &$ligne_formatee));
1702 raphael 368
		}
1694 raphael 369
 
1654 aurelien 370
		return $ligne_formatee;
371
	}
2143 jpm 372
 
1654 aurelien 373
	/*
374
	* Wrapper générant un tableau associatif:
1694 raphael 375
	* Ne pas changer les valeurs par défaut du prototype sans réflexion sur l'implication pour nomEnsembleVersListeColonnes()
2143 jpm 376
 
1654 aurelien 377
	* @param $abbrev (obligatoire): nom court de colonne, largement utilisé lors de l'import.
378
	*		  En effet chaque ligne importée est accessible à l'aide du `define` de $abbrev en majuscule, préfixé de "C_"
379
	*		  Exemple: $ligne[C_LONGITUDE] pour "longitude".
380
	*		  cf: ImportXLS::detectionEntete()
2143 jpm 381
 
1654 aurelien 382
	* @param $nom (obligatoire): nom complet de colonne (utilisé pour la ligne d'en-tête)
1702 raphael 383
	*		  Les définition de champs dynamique (correspondant à de multiples colonnes) doivent laisser cette valeur
384
	*		  vide afin de ne pas créer une colonne supplémentaire erronée.
2143 jpm 385
 
1654 aurelien 386
	* @param $is_extra:
387
	* Si 0, la colonne est une colonne standard
388
	* Si 1, la colonne est extra [le plus souvent générée automatiquement]
389
	*		 (auquel cas une bordure bleue entoure son nom dans la ligne d'entête)
390
	* Si 2, la colonne n'est pas traité à l'export, mais une définition peut lui être donnée
391
	*		 qui pourra être utilisée à l'import, exemple: "image"
2143 jpm 392
 
1654 aurelien 393
	* @param $fonction (optionnel): un nom d'un fonction de préprocessing
394
	* 		  $fonction doit prendre comme seul argument la valeur d'origine et retourner la valeur transformée
2143 jpm 395
 
1654 aurelien 396
	* @param $fonction_data (optionnel): une *méthode* d'obtention de donnée
397
	* 		  $fonction_data doit prendre comme premier argument le tableau des champs de l'enregistrement existant
398
	*		  $fonction_data doit retourner une valeur
2143 jpm 399
 
1654 aurelien 400
	* @param $importable (optionnel): défini si la colonne est traitée (ou absolument ignorée par PHPExcel) lors de
401
	*		  l'import.
1694 raphael 402
 
403
	* @param $preload (optionnel): défini une fonction de préchargement massif de donnée potentiellement utilisable par $fonction_data.
404
	*		  Utile, notamment, dans le cadre de l'export
1702 raphael 405
 
406
	* @param $fonction_dynamique (optionnel): défini une fonction ajoutant un nombre arbitraire de colonnes à une ligne donnée
407
	*		  Utile, notamment, dans le cadre de l'export des champs étendus ou des données baseflor
408
	*		  La fonction doit TOUJOURS alterer la ligne en lui ajoutant une nombre CONSTANT d'éléments (NULL ou non)
1765 raphael 409
	*		  La fonction doit prendre comme arguments ($obs, &$ligne_formatee)
1654 aurelien 410
	*/
1757 raphael 411
	static function GenColInfo($args) {
412
		$default = Array('abbrev' => NULL,
413
						 'nom' => NULL,
414
						 'extra' => 0,
415
						 'fonction' => NULL,
416
						 'fonction_data' => NULL,
417
						 'importable' => TRUE,
418
						 'preload' => NULL,
419
						 'dyna' => NULL);
420
		$ret = array_intersect_key($args, $default);
421
		return array_merge($default, $ret);
1654 aurelien 422
	}
2143 jpm 423
 
1656 raphael 424
	static function formaterDate($date_heure_mysql) {
1671 aurelien 425
		//return "";
1707 raphael 426
		if (!$date_heure_mysql || $date_heure_mysql == "0000-00-00 00:00:00") return NULL;
1671 aurelien 427
		// malheureusement pas disponible en php < 5.3
428
		//$date_format = DateTime::createFromFormat("Y-m-d H:i:s", $date_heure_mysql);
429
		$val = explode(' ', $date_heure_mysql);
430
		$date = explode('-', $val[0]);
431
		$heure = explode(':', $val[1]);
432
		$timestamp = mktime((int) $heure[0], (int) $heure[1], (int) $heure[2], (int) $date[1], (int) $date[2], (int) $date[0]);
1707 raphael 433
		if(!$timestamp) return NULL;
1656 raphael 434
		// TODO: les widgets ne font malheureusement pas usage de l'heure dans le CEL
435
		// TODO: si modification, ne pas oublier de modifier le format d'import correspondant
1698 raphael 436
		//	dans ImportXLS, traiterDateObs() (actuellement: "Y/m/d" car utilisation de strtotime() qui ne lit pas tout)
437
		// $date_formatee = strftime('%d/%m/%Y', $timestamp);
438
		$date_formatee = strftime('%Y/%m/%d', $timestamp);
1654 aurelien 439
		if(!$date_formatee) return "00/00/0000";
440
		return $date_formatee;
441
	}
1757 raphael 442
 
1835 raphael 443
	static function formaterUrlUser($obs) {
444
		$is_id = is_numeric($obs['ce_utilisateur']);
445
		return sprintf("%s %s <%s>%s",
446
					   $obs['prenom_utilisateur'],
447
					   $obs['nom_utilisateur'],
448
					   preg_replace(';@.*;', '@...', $obs['courriel_utilisateur']),
449
					   $is_id ? sprintf(' (' . USER_BASEURL . ')', $obs['ce_utilisateur']) : '');
450
	}
451
 
1759 raphael 452
	static function getImages_preload($cel, $obsids) {
453
		if(!$obsids) return;
1766 raphael 454
		$rec = Cel::db()->requeter(
1759 raphael 455
			sprintf("SELECT o.id_observation, GROUP_CONCAT(nom_original ORDER BY nom_original ASC SEPARATOR '%s') AS i " .
456
					"FROM cel_images i LEFT JOIN cel_obs_images oi ON (i.id_image = oi.id_image) LEFT JOIN cel_obs o ON (oi.id_observation = o.id_observation) " .
457
					"WHERE o.ce_utilisateur = %d AND o.id_observation IN (%s) " .
458
					"GROUP BY id_observation",
459
					SEPARATEUR_IMAGES,
460
					$cel->id_utilisateur,
461
					implode(',', $obsids)));
462
		foreach($rec as $v) {
463
			self::$cache['getImages'][$v['id_observation']] = $v['i'];
464
		}
465
		return NULL;
466
	}
467
 
1765 raphael 468
	static function getImages($obs, $id_utilisateur) {
1656 raphael 469
		if(! $id_utilisateur) return NULL;
1759 raphael 470
		if(isset(self::$cache['getImages'][$obs['id_observation']]))
471
			return self::$cache['getImages'][$obs['id_observation']];
472
 
1765 raphael 473
		$rec = Cel::db()->requeter(
1759 raphael 474
			sprintf("SELECT GROUP_CONCAT(nom_original ORDER BY nom_original ASC SEPARATOR '%s') AS i FROM cel_images i"
1656 raphael 475
					." LEFT JOIN cel_obs_images oi ON (i.id_image = oi.id_image)"
476
					." LEFT JOIN cel_obs o ON (oi.id_observation = o.id_observation)"
1757 raphael 477
					." WHERE o.ce_utilisateur = %d AND o.id_observation = %d LIMIT 1",
1656 raphael 478
					SEPARATEUR_IMAGES,
1757 raphael 479
					$id_utilisateur,
480
					$obs['id_observation']));
481
		return $rec ? $rec[0]['i'] : NULL;
1654 aurelien 482
	}
2143 jpm 483
 
484
	public static function convertirCodeZoneGeoVersDepartement($code_zone_geo) {
1654 aurelien 485
		$code_departement = '';
486
		if(self::estUnCodeInseeDepartement($code_zone_geo)) {
487
			$code_departement = substr(ltrim($code_zone_geo,'INSEE-C:'),0,2);
488
		}
2143 jpm 489
 
1654 aurelien 490
		return $code_departement;
491
	}
1757 raphael 492
 
493
	public static function trim0($lonlat) {
494
		return trim(trim($lonlat, "0"), ".");
495
	}
496
 
497
	public static function boolOuiNon($transmission) {
498
		return $transmission ? 'oui' : '';
499
	}
2143 jpm 500
 
1654 aurelien 501
	public static function estUnCodeInseeDepartement($code_a_tester) {
502
		return preg_match('/^INSEE-C:[0-9]{5}/',$code_a_tester);
503
	}
2143 jpm 504
 
505
 
1654 aurelien 506
	// TODO: référentiel ne devrait pas être généré au moment d'un Config::get,
507
	// comme dans Config::get('nomsVernaRechercheLimiteeTpl')
508
	// Par exemple, la variable pour "nva" ?
509
	function getNomCommun($obs) {
510
		$langue = 'fra';
511
		list($referentiel) = explode(':', strtolower($obs['nom_referentiel']));
512
		if($referentiel == 'bdtfx') $referentiel = 'nvjfl';
513
		else return '';
2143 jpm 514
 
1654 aurelien 515
		$cache_id = $referentiel . '-' . $obs['nt'] . '-' . $langue;
1657 raphael 516
		if(isset(self::$cache['getNomCommun'][$cache_id])) {
1656 raphael 517
			//debug: error_log("require url_service_nom_attribution: OK ! (pour \"{$obs['nom_ret']}\")");
1657 raphael 518
			return self::$cache['getNomCommun'][$cache_id];
1654 aurelien 519
		}
520
		// pas de cache:
521
		//debug: error_log("require url_service_nom_attribution pour \"{$obs['nom_ret']}\"");
2143 jpm 522
 
1654 aurelien 523
		// pour bdtfx:
524
		// /service:eflore:0.1/nvjfl/noms-vernaculaires/attributions?masque.nt=X&masque.lg=fra&retour.champs=num_statut
525
		// /projet/services/modules/0.1/nvjfl/NomsVernaculaires.php
526
		$url = str_replace(Array('{referentiel}', '{valeur}', '{langue}'),
1656 raphael 527
						   Array($referentiel, $obs['nt'], $langue),
1657 raphael 528
						   self::$config['eflore']['url_service_nom_attribution']) . // TODO !
1656 raphael 529
			"&retour.champs=num_statut";
1654 aurelien 530
		$noms = @json_decode(file_get_contents($url));
531
		if(! $noms) return '';
1673 raphael 532
		$noms = array_filter((array)($noms->resultat), array($this, retournerNumStatutUn)); // XXX: php 5.3
1654 aurelien 533
		$nom = array_pop($noms)->nom_vernaculaire;
2143 jpm 534
 
1654 aurelien 535
		// cache
1657 raphael 536
		self::$cache['getNomCommun'][$cache_id] = $nom;
1654 aurelien 537
		return $nom;
538
	}
2143 jpm 539
 
1671 aurelien 540
	private function retournerNumStatutUn(&$item) {
541
		return ($item->num_statut == 1);
542
	}
1673 raphael 543
 
544
	private function retournerNumStatutUnArr(&$item) {
545
		return ($item['num_statut'] == 1);
546
	}
2143 jpm 547
 
1656 raphael 548
	// si getNomCommun_v2 ou getNomCommun_v3 sont utilisés
549
	/* require_once('/home/raphael/eflore/framework/framework/Framework.php');
550
	Framework::setCheminAppli("/home/raphael/eflore/projets/services/index.php");
551
	Framework::setInfoAppli(Config::get('info'));
552
	require_once('/home/raphael/eflore/projets/services/modules/0.1/Projets.php');*/
2143 jpm 553
 
1654 aurelien 554
	/* Tente de bootstraper le framework au plus court et d'initialiser une instance de
1656 raphael 555
	   NomsVernaculaires pour obtenir le nom commun */
1654 aurelien 556
	function getNomCommun_v2($obs) {
557
		static $service;
1656 raphael 558
		$service = new Projets();
2143 jpm 559
 
1654 aurelien 560
		$langue = 'fra';
561
		list($referentiel) = explode(':', strtolower($obs['nom_referentiel']));
562
		if($referentiel == 'bdtfx') $referentiel = 'nvjfl';
563
		else return '';
2143 jpm 564
 
1654 aurelien 565
		$cache_id = $referentiel . '-' . $obs['nt'] . '-' . $langue;
1657 raphael 566
		if(isset(self::$cache['getNomCommun'][$cache_id])) {
1656 raphael 567
			error_log("require NomsVernaculaires.php: OK ! (pour \"{$obs['nom_ret']}\")");
1657 raphael 568
			return self::$cache['getNomCommun'][$cache_id];
1654 aurelien 569
		}
570
		// pas de cache:
571
		error_log("require NomsVernaculaires.php pour \"{$obs['nom_ret']}\"");
2143 jpm 572
 
1656 raphael 573
		$donnees = Array('masque.nt' => $obs['nt'],
574
						 'masque.lg' => $langue,
575
						 'retour.champs' => 'num_statut');
1654 aurelien 576
		$noms = $service->consulter(Array('nvjfl', 'noms-vernaculaires'), $donnees);
2143 jpm 577
 
1654 aurelien 578
		if(! $noms) return '';
1673 raphael 579
		$noms = array_filter((array)($noms->resultat), array($this, retournerNumStatutUn)); // XXX: php 5.3
1654 aurelien 580
		$nom = array_pop($noms)->nom_vernaculaire;
2143 jpm 581
 
1656 raphael 582
		// cache
1657 raphael 583
		self::$cache['getNomCommun'][$cache_id] = $nom;
1654 aurelien 584
		return $nom;
585
	}
2143 jpm 586
 
587
 
1654 aurelien 588
	/* Effectue un bootstraping plus sage que ci-dessus, mais le gain d'efficacité
1656 raphael 589
	   n'est pas aussi retentissant qu'espéré */
1654 aurelien 590
	static $service;
591
	function getNomCommun_v3($obs) {
592
		if(! $this->service) $this->service = new Projets();
2143 jpm 593
 
1654 aurelien 594
		$langue = 'fra';
595
		list($referentiel) = explode(':', strtolower($obs['nom_referentiel']));
596
		if($referentiel == 'bdtfx') $referentiel = 'nvjfl';
597
		else return '';
2143 jpm 598
 
1654 aurelien 599
		$cache_id = $referentiel . '-' . $obs['nt'] . '-' . $langue;
1657 raphael 600
		if(isset(self::$cache['getNomCommun'][$cache_id])) {
1656 raphael 601
			error_log("require NomsVernaculaires.php: OK ! (pour \"{$obs['nom_ret']}\")");
1657 raphael 602
			return self::$cache['getNomCommun'][$cache_id];
1654 aurelien 603
		}
604
		// pas de cache:
1656 raphael 605
		error_log("require NomsVernaculaires.php pour \"{$obs['nom_ret']}\"");
2143 jpm 606
 
1654 aurelien 607
		$donnees = Array('masque.nt' => $obs['nt'],
1656 raphael 608
						 'masque.lg' => $langue,
609
						 'retour.champs' => 'conseil_emploi');
610
		$this->service->initialiserRessourcesEtParametres(Array('nvjfl', 'noms-vernaculaires', 'attributions'), $donnees);
1654 aurelien 611
		try {
1656 raphael 612
			$noms = $this->service->traiterRessources();
2143 jpm 613
		} catch(Exception $e) {
1656 raphael 614
			return '';
1654 aurelien 615
		}
1656 raphael 616
		if(! $noms) return '';
1673 raphael 617
		$noms = array_filter($noms['resultat'], array($this, retournerNumStatutUnArr)); // XXX: php 5.3
1656 raphael 618
		$premier_nom = array_pop($noms);
1654 aurelien 619
		$nom = $premier_nom['nom_vernaculaire'];
2143 jpm 620
 
1654 aurelien 621
		// cache
1657 raphael 622
		self::$cache['getNomCommun'][$cache_id] = $nom;
1654 aurelien 623
		return $nom;
624
	}
1685 raphael 625
 
1694 raphael 626
	/* Cette fonction initialise le cache des noms communs en 1 fois, sur la liste des observations à exporter.
1702 raphael 627
	   Ainsi, les appels successifs à getNomCommun_v4() ne sont pas couteux (pas de requête SQL) */
1694 raphael 628
	static function getNomCommun_preload($cel, $obsids) {
629
		if(!$obsids) return;
1765 raphael 630
		if(!self::referenceTableExiste()) return NULL;
1694 raphael 631
 
632
		// CREATE INDEX i_nom_referentiel ON cel_obs (nom_referentiel(5));
633
		$req = sprintf("SELECT r.referentiel, r.num_taxon, r.nom_commun FROM cel_references r" .
634
					   " INNER JOIN cel_obs c ON (r.referentiel = substring_index(c.nom_referentiel, ':', 1) and r.num_taxon = c.nt)" .
635
					   " WHERE c.id_observation IN (%s)",
636
					   implode(',', $obsids));
1765 raphael 637
		$res = Cel::db()->requeter($req);
1694 raphael 638
		foreach($res as $v) {
639
			self::$cache['getNomCommun'][$v['referentiel'] . '-' . $v['num_taxon'] . '-' . 'fra'] = $v['nom_commun'];
640
		}
641
		return NULL;
642
	}
1702 raphael 643
 
1765 raphael 644
	static function referenceTableExiste() {
2143 jpm 645
		if (!self::$is_table) {
1702 raphael 646
			// une seule fois
2143 jpm 647
			if (! Cel::db()->requeterLigne("SHOW TABLES LIKE 'cel_references'")) return FALSE;
1702 raphael 648
			self::$is_table = TRUE;
649
		}
650
		return TRUE;
651
	}
2143 jpm 652
 
1765 raphael 653
	static function getNomCommun_v4($obs) {
2281 aurelien 654
		// Attention la fonction suppose que l'on ait fait appel à getNomCommun_preload avant
655
		// d'être appelée
1685 raphael 656
		if(! $obs['nt']) return NULL;
1765 raphael 657
		if(! self::referenceTableExiste()) return NULL;
1689 raphael 658
 
1685 raphael 659
		$langue = 'fra';
660
		list($referentiel) = explode(':', strtolower($obs['nom_referentiel']));
661
		$cache_id = $referentiel . '-' . $obs['nt'] . '-' . $langue;
662
 
2281 aurelien 663
		$nom = null;
1757 raphael 664
		// cache:
2281 aurelien 665
		if(isset(self::$cache['getNomCommun'])) {
1757 raphael 666
			if(isset(self::$cache['getNomCommun'][$cache_id])) return self::$cache['getNomCommun'][$cache_id];
667
			// XXX: problème de valeurs NULL ?
2281 aurelien 668
			if(array_key_exists($cache_id, self::$cache['getNomCommun'])) {
669
				$nom = self::$cache['getNomCommun'][$cache_id];
670
			}
1757 raphael 671
		}
1685 raphael 672
 
673
		return $nom;
674
	}
1702 raphael 675
 
676
 
677
	/* Cette fonction initialise le cache des données baseflor en 1 fois, sur la liste des observations à exporter.
678
	   Ainsi, les appels successifs à baseflor_ligne() ne sont pas couteux (pas de requête SQL) */
679
	static function baseflor_preload($cel, $obsids) {
680
		if(!$obsids) return;
1765 raphael 681
		if(!self::referenceTableExiste()) return NULL;
1702 raphael 682
 
2254 aurelien 683
		// Attention (en attendant de faire une meilleure table et une meilleure requete) le distinct est très important
684
		$req = sprintf("SELECT DISTINCT referentiel, num_nom_retenu, %s FROM cel_references r" .
2297 mathias 685
						" INNER JOIN cel_obs c ON (r.num_nom_retenu = c.nom_ret_nn)" .
686
						" AND r.referentiel = IF(LOCATE(':', c.nom_referentiel) = 0, c.nom_referentiel, SUBSTR(c.nom_referentiel FROM 1 FOR LOCATE(':', c.nom_referentiel) - 1))" .
687
						" WHERE c.id_observation IN (%s)",
688
						//" AND catminat_code IS NOT NULL", // TODO: suppression des NULL ici signifie que le cache sera partiel...
689
						implode(',', array_keys(self::$baseflor_col)),
690
						implode(',', $obsids));
1765 raphael 691
		$res = Cel::db()->requeter($req);
1706 raphael 692
		if(!$res) return NULL;
1702 raphael 693
 
694
		foreach($res as $v) {
695
			$data = $v;
696
			unset($data['referentiel']); // non nécessaire
697
			unset($data['num_nom_retenu']); // non nécessaire
2244 aurelien 698
 
699
			// Des fois les synonymes ont des valeurs pour baseflor et pas le nom retenu et vice versa
700
			// on les fusionne pour avoir le maximum d'infos, en attendant de repenser la table référence
701
			if(isset(self::$cache['getBaseflor'][$v['referentiel'] . '-' . $v['num_nom_retenu']])) {
2245 aurelien 702
				$orig  = array_filter(self::$cache['getBaseflor'][$v['referentiel'] . '-' . $v['num_nom_retenu']], 'strlen');
703
				$data  = array_filter($data , 'strlen');
2244 aurelien 704
				$data = array_merge($orig, $data);
705
			}
706
 
1702 raphael 707
			self::$cache['getBaseflor'][$v['referentiel'] . '-' . $v['num_nom_retenu']] = $data;
708
		}
709
 
710
		return NULL;
711
	}
1685 raphael 712
 
2312 mathias 713
	/**
714
	 * Attention la fonction suppose que l'on ait fait appel à baseflor_preload avant
715
	 * d'être appelée
716
	 * @CASSECOUILLES elle pourrait le détecter et le faire elle-même
717
	 */
1765 raphael 718
	static function baseflor_ligne($obs, &$ligne) {
2312 mathias 719
		$clefsBF = array_keys(self::$baseflor_col);
720
		// par défaut des colonnes vides pour ne pas décaler le bousin
721
		$donneesBF = array_fill_keys($clefsBF, "");
1702 raphael 722
 
2312 mathias 723
		// s'il y a des données baseflor
724
		if ($obs['nom_ret_nn'] && self::referenceTableExiste() && count(self::$cache['getBaseflor']) > 0) {
725
			// l'astuce à un franc vingt
726
			list($referentiel) = explode(':', strtolower($obs['nom_referentiel']));
727
			$cache_id = $referentiel . '-' . $obs['nom_ret_nn'];
1702 raphael 728
 
2312 mathias 729
			// si les données baseflor existent dans le cache pour ce nom_ret_nn
730
			if (array_key_exists($cache_id, self::$cache['getBaseflor'])) {
731
				$donneesBFATrous = self::$cache['getBaseflor'][$cache_id];
732
				foreach($clefsBF as $colbf) { // remplit les trous tout en préservant l'ordre
733
					if(array_key_exists($colbf, $donneesBFATrous)) {
734
						$donneesBF[$colbf] = $donneesBFATrous[$colbf];
735
					} else {
736
						$donneesBF[$colbf] = "";
737
					}
738
				}
739
			}
1702 raphael 740
		}
2312 mathias 741
 
742
		// Quand les données sont prêtes, on les fusionne
743
		$ligne = array_merge($ligne, $donneesBF);
1702 raphael 744
	}
1715 raphael 745
 
746
	static function champsEtendus_preload($cel, $obsids) {
747
		$gestion_champs_etendus = new GestionChampsEtendus($cel->config, 'obs');
1718 raphael 748
		$colonnes_champs_supp_par_obs = $gestion_champs_etendus->consulterClesParLots($obsids);
1741 raphael 749
		// ces deux lignes réordonnent l'ordre des colonnes des champs étendus en fonction de l'ordre (très spécifique)
750
		// de self::$ordre_champ_etendus_Florileges, les champs non-mentionnés sont ajoutés à la fin.
751
		$colonnes_champs_supp_par_obs = self::sortArrayByArray(array_flip($colonnes_champs_supp_par_obs),
752
															   self::$ordre_champ_etendus_Florileges);
753
		$colonnes_champs_supp_par_obs = array_keys($colonnes_champs_supp_par_obs);
754
 
1718 raphael 755
		// si le SELECT des clefs ne retourne rien, une autre requêtes est inutile
756
		// TODO: optimize, 1 seule requête
757
		if(!$colonnes_champs_supp_par_obs) return Array('header' => array(), 'data' => array());
758
 
1715 raphael 759
		$champs_supp_par_obs = $gestion_champs_etendus->consulterParLots($obsids);
1741 raphael 760
 
1791 raphael 761
		self::$cache['champsEtendus']['header'] = self::champsEtendus_prefixHeader($colonnes_champs_supp_par_obs);
762
 
1715 raphael 763
		foreach($champs_supp_par_obs as &$v) {
764
			$v = self::champsEtendus_aplatir($v);
765
		}
766
		self::$cache['champsEtendus']['data'] = $champs_supp_par_obs;
767
		// ce return est temporaire,
768
		// le temps que toutes les fonctions bougent ici et utilise plutôt le cache statique
1716 raphael 769
		// encore utilisé pour les entêtes (self::$cache['champsEtendus']['header'])
1715 raphael 770
		return self::$cache['champsEtendus'];
771
	}
772
 
773
	// XXX: PHP-5.3, fonction anonyme + array_map
1791 raphael 774
	static function champsEtendus_prefixHeader($array) {
775
		return array_map(create_function('$v', 'return "' . PREFIX_CHAMPS_ETENDUS . '".$v;'), $array);
776
	}
777
 
778
	// XXX: PHP-5.3, fonction anonyme + array_map
1715 raphael 779
	static function champsEtendus_aplatir($ligne_champs_etendus) {
780
		$champs_etendus_fmt = array();
781
		if(!$ligne_champs_etendus) return $champs_etendus_fmt;
782
		foreach($ligne_champs_etendus as $champ) {
1791 raphael 783
			$champs_etendus_fmt[PREFIX_CHAMPS_ETENDUS . $champ->cle] = $champ->valeur;
1715 raphael 784
		}
785
		return $champs_etendus_fmt;
786
	}
1716 raphael 787
 
1765 raphael 788
	static function champsEtendus_ligne($obs, &$ligne) {
1716 raphael 789
		// si header n'est pas défini, aucune observation ne possède de champ étendu
790
		// et nous n'ajoutons ni colonnes, ni valeurs.
791
		if(! isset(self::$cache['champsEtendus']['header'])) return;
1736 raphael 792
		$ligne_etendue_aplatie = @self::$cache['champsEtendus']['data'][$obs['id_observation']];
1716 raphael 793
 
794
		$ligne_supp = array_fill(0, count(self::$cache['champsEtendus']['header']), '');
795
		$ligne_etendue_fmt = array();
796
 
797
		// si, cependant cette seule observation n'a pas de champs étendus,
798
		// nous devons rajouter des blancs (notamment dans le cas ou d'autres
799
		// champs viennent à être ajoutés en aval à l'avenir
800
		// cf: $fonction_dynamique dans FormateurGroupeColonne::GenColInfo()
801
		if(! $ligne_etendue_aplatie) {
802
			$ligne = array_merge($ligne, $ligne_supp);
803
			return;
804
		}
805
 
806
		foreach(self::$cache['champsEtendus']['header'] as $colonne) {
807
			if(!isset($ligne_etendue_aplatie[$colonne])) {
2143 jpm 808
				$ligne_etendue_fmt[$colonne] = '';
1716 raphael 809
			} else {
810
				$ligne_etendue_fmt[$colonne] = $ligne_etendue_aplatie[$colonne];
811
			}
812
		}
813
 
814
		// XXX/ array_merge() ?
815
		$ligne += $ligne_etendue_fmt;
816
	}
1741 raphael 817
 
818
	/* HELPERS */
819
 
820
	// http://stackoverflow.com/questions/348410/sort-an-array-based-on-another-array
821
	// XXX; redéfinition, utilisé aussi par ExportXLS
822
	static function sortArrayByArray($array, $orderArray) {
823
		$ordered = array();
824
		foreach($orderArray as $key) {
825
			if(array_key_exists($key, $array)) {
826
				$ordered[$key] = $array[$key];
827
				unset($array[$key]);
828
			}
829
		}
830
		return $ordered + $array;
831
	}
832
 
1715 raphael 833
}