Subversion Repositories eFlore/Applications.cel

Rev

Rev 2806 | Rev 3138 | Go to most recent revision | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 2806 Rev 3131
Line 28... Line 28...
28
error_reporting(error_reporting() & ~E_STRICT);
28
error_reporting(error_reporting() & ~E_STRICT);
29
require_once 'lib/OLE.php';
29
require_once 'lib/OLE.php';
30
require_once 'lib/Spreadsheet/Excel/Writer.php';
30
require_once 'lib/Spreadsheet/Excel/Writer.php';
Line 31... Line 31...
31
 
31
 
32
class CelWidgetExport extends Cel {
32
class CelWidgetExport extends Cel {
33
 
33
	
34
	private $nom_fichier_export = 'cel_export';
34
	private $nom_fichier_export = 'cel_export';
35
	// certains paramètres apparaissent plusieurs fois car ils ont des alias
35
	// certains paramètres apparaissent plusieurs fois car ils ont des alias
36
	// dans certains widgets
36
	// dans certains widgets
37
	private $parametres_autorises = array(
37
	private $parametres_autorises = array(
38
		'id_utilisateur' => 'ce_utilisateur',
38
			'id_utilisateur' => 'ce_utilisateur',
39
		'utilisateur' => 'courriel_utilisateur',
39
			'utilisateur' => 'courriel_utilisateur',
40
		'courriel_utilisateur' => 'courriel_utilisateur',
40
			'courriel_utilisateur' => 'courriel_utilisateur',
41
		'pays' => 'pays',
41
			'pays' => 'pays',
42
		'commune' => 'zone_geo',
42
			'commune' => 'zone_geo',
43
		'zone_geo' => 'zone_geo',
43
			'zone_geo' => 'zone_geo',
44
		'dept' => 'departement',
44
			'dept' => 'departement',
45
		'departement' => 'departement',
45
			'departement' => 'departement',
46
		'lieudit' => 'lieudit',
46
			'lieudit' => 'lieudit',
47
		'station' => 'station',
47
			'station' => 'station',
-
 
48
			'projet' => 'mots_cles',
48
		'projet' => 'mots_cles',
49
			'programme' => 'programme',
49
		'num_taxon' => 'nt',
50
			'num_taxon' => 'nt',
50
		'date_debut' => 'date_debut',
51
			'date_debut' => 'date_debut',
51
		'date_fin' => 'date_fin',
52
			'date_fin' => 'date_fin',
-
 
53
			'taxon' => 'taxon',
-
 
54
			'identiplante' => 'validation_identiplante',
52
		'taxon' => 'taxon',
55
			'validation_identiplante' => 'validation_identiplante',
53
		'annee' => 'annee',
56
			'annee' => 'annee',
54
		'mois' => 'mois',
57
			'mois' => 'mois',
55
		'jour' => 'jour',
58
			'jour' => 'jour',
56
		'recherche' => 'recherche',
59
			'recherche' => 'recherche',
57
		'id_mots_cles' => 'id_mots_cles',
60
			'id_mots_cles' => 'id_mots_cles',
58
		'mots_cles' => 'mots_cles',
61
			'mots_cles' => 'mots_cles',
59
		'debut' => 'debut',
62
			'debut' => 'debut',
60
		'limite' => 'limite',
63
			'limite' => 'limite',
61
		'format' => 'format',
64
			'format' => 'format',
62
		'colonnes' => 'colonnes',
65
			'colonnes' => 'colonnes',
63
		'transmission' => 'transmission',
66
			'transmission' => 'transmission',
64
		'obsids' => 'obsids',
67
			'obsids' => 'obsids',
65
	);
68
	);
66
 
69
	
67
	private $limite_decoupage_defaut = 9000;
70
	private $limite_decoupage_defaut = 9000;
68
 
71
	
69
	private $format = 'csv';
72
	private $format = 'csv';
70
 
73
	
71
	public $id_utilisateur = null;
74
	public $id_utilisateur = null;
72
 
75
	
73
	public $export_prive = false;
76
	public $export_prive = false;
74
 
77
	
75
	// un cache, initialisé par certaines fonctions de préchargement, à la manière
78
	// un cache, initialisé par certaines fonctions de préchargement, à la manière
76
	// de ce qui est fait par FormateurGroupeColonne
79
	// de ce qui est fait par FormateurGroupeColonne
77
	static $cache = Array();
80
	static $cache = Array();
78
 
81
	
79
	public function getRessource() {
82
	public function getRessource() {
80
		return $this->getElement(array());
83
		return $this->getElement(array());
81
	}
84
	}
82
 
85
	
83
	/**
86
	/**
84
	 * Méthode appelée avec une requête de type GET.
87
	 * Méthode appelée avec une requête de type GET.
85
	 */
88
	 */
86
	public function getElement($params = array()) {
89
	public function getElement($params = array()) {
87
		switch(@strtolower($params[0])) {
90
		switch(@strtolower($params[0])) {
88
		case 'calcul':
91
			case 'calcul':
89
			$this->getCalcul();
92
				$this->getCalcul();
90
			break;
93
				break;
91
 
94
				
92
		case 'export':
95
			case 'export':
93
			$this->getExport();
96
				$this->getExport();
94
			break;
97
				break;
95
		default:
98
			default:
96
			$this->getExport();
99
				$this->getExport();
97
		}
100
		}
98
	}
101
	}
99
 
102
	
100
	private function getCalcul() {
103
	private function getCalcul() {
101
		$criteres = $this->traiterParametresAutorises($_GET);
104
		$criteres = $this->traiterParametresAutorises($_GET);
102
		$criteres['transmission'] = 1;
105
		$criteres['transmission'] = 1;
103
 
106
		
104
		// Définit si l'on exporte les obs privées ainsi que les champs étendus privés
107
		// Définit si l'on exporte les obs privées ainsi que les champs étendus privés
105
		$this->export_prive = $this->doitEtPeutExporterObsPrivees($criteres);
108
		$this->export_prive = $this->doitEtPeutExporterObsPrivees($criteres);
106
		if($this->export_prive) {
109
		if($this->export_prive) {
107
			unset($criteres['transmission']);
110
			unset($criteres['transmission']);
108
			$this->id_utilisateur = $criteres['id_utilisateur'];
111
			$this->id_utilisateur = $criteres['id_utilisateur'];
109
		}
112
		}
110
		$chercheur_observations = new RechercheObservation($this->config);
-
 
111
 
113
		$chercheur_observations = new RechercheObservationExport($this->config);
112
		$numero_page = isset($criteres['debut']) ? $criteres['debut'] : 0;
114
		$numero_page = isset($criteres['debut']) ? $criteres['debut'] : 0;
113
		$limite = isset($criteres['limite']) ? $criteres['limite'] : 0;
115
		$limite = isset($criteres['limite']) ? $criteres['limite'] : 0;
114
		$colonnes = @FormateurGroupeColonne::colGroupsValidation($criteres['colonnes']);
116
		$colonnes = @FormateurGroupeColonne::colGroupsValidation($criteres['colonnes']);
115
 
117
		
116
		unset($criteres['limite']);
118
		unset($criteres['limite']);
117
		unset($criteres['debut']);
119
		unset($criteres['debut']);
118
		unset($criteres['format']);
120
		unset($criteres['format']);
119
		unset($criteres['colonnes']);
121
		unset($criteres['colonnes']);
120
 
122
		
121
		$nb_observations = $chercheur_observations->compterObservations(null, $criteres);
123
		$nb_observations = $chercheur_observations->compterObservations(null, $criteres);
122
		$limite_decoupage = $this->calculerNbLignesMaxParFichier(explode(',', $colonnes));
124
		$limite_decoupage = $this->calculerNbLignesMaxParFichier(explode(',', $colonnes));
123
 
125
		
124
		$url_telechargements = array();
126
		$url_telechargements = array();
125
		$intervalle = 0;
127
		$intervalle = 0;
126
 
128
		
127
		$params_url = $criteres;
129
		$params_url = $criteres;
128
		unset($params_url['transmission']);
130
		unset($params_url['transmission']);
129
		do {
131
		do {
130
			$base_url = $this->config['settings']['baseURLAbsolu'].'CelWidgetExport/export';
132
			$base_url = $this->config['settings']['baseURLAbsolu'].'CelWidgetExport/export';
Line 133... Line 135...
133
			$url_telechargement_fichier = $base_url;
135
			$url_telechargement_fichier = $base_url;
134
			$url_telechargements[] = $base_url.'?'.http_build_query($params_url).'&format='.$this->format.'&colonnes='.$colonnes;
136
			$url_telechargements[] = $base_url.'?'.http_build_query($params_url).'&format='.$this->format.'&colonnes='.$colonnes;
135
			$intervalle += $limite_decoupage;
137
			$intervalle += $limite_decoupage;
136
			$nb_observations -= $limite_decoupage;
138
			$nb_observations -= $limite_decoupage;
137
		} while($nb_observations > 0);
139
		} while($nb_observations > 0);
138
 
140
		
139
		$this->envoyerJson($url_telechargements);
141
		$this->envoyerJson($url_telechargements);
140
	}
142
	}
141
 
143
	
142
	private function calculerNbLignesMaxParFichier($colonnes) {
144
	private function calculerNbLignesMaxParFichier($colonnes) {
143
		$limite = $this->limite_decoupage_defaut;
145
		$limite = $this->limite_decoupage_defaut;
144
 
146
		
145
		switch($this->format) {
147
		switch($this->format) {
146
			case 'csv':
148
			case 'csv':
147
				$limite = 20000;
149
				$limite = 20000;
148
				break;
150
				break;
149
			case 'xls':
151
			case 'xls':
Line 151... Line 153...
151
				break;
153
				break;
152
			case 'pdf':
154
			case 'pdf':
153
				$limite = 300;
155
				$limite = 300;
154
				break;
156
				break;
155
		}
157
		}
156
 
158
		
157
		return $limite;
159
		return $limite;
158
	}
160
	}
159
 
161
	
160
	private function getExport() {
162
	private function getExport() {
161
		$criteres = $this->traiterParametresAutorises($_GET);
163
		$criteres = $this->traiterParametresAutorises($_GET);
162
		// ne pas faire de super-requête en cas d'absence de paramètres
164
		// ne pas faire de super-requête en cas d'absence de paramètres
163
		// par exemple "format", au minimum, devrait être défini
165
		// par exemple "format", au minimum, devrait être défini
164
		if(!$criteres) die('erreur: pas de paramètre reçu');
166
		if(!$criteres) die('erreur: pas de paramètre reçu');
165
		if(!in_array($this->format, array('pdf','csv','xls'))) die('erreur: format invalide');
167
		if(!in_array($this->format, array('pdf','csv','xls'))) die('erreur: format invalide');
166
 
168
		
167
		$criteres['transmission'] = 1;
169
		//$criteres['transmission'] = 1;
168
		// Définit si l'on exporte les obs privées ainsi que les champs étendus privés
170
		// Définit si l'on exporte les obs privées ainsi que les champs étendus privés
169
		$this->export_prive = $this->doitEtPeutExporterObsPrivees($criteres);
171
		$this->export_prive = $this->doitEtPeutExporterObsPrivees($criteres);
170
		if($this->export_prive) {
172
		if($this->export_prive) {
171
			unset($criteres['transmission']);
173
			//unset($criteres['transmission']);
172
			$this->id_utilisateur = $criteres['ce_utilisateur'];
174
			$this->id_utilisateur = $criteres['ce_utilisateur'];
173
		}
175
		}
174
		$chercheur_observations = new RechercheObservation($this->config);
176
		$chercheur_observations = new RechercheObservationExport($this->config);
175
 
177
		
176
		$debut = isset($criteres['debut']) ? intval($criteres['debut']) : 0;
178
		$debut = isset($criteres['debut']) ? intval($criteres['debut']) : 0;
177
		$limite = isset($criteres['limite']) ? intval($criteres['limite']) : 0;
179
		$limite = isset($criteres['limite']) ? intval($criteres['limite']) : 0;
178
		$groupes = @FormateurGroupeColonne::colGroupsValidation($criteres['colonnes']);
180
		$groupes = @FormateurGroupeColonne::colGroupsValidation($criteres['colonnes']);
179
		$groupes .= ',auteur';
181
		$groupes .= ',auteur';
180
 
182
		
181
		if(!$groupes) die('erreur: Ne peut identifier les groupes de champs demandés.');
183
		if(!$groupes) die('erreur: Ne peut identifier les groupes de champs demandés.');
182
 
184
		
183
 
185
		
184
		if($criteres['obsids']) $criteres['sql_brut'] = sprintf('id_observation IN (%s)',
186
		if($criteres['obsids']) $criteres['sql_brut'] = sprintf('id_observation IN (%s)',
185
																implode(',', $criteres['obsids']));
187
				implode(',', $criteres['obsids']));
186
 
188
		
187
		unset($criteres['limite']);
189
		unset($criteres['limite']);
188
		unset($criteres['debut']);
190
		unset($criteres['debut']);
189
		unset($criteres['format']);
191
		unset($criteres['format']);
190
		unset($criteres['colonnes']);
192
		unset($criteres['colonnes']);
191
		unset($criteres['obsids']);
193
		unset($criteres['obsids']);
192
 
194
		
193
		$observations = $chercheur_observations->rechercherObservations(null, $criteres, $debut, $limite, TRUE)->get();
195
		$observations = $chercheur_observations->rechercherObservations(null, $criteres, $debut, $limite, TRUE)->get();
194
		$ids = array();
196
		$ids = array();
195
		foreach($observations as &$obs) {
197
		foreach($observations as &$obs) {
196
			$ids[] = $obs['id_observation'];
198
			$ids[] = $obs['id_observation'];
197
		}
199
		}
198
 
200
		
199
		if($this->format == 'pdf') {
201
		if($this->format == 'pdf') {
200
			$pdf = $this->convertirEnPdf($observations);
202
			$pdf = $this->convertirEnPdf($observations);
201
			$pdf->pdf->Output('etiquettes.pdf', 'I');
203
			$pdf->pdf->Output('etiquettes.pdf', 'I');
202
			exit;
204
			exit;
203
		}
205
		}
204
 
206
		
205
		// cas XLS et CSV: on peut avoir besoin des champs étendus, des noms communs et des champs baseflor:
207
		// cas XLS et CSV: on peut avoir besoin des champs étendus, des noms communs et des champs baseflor:
206
 
208
		
207
		// Obtention des colonnes correspondantes aux groupes de champs
209
		// Obtention des colonnes correspondantes aux groupes de champs
208
		$colonnes = FormateurGroupeColonne::nomEnsembleVersListeColonnes($groupes);
210
		$colonnes = FormateurGroupeColonne::nomEnsembleVersListeColonnes($groupes);
209
 
211
		
210
		/*
212
		/*
211
		  Champs étendus et noms communs, si demandés.
213
		 Champs étendus et noms communs, si demandés.
212
		  * Pour "nom commun", "preload" retourne NULL, car c'est le cache statique de FormateurGroupeColonne
214
		 * Pour "nom commun", "preload" retourne NULL, car c'est le cache statique de FormateurGroupeColonne
213
		  qu'il initialise et utilise en interne sans qu'un passage par paramètre dans le contexte de CelWidgetExport
215
		 qu'il initialise et utilise en interne sans qu'un passage par paramètre dans le contexte de CelWidgetExport
214
		  ne soit nécessaire.
216
		 ne soit nécessaire.
215
		  * Pour les champs étendus, c'est CelWidgetExport::$cache qui est utilisé, aussi bien pour les en-têtes que
217
		 * Pour les champs étendus, c'est CelWidgetExport::$cache qui est utilisé, aussi bien pour les en-têtes que
216
		  pour les données préchargées, cf self::traiterLigneEtendue()
218
		 pour les données préchargées, cf self::traiterLigneEtendue()
217
		*/
219
		 */
218
		self::$cache = FormateurGroupeColonne::preload($colonnes, $this, $ids);
220
		self::$cache = FormateurGroupeColonne::preload($colonnes, $this, $ids);
219
 
221
		
220
    	// TODO: tous les champs étendus et les paramètres supplémentaires devraient être passés en un seul
222
		// TODO: tous les champs étendus et les paramètres supplémentaires devraient être passés en un seul
221
    	// tableau (et chaque formateur csv, xls etc... pourrait également être dans une classe à part)
223
		// tableau (et chaque formateur csv, xls etc... pourrait également être dans une classe à part)
222
		switch($this->format) {
224
		switch($this->format) {
223
		case 'csv':
225
			case 'csv':
224
			$csv = $this->convertirEnCsv($observations, $colonnes);
226
				$csv = $this->convertirEnCsv($observations, $colonnes);
225
			$this->envoyerCsv($csv);
227
				$this->envoyerCsv($csv);
226
			break;
228
				break;
227
		case 'xls':
229
			case 'xls':
228
			$xls = $this->convertirEnXls($observations, $colonnes);
230
				$xls = $this->convertirEnXls($observations, $colonnes);
229
			$this->envoyerXls($xls);
231
				$this->envoyerXls($xls);
230
			break;
232
				break;
231
		default:
233
			default:
232
		}
234
		}
233
	}
235
	}
234
 
236
	
235
	protected function traiterParametresAutorises(Array $parametres) {
237
	protected function traiterParametresAutorises(Array $parametres) {
236
		$parametres_traites = array();
238
		$parametres_traites = array();
237
		$this->format = (isset($parametres['format']) && $parametres['format'] != '') ? $parametres['format'] : $this->format;
239
		$this->format = (isset($parametres['format']) && $parametres['format'] != '') ? $parametres['format'] : $this->format;
238
		foreach($parametres as $cle => $valeur) {
240
		foreach($parametres as $cle => $valeur) {
239
			if(is_string($valeur) && !trim($valeur)) continue;
241
			if(is_string($valeur) && !trim($valeur)) continue;
Line 242... Line 244...
242
			}
244
			}
243
		}
245
		}
244
		$parametres_traites['obsids'] = @self::traiterObsIds($parametres['obsids']);
246
		$parametres_traites['obsids'] = @self::traiterObsIds($parametres['obsids']);
245
		return $parametres_traites;
247
		return $parametres_traites;
246
	}
248
	}
