Subversion Repositories eFlore/Applications.cel

Rev

Rev 1714 | Rev 1716 | Go to most recent revision | Only display areas with differences | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

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