247
 
249
	
248
	private function envoyerCsv($csv) {
250
	private function envoyerCsv($csv) {
249
		header('Content-Type: text/csv; charset=UTF-8');
251
		header('Content-Type: text/csv; charset=UTF-8');
250
		header('Content-Disposition: attachment;filename='.$this->nom_fichier_export.'.csv');
252
		header('Content-Disposition: attachment;filename='.$this->nom_fichier_export.'.csv');
251
		echo $csv;
253
		echo $csv;
252
		exit;
254
		exit;
253
	}
255
	}
254
 
256
	
255
	private function envoyerXls($workbook) {
257
	private function envoyerXls($workbook) {
256
		$workbook->close();
258
		$workbook->close();
257
		exit;
259
		exit;
258
	}
260
	}
259
 
261
	
260
	private function convertirEnCsv(&$data, $colonnes) {
262
	private function convertirEnCsv(&$data, $colonnes) {
261
		$chemin_temp = "php://temp";
263
		$chemin_temp = "php://temp";
262
		$outstream = fopen($chemin_temp, 'r+');
264
		$outstream = fopen($chemin_temp, 'r+');
263
 
265
		
264
		$intitule_champs = array_merge(FormateurGroupeColonne::getIntitulesColonnes($colonnes));
266
		$intitule_champs = array_merge(FormateurGroupeColonne::getIntitulesColonnes($colonnes));
265
		// en premier car utilisé génériquement dans getLigneObservation()
267
		// en premier car utilisé génériquement dans getLigneObservation()
266
		if(isset($colonnes['baseflor'])) {
268
		if(isset($colonnes['baseflor'])) {
267
			$intitule_champs = array_merge($intitule_champs, FormateurGroupeColonne::$baseflor_col);
269
			$intitule_champs = array_merge($intitule_champs, FormateurGroupeColonne::$baseflor_col);
268
		}
270
		}
269
		// en second car manuellement appellé plus bas, TODO: utiliser l'API du FormateurGroupeColonne
271
		// en second car manuellement appellé plus bas, TODO: utiliser l'API du FormateurGroupeColonne
270
		if(isset($colonnes['etendu'])) {
272
		if(isset($colonnes['etendu'])) {
271
			$intitule_champs = array_merge($intitule_champs, array_values(self::$cache['etendu']['header']));
273
			$intitule_champs = array_merge($intitule_champs, array_values(self::$cache['etendu']['header']));
272
		}
274
		}
273
 
275
		
274
		// header
276
		// header
275
		fputcsv($outstream, $intitule_champs, ',', '"');
277
		fputcsv($outstream, $intitule_champs, ',', '"');
276
		// lignes
278
		// lignes
277
		foreach($data as &$ligne) {
279
		foreach($data as &$ligne) {
278
			$ligne = self::filtrerDonneesSensibles($ligne);
280
			$ligne = self::filtrerDonneesSensibles($ligne);
Line 282... Line 284...
282
		rewind($outstream);
284
		rewind($outstream);
283
		$csv = stream_get_contents($outstream);
285
		$csv = stream_get_contents($outstream);
284
		fclose($outstream);
286
		fclose($outstream);
285
		return $csv;
287
		return $csv;
286
	}
288
	}
287
 
289
	
288
	private function convertirEnXls(&$data, $colonnes) {
290
	private function convertirEnXls(&$data, $colonnes) {
289
		$this->extendSpreadsheetProductor = new SpreadsheetProductor();
291
		$this->extendSpreadsheetProductor = new SpreadsheetProductor();
290
		$this->extendSpreadsheetProductor->initSpreadsheet();
292
		$this->extendSpreadsheetProductor->initSpreadsheet();
291
 
293
		
292
		$workbook = new Spreadsheet_Excel_Writer();
294
		$workbook = new Spreadsheet_Excel_Writer();
293
		// avant la définition du titre de la worksheet !
295
		// avant la définition du titre de la worksheet !
294
		$workbook->setVersion(8);
296
		$workbook->setVersion(8);
295
 
297
		
296
		$worksheet = $workbook->addWorksheet('Liste');
298
		$worksheet = $workbook->addWorksheet('Liste');
297
		$workbook->setTempDir($this->config['cel']['chemin_stockage_temp']);
299
		$workbook->setTempDir($this->config['cel']['chemin_stockage_temp']);
298
		$worksheet->setInputEncoding('utf-8');
300
		$worksheet->setInputEncoding('utf-8');
299
		$workbook->send($this->nom_fichier_export.'.xls');
301
		$workbook->send($this->nom_fichier_export.'.xls');
300
 
302
		
301
		$nb_lignes = 1;
303
		$nb_lignes = 1;
302
 
304
		
303
		$intitule_champs = array_merge(FormateurGroupeColonne::getIntitulesColonnes($colonnes));
305
		$intitule_champs = array_merge(FormateurGroupeColonne::getIntitulesColonnes($colonnes));
304
		// en premier car utilisé génériquement dans getLigneObservation()
306
		// en premier car utilisé génériquement dans getLigneObservation()
305
		if(isset($colonnes['baseflor'])) {
307
		if(isset($colonnes['baseflor'])) {
306
			$intitule_champs = array_merge($intitule_champs, FormateurGroupeColonne::$baseflor_col);
308
			$intitule_champs = array_merge($intitule_champs, FormateurGroupeColonne::$baseflor_col);
307
		}
309
		}
308
		// en second car manuellement appellé plus bas, TODO: utiliser l'API du FormateurGroupeColonne
310
		// en second car manuellement appellé plus bas, TODO: utiliser l'API du FormateurGroupeColonne
309
		if(isset($colonnes['etendu'])) {
311
		if(isset($colonnes['etendu'])) {
310
			$intitule_champs = array_merge($intitule_champs, array_values(self::$cache['etendu']['header']));
312
			$intitule_champs = array_merge($intitule_champs, array_values(self::$cache['etendu']['header']));
311
		}
313
		}
312
 
314
		
313
		// header
315
		// header
314
		$indice = 0;
316
		$indice = 0;
315
		foreach ($intitule_champs as &$intitule) {
317
		foreach ($intitule_champs as &$intitule) {
316
			$worksheet->write(0,$indice++,$intitule);
318
			$worksheet->write(0,$indice++,$intitule);
317
		}
319
		}
318
 
320
		
319
		foreach($data as &$ligne) {
321
		foreach($data as &$ligne) {
320
			$ligne = self::filtrerDonneesSensibles($ligne);
322
			$ligne = self::filtrerDonneesSensibles($ligne);
321
			$ligne = FormateurGroupeColonne::getLigneObservation($ligne, $colonnes, $this);
323
			$ligne = FormateurGroupeColonne::getLigneObservation($ligne, $colonnes, $this);
322
			$indice = 0;
324
			$indice = 0;
323
			foreach($ligne as &$champ) {
325
			foreach($ligne as &$champ) {
Line 325... Line 327...
325
			}
327
			}
326
			$nb_lignes++;
328
			$nb_lignes++;
327
		}
329
		}
328
		return $workbook;
330
		return $workbook;
329
	}
331
	}
330
 
332
	
331
	private function convertirEnPdf(&$observations) {
333
	private function convertirEnPdf(&$observations) {
332
		if(count($observations) > 300) die('erreur: trop de données');
334
		if(count($observations) > 300) die('erreur: trop de données');
333
		//require_once('GenerateurPDF.php');
335
		//require_once('GenerateurPDF.php');
334
		$pdf = new GenerateurPDF();
336
		$pdf = new GenerateurPDF();
335
		$pdf->export($observations);
337
		$pdf->export($observations);
336
		return $pdf;
338
		return $pdf;
337
	}
339
	}
338
 
340
	
339
	static function filtrerDonneesSensibles($ligne) {
341
	static function filtrerDonneesSensibles($ligne) {
340
		if(stripos($ligne['mots_cles_texte'], 'sensible') !== false) {
342
		if(stripos($ligne['mots_cles_texte'], 'sensible') !== false) {
341
			$ligne['latitude'] = '';
343
			$ligne['latitude'] = '';
342
			$ligne['longitude'] = '';
344
			$ligne['longitude'] = '';
343
		}
345
		}
344
		return $ligne;
346
		return $ligne;
345
	}
347
	}
346
 
348
	
347
	private function doitEtPeutExporterObsPrivees($criteres) {
349
	private function doitEtPeutExporterObsPrivees($criteres) {
348
		return isset($criteres['ce_utilisateur']) &&
350
		return isset($criteres['ce_utilisateur']) &&
349
					$this->peutExporterObsPrivees($criteres['ce_utilisateur']);
351
		$this->peutExporterObsPrivees($criteres['ce_utilisateur']);
350
	}
352
	}
351
 
353
	
352
	private function peutExporterObsPrivees($id_utilisateur) {
354
	private function peutExporterObsPrivees($id_utilisateur) {
353
		$gestion_utilisateur = new GestionUtilisateur($this->config);
355
		$gestion_utilisateur = new GestionUtilisateur($this->config);
354
		$utilisateur = $gestion_utilisateur->obtenirIdentiteConnectee();
356
		$utilisateur = $gestion_utilisateur->obtenirIdentiteConnectee();
355
		return ! empty($utilisateur['id_utilisateur']) && $id_utilisateur == $utilisateur['id_utilisateur'];
357
		return ! empty($utilisateur['id_utilisateur']) && $id_utilisateur == $utilisateur['id_utilisateur'];
356
	}
358
	}
357
 
359
	
358
	static function traiterObsIds($range_param) {
360
	static function traiterObsIds($range_param) {
359
		if (!isset($range_param)) return NULL;
361
		if (!isset($range_param)) return NULL;
360
		// trim() car: `POST http://url<<<"range=*"`
362
		// trim() car: `POST http://url<<<"range=*"`
361
		if (trim($range_param) == '*') return NULL;
363
		if (trim($range_param) == '*') return NULL;
362
		return self::rangeToList(trim($range_param));
364
		return self::rangeToList(trim($range_param));
363
	}
365
	}
364
 
366
	
365
	/*
367
	/*
366
	 * @param $fieldSets: un range, eg: 1-5,8,32,58-101
368
	 * @param $fieldSets: un range, eg: 1-5,8,32,58-101
367
	 * @return un tableau trié, eg: 1,2,3,4,5,8,32,58,...,101
369
	 * @return un tableau trié, eg: 1,2,3,4,5,8,32,58,...,101
368
	 * http://stackoverflow.com/questions/7698664/converting-a-range-or-partial-array-in-the-form-3-6-or-3-6-12-into-an-arra
370
	 * http://stackoverflow.com/questions/7698664/converting-a-range-or-partial-array-in-the-form-3-6-or-3-6-12-into-an-arra
369
	 */
371
	 */
370
	static function rangeToList($in = '') {
372
	static function rangeToList($in = '') {
371
		$inSets = explode(',', trim($in, ','));
373
		$inSets = explode(',', trim($in, ','));
372
		$outSets = array();
374
		$outSets = array();
373
 
375
		
374
		foreach($inSets as $inSet) {
376
		foreach($inSets as $inSet) {
375
			list($start,$end) = explode('-', $inSet . '-' . $inSet);
377
			list($start,$end) = explode('-', $inSet . '-' . $inSet);
376
			// ignore les ranges trop importants
378
			// ignore les ranges trop importants
377
			if($start > 10000000 || $end > 10000000 || abs($start-$end) > 10000) continue;
379
			if($start > 10000000 || $end > 10000000 || abs($start-$end) > 10000) continue;
378
			$outSets = array_merge($outSets,range($start,$end));
380
			$outSets = array_merge($outSets,range($start,$end));