Subversion Repositories eFlore/Applications.cel

Rev

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

Rev 1715 Rev 1716
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 
 
 65 
 
66 
	// un cache, initialisé par certaines fonctions de préchargement, à la manière
 66 
	// un cache, initialisé par certaines fonctions de préchargement, à la manière
67 
	// de ce qui est fait par FormateurGroupeColonne
 67 
	// de ce qui est fait par FormateurGroupeColonne
68 
	static $cache = Array();
 68 
	static $cache = Array();
69
69
70 
	public function getRessource() {
 70 
	public function getRessource() {
71 
		return $this->getElement(array());
 71 
		return $this->getElement(array());
72 
	}
 72 
	}
73
73
74 
	/**
 74 
	/**
75 
	 * Méthode appelée avec une requête de type GET.
 75 
	 * Méthode appelée avec une requête de type GET.
76 
	 */
 76 
	 */
77 
	public function getElement($params = array()) {
 77 
	public function getElement($params = array()) {
78 
		switch(@strtolower($params[0])) {
 78 
		switch(@strtolower($params[0])) {
79 
		case 'calcul':
 79 
		case 'calcul':
80 
			$this->getCalcul();
 80 
			$this->getCalcul();
81 
			break;
 81 
			break;
82
82
83 
		case 'export':
 83 
		case 'export':
84 
			$this->getExport();
 84 
			$this->getExport();
85 
			break;
 85 
			break;
86 
		default:
 86 
		default:
87 
			$this->getExport();
 87 
			$this->getExport();
88 
		}
 88 
		}
89 
	}
 89 
	}
90
90
91 
	private function getCalcul() {
 91 
	private function getCalcul() {
92 
		$criteres = $this->traiterParametresAutorises($_GET);
 92 
		$criteres = $this->traiterParametresAutorises($_GET);
93 
 
 93 
 
94 
		$criteres['transmission'] = 1;
 94 
		$criteres['transmission'] = 1;
95 
		if($this->doitEtPeutExporterObsPrivees($criteres)) {
 95 
		if($this->doitEtPeutExporterObsPrivees($criteres)) {
96 
			unset($criteres['transmission']);
 96 
			unset($criteres['transmission']);
97 
			$this->id_utilisateur = $criteres['id_utilisateur'];
 97 
			$this->id_utilisateur = $criteres['id_utilisateur'];
98 
		}
 98 
		}
99 
		$chercheur_observations = new RechercheObservation($this->config);
 99 
		$chercheur_observations = new RechercheObservation($this->config);
100
100
101 
		$numero_page = isset($criteres['debut']) ? $criteres['debut'] : 0;
 101 
		$numero_page = isset($criteres['debut']) ? $criteres['debut'] : 0;
102 
		$limite = isset($criteres['limite']) ? $criteres['limite'] : 0;
 102 
		$limite = isset($criteres['limite']) ? $criteres['limite'] : 0;
103 
		$colonnes = @FormateurGroupeColonne::colGroupsValidation($criteres['colonnes']);
 103 
		$colonnes = @FormateurGroupeColonne::colGroupsValidation($criteres['colonnes']);
104
104
105 
		unset($criteres['limite']);
 105 
		unset($criteres['limite']);
106 
		unset($criteres['debut']);
 106 
		unset($criteres['debut']);
107 
		unset($criteres['format']);
 107 
		unset($criteres['format']);
108 
		unset($criteres['colonnes']);
 108 
		unset($criteres['colonnes']);
109
109
110 
		$nb_observations = $chercheur_observations->compterObservations(null, $criteres);
 110 
		$nb_observations = $chercheur_observations->compterObservations(null, $criteres);
111 
		$limite_decoupage = $this->calculerNbLignesMaxParFichier();
 111 
		$limite_decoupage = $this->calculerNbLignesMaxParFichier();
112
112
113 
		$url_telechargements = array();
 113 
		$url_telechargements = array();
114 
		$intervalle = 0;
 114 
		$intervalle = 0;
115
115
116 
		$params_url = $criteres;
 116 
		$params_url = $criteres;
117 
		unset($params_url['transmission']);
 117 
		unset($params_url['transmission']);
118 
		do {
 118 
		do {
119 
			$base_url = $this->config['settings']['baseURLAbsolu'].'CelWidgetExport/export';
 119 
			$base_url = $this->config['settings']['baseURLAbsolu'].'CelWidgetExport/export';
120 
			$params_url['debut'] = $intervalle;
 120 
			$params_url['debut'] = $intervalle;
121 
			$params_url['limite'] = $limite_decoupage;
 121 
			$params_url['limite'] = $limite_decoupage;
122 
			$url_telechargement_fichier = $base_url;
 122 
			$url_telechargement_fichier = $base_url;
123 
			$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;
124 
			$intervalle += $limite_decoupage;
 124 
			$intervalle += $limite_decoupage;
125 
			$nb_observations -= $limite_decoupage;
 125 
			$nb_observations -= $limite_decoupage;
126 
		} while($nb_observations >= $limite_decoupage);
 126 
		} while($nb_observations >= $limite_decoupage);
127
127
128 
		$this->envoyerJson($url_telechargements);
 128 
		$this->envoyerJson($url_telechargements);
129 
	}
 129 
	}
130
130
131 
	private function calculerNbLignesMaxParFichier() {
 131 
	private function calculerNbLignesMaxParFichier() {
132 
		$limite = $this->limite_decoupage_defaut;
 132 
		$limite = $this->limite_decoupage_defaut;
133 
		switch($this->format) {
 133 
		switch($this->format) {
134 
			case 'csv':
 134 
			case 'csv':
135 
				$limite = 20000;
 135 
				$limite = 20000;
136 
				break;
 136 
				break;
137 
			case 'xls':
 137 
			case 'xls':
138 
				$limite = 8000;
 138 
				$limite = 8000;
139 
				break;
 139 
				break;
140 
			case 'pdf':
 140 
			case 'pdf':
141 
				$limite = 300;
 141 
				$limite = 300;
142 
				break;
 142 
				break;
143 
		}
 143 
		}
144 
		return $limite;
 144 
		return $limite;
145 
	}
 145 
	}
146
146
147 
	private function getExport() {
 147 
	private function getExport() {
148 
		$criteres = $this->traiterParametresAutorises($_GET);
 148 
		$criteres = $this->traiterParametresAutorises($_GET);
149 
		// 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
150 
		// par exemple "format", au minimum, devrait être défini
 150 
		// par exemple "format", au minimum, devrait être défini
151 
		if(!$criteres) die('erreur: 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');
 152 
		if(!in_array($this->format, array('pdf','csv','xls'))) die('erreur: format invalide');
153 
 
 153 
 
154 
		$criteres['transmission'] = 1;
 154 
		$criteres['transmission'] = 1;
155 
		if($this->doitEtPeutExporterObsPrivees($criteres)) {
 155 
		if($this->doitEtPeutExporterObsPrivees($criteres)) {
156 
			unset($criteres['transmission']);
 156 
			unset($criteres['transmission']);
157 
		}
 157 
		}
158 
		$chercheur_observations = new RechercheObservation($this->config);
 158 
		$chercheur_observations = new RechercheObservation($this->config);
159
159
160 
		$debut = isset($criteres['debut']) ? intval($criteres['debut']) : 0;
 160 
		$debut = isset($criteres['debut']) ? intval($criteres['debut']) : 0;
161 
		$limite = isset($criteres['limite']) ? intval($criteres['limite']) : 0;
 161 
		$limite = isset($criteres['limite']) ? intval($criteres['limite']) : 0;
162 
		$groupes = @FormateurGroupeColonne::colGroupsValidation($criteres['colonnes']);
 162 
		$groupes = @FormateurGroupeColonne::colGroupsValidation($criteres['colonnes']);
163 
		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.');
164 
 
 164 
 
165 
 
 165 
 
166 
		if($criteres['obsids']) $criteres['sql_brut'] = sprintf('id_observation IN (%s)',
 166 
		if($criteres['obsids']) $criteres['sql_brut'] = sprintf('id_observation IN (%s)',
167 
																implode(',', $criteres['obsids']));
 167 
																implode(',', $criteres['obsids']));
168
168
169 
		unset($criteres['limite']);
 169 
		unset($criteres['limite']);
170 
		unset($criteres['debut']);
 170 
		unset($criteres['debut']);
171 
		unset($criteres['format']);
 171 
		unset($criteres['format']);
172 
		unset($criteres['colonnes']);
 172 
		unset($criteres['colonnes']);
173 
		unset($criteres['obsids']);
 173 
		unset($criteres['obsids']);
174 
 
 174 
 
175 
		$observations = $chercheur_observations->rechercherObservations(null, $criteres, $debut, $limite, TRUE)->get();
 175 
		$observations = $chercheur_observations->rechercherObservations(null, $criteres, $debut, $limite, TRUE)->get();
176 
		$ids = array();
 176 
		$ids = array();
177 
		foreach($observations as &$obs) {
 177 
		foreach($observations as &$obs) {
178 
			$ids[] = $obs['id_observation'];
 178 
			$ids[] = $obs['id_observation'];
179 
		}
 179 
		}
180 
 
 180 
 
181 
		if($this->format == 'pdf') {
 181 
		if($this->format == 'pdf') {
182 
			$pdf = $this->convertirEnPdf($observations);
 182 
			$pdf = $this->convertirEnPdf($observations);
183 
			$pdf->pdf->Output('etiquettes.pdf', 'I');
 183 
			$pdf->pdf->Output('etiquettes.pdf', 'I');
184 
			exit;
 184 
			exit;
185 
		}
 185 
		}
186 
 
 186 
 
187 
		// 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 
 
 188 
 
189 
		// Obtention des colonnes correspondantes aux groupes de champs
 189 
		// Obtention des colonnes correspondantes aux groupes de champs
190 
		$colonnes = FormateurGroupeColonne::nomEnsembleVersListeColonnes($groupes);
 190 
		$colonnes = FormateurGroupeColonne::nomEnsembleVersListeColonnes($groupes);
191 
 
 191 
 
192 
		/*
 192 
		/*
193 
		  Champs étendus et noms communs, 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
 194 
		  * Pour "nom commun", "preload" retourne NULL, car c'est le cache statique de FormateurGroupeColonne
195 
		  qu'il initialise et utilise en interne sans qu'un passage par paramètre dans le contexte de CelWidgetExport
 195 
		  qu'il initialise et utilise en interne sans qu'un passage par paramètre dans le contexte de CelWidgetExport
196 
		  ne soit nécessaire.
 196 
		  ne soit nécessaire.
197 
		  * Pour les champs étendus, c'est CelWidgetExport::$cache qui est utilisé, aussi bien pour les en-têtes que
 197 
		  * Pour les champs étendus, c'est CelWidgetExport::$cache qui est utilisé, aussi bien pour les en-têtes que
198 
		  pour les données préchargées, cf self::traiterLigneEtendue()
 198 
		  pour les données préchargées, cf self::traiterLigneEtendue()
199 
		*/
 199 
		*/
200 
		self::$cache = FormateurGroupeColonne::preload($colonnes, $this, $ids);
 200 
		self::$cache = FormateurGroupeColonne::preload($colonnes, $this, $ids);
201 
 
 201 
 
202 
    	// 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
203 
    	// 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)
204 
		switch($this->format) {
 204 
		switch($this->format) {
205 
		case 'csv':
 205 
		case 'csv':
206 
			$csv = $this->convertirEnCsv($observations, $colonnes);
 206 
			$csv = $this->convertirEnCsv($observations, $colonnes);
207 
			$this->envoyerCsv($csv);
 207 
			$this->envoyerCsv($csv);
208 
			break;
 208 
			break;
209 
		case 'xls':
 209 
		case 'xls':
210 
			$xls = $this->convertirEnXls($observations, $colonnes);
 210 
			$xls = $this->convertirEnXls($observations, $colonnes);
211 
			$this->envoyerXls($xls);
 211 
			$this->envoyerXls($xls);
212 
			break;
 212 
			break;
213 
		default:
 213 
		default:
214 
		}
 214 
		}
215 
	}
 215 
	}
216
216
217 
	protected function traiterParametresAutorises(Array $parametres) {
 217 
	protected function traiterParametresAutorises(Array $parametres) {
218 
		$parametres_traites = array();
 218 
		$parametres_traites = array();
219 
		$this->format = (isset($parametres['format']) && $parametres['format'] != '') ? $parametres['format'] : $this->format;
 219 
		$this->format = (isset($parametres['format']) && $parametres['format'] != '') ? $parametres['format'] : $this->format;
220 
		foreach($parametres as $cle => $valeur) {
 220 
		foreach($parametres as $cle => $valeur) {
221 
			if(is_string($valeur) && !trim($valeur)) continue;
 221 
			if(is_string($valeur) && !trim($valeur)) continue;
222 
			if(isset($this->parametres_autorises[$cle])) {
 222 
			if(isset($this->parametres_autorises[$cle])) {
223 
				$parametres_traites[$this->parametres_autorises[$cle]] = $valeur;
 223 
				$parametres_traites[$this->parametres_autorises[$cle]] = $valeur;
224 
			}
 224 
			}
225 
		}
 225 
		}
226 
		$parametres_traites['obsids'] = @self::traiterObsIds($parametres['obsids']);
 226 
		$parametres_traites['obsids'] = @self::traiterObsIds($parametres['obsids']);
227 
		return $parametres_traites;
 227 
		return $parametres_traites;
228 
	}
 228 
	}
229
229
230 
	private function envoyerCsv($csv) {
 230 
	private function envoyerCsv($csv) {
231 
		header('Content-Type: text/csv; charset=UTF-8');
 231 
		header('Content-Type: text/csv; charset=UTF-8');
232 
		header('Content-Disposition: attachment;filename='.$this->nom_fichier_export.'.csv');
 232 
		header('Content-Disposition: attachment;filename='.$this->nom_fichier_export.'.csv');
233 
		echo $csv;
 233 
		echo $csv;
234 
		exit;
 234 
		exit;
235 
	}
 235 
	}
236
236
237 
	private function envoyerXls($workbook) {
 237 
	private function envoyerXls($workbook) {
238 
		$workbook->close();
 238 
		$workbook->close();
239 
		exit;
 239 
		exit;
240 
	}
 240 
	}
241
241
242 
	private function convertirEnCsv(&$data, $colonnes) {
 242 
	private function convertirEnCsv(&$data, $colonnes) {
243 
		$chemin_temp = "php://temp";
 243 
		$chemin_temp = "php://temp";
244 
		$outstream = fopen($chemin_temp, 'r+');
 244 
		$outstream = fopen($chemin_temp, 'r+');
245 
 
 245 
 
246 
		$intitule_champs = array_merge(FormateurGroupeColonne::getIntitulesColonnes($colonnes));
 246 
		$intitule_champs = array_merge(FormateurGroupeColonne::getIntitulesColonnes($colonnes));
247 
		// en premier car utilisé génériquement dans getLigneObservation()
 247 
		// en premier car utilisé génériquement dans getLigneObservation()
248 
		if(isset($colonnes['baseflor'])) {
 248 
		if(isset($colonnes['baseflor'])) {
249 
			$intitule_champs = array_merge($intitule_champs, FormateurGroupeColonne::$baseflor_col);
 249 
			$intitule_champs = array_merge($intitule_champs, FormateurGroupeColonne::$baseflor_col);
250 
		}
 250 
		}
251 
		// 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'])) {
 252 
		if(isset($colonnes['etendu'])) {
253 
			$intitule_champs = array_merge($intitule_champs, array_values(self::$cache['etendu']['header']));
 253 
			$intitule_champs = array_merge($intitule_champs, array_values(self::$cache['etendu']['header']));
254 
		}
 254 
		}
255 
 
 255 
 
256 
		// header
 256 
		// header
257 
		fputcsv($outstream, $intitule_champs, ',', '"');
257 
		fputcsv($outstream, $intitule_champs, ',', '"');
258 
		// lignes
 258 
		// lignes
259 
		foreach($data as &$ligne) {
 259 
		foreach($data as &$ligne) {
260 
			$id_obs = $ligne['id_observation'];
 - 
 
261 
			$ligne = self::filtrerDonneesSensibles($ligne);
 260 
			$ligne = self::filtrerDonneesSensibles($ligne);
262 
			$ligne = FormateurGroupeColonne::getLigneObservation($ligne, $colonnes, $this);
 261 
			$ligne = FormateurGroupeColonne::getLigneObservation($ligne, $colonnes, $this);
263 
			self::traiterLigneEtendue($ligne, @self::$cache['etendu']['data'][$id_obs]);
 - 
 
264 
			fputcsv($outstream, $ligne, ',', '"');
 262 
			fputcsv($outstream, $ligne, ',', '"');
265 
		}
 263 
		}
266 
		rewind($outstream);
 264 
		rewind($outstream);
267 
		$csv = stream_get_contents($outstream);
 265 
		$csv = stream_get_contents($outstream);
268 
		fclose($outstream);
 266 
		fclose($outstream);
269 
		return $csv;
 267 
		return $csv;
270 
	}
 268 
	}
271
269
272 
	private function convertirEnXls(&$data, $colonnes) {
 270 
	private function convertirEnXls(&$data, $colonnes) {
273 
		$this->extendSpreadsheetProductor = new SpreadsheetProductor();
 271 
		$this->extendSpreadsheetProductor = new SpreadsheetProductor();
274 
		$this->extendSpreadsheetProductor->initSpreadsheet();
 272 
		$this->extendSpreadsheetProductor->initSpreadsheet();
275
273
276 
		$workbook = new Spreadsheet_Excel_Writer();
 274 
		$workbook = new Spreadsheet_Excel_Writer();
277 
		$worksheet = $workbook->addWorksheet('Liste');
 275 
		$worksheet = $workbook->addWorksheet('Liste');
278 
		$workbook->setTempDir($this->config['cel']['chemin_stockage_temp']);
 276 
		$workbook->setTempDir($this->config['cel']['chemin_stockage_temp']);
279 
		$workbook->setVersion(8);
 277 
		$workbook->setVersion(8);
280 
 
 278 
 
281 
		$worksheet->setInputEncoding('utf-8');
 279 
		$worksheet->setInputEncoding('utf-8');
282 
		$workbook->send($this->nom_fichier_export.'.xls');
 280 
		$workbook->send($this->nom_fichier_export.'.xls');
283
281
284 
		$nb_lignes = 1;
 282 
		$nb_lignes = 1;
285 
 
 283 
 
286 
		$intitule_champs = array_merge(FormateurGroupeColonne::getIntitulesColonnes($colonnes));
 284 
		$intitule_champs = array_merge(FormateurGroupeColonne::getIntitulesColonnes($colonnes));
287 
		// en premier car utilisé génériquement dans getLigneObservation()
 285 
		// en premier car utilisé génériquement dans getLigneObservation()
288 
		if(isset($colonnes['baseflor'])) {
 286 
		if(isset($colonnes['baseflor'])) {
289 
			$intitule_champs = array_merge($intitule_champs, FormateurGroupeColonne::$baseflor_col);
 287 
			$intitule_champs = array_merge($intitule_champs, FormateurGroupeColonne::$baseflor_col);
290 
		}
 288 
		}
291 
		// en second car manuellement appellé plus bas, TODO: utiliser l'API du FormateurGroupeColonne
 289 
		// en second car manuellement appellé plus bas, TODO: utiliser l'API du FormateurGroupeColonne
292 
		if(isset($colonnes['etendu'])) {
 290 
		if(isset($colonnes['etendu'])) {
293 
			$intitule_champs = array_merge($intitule_champs, array_values(self::$cache['etendu']['header']));
 291 
			$intitule_champs = array_merge($intitule_champs, array_values(self::$cache['etendu']['header']));
294 
		}
 292 
		}
295 
 
 293 
 
296 
		// header
 294 
		// header
297 
		$indice = 0;
 295 
		$indice = 0;
298 
		foreach ($intitule_champs as &$intitule) {
296 
		foreach ($intitule_champs as &$intitule) {
299 
			$worksheet->write(0,$indice++,$intitule);
 297 
			$worksheet->write(0,$indice++,$intitule);
300 
		}
 298 
		}
301 
 
 299 
 
302 
		foreach($data as &$ligne) {
 300 
		foreach($data as &$ligne) {
303 
			$id_obs = $ligne['id_observation'];
 - 
 
304 
			$ligne = self::filtrerDonneesSensibles($ligne);
 301 
			$ligne = self::filtrerDonneesSensibles($ligne);
305 
			$ligne = FormateurGroupeColonne::getLigneObservation($ligne, $colonnes, $this);
 302 
			$ligne = FormateurGroupeColonne::getLigneObservation($ligne, $colonnes, $this);
306 
			self::traiterLigneEtendue($ligne, @self::$cache['etendu']['data'][$id_obs]);
 - 
 
307 
			$indice = 0;
 303 
			$indice = 0;
308 
			foreach($ligne as &$champ) {
 304 
			foreach($ligne as &$champ) {
309 
				$worksheet->write($nb_lignes,$indice++,$champ);
 305 
				$worksheet->write($nb_lignes,$indice++,$champ);
310 
			}
 306 
			}
311 
			$nb_lignes++;
 307 
			$nb_lignes++;
312 
		}
 308 
		}
313 
		return $workbook;
 309 
		return $workbook;
314 
	}
 310 
	}
315
311
316 
	private function convertirEnPdf(&$observations) {
 312 
	private function convertirEnPdf(&$observations) {
317 
		if(count($observations) > 300) die('erreur: trop de données');
 313 
		if(count($observations) > 300) die('erreur: trop de données');
318 
		//require_once('GenerateurPDF.php');
 314 
		//require_once('GenerateurPDF.php');
319 
		$pdf = new GenerateurPDF();
 315 
		$pdf = new GenerateurPDF();
320 
		$pdf->export($observations);
 316 
		$pdf->export($observations);
321 
		return $pdf;
 317 
		return $pdf;
322 
	}
 318 
	}
323
- 
 
324 
	static function traiterLigneEtendue(&$ligne, $ligne_etendue_aplatie) {
 - 
 
325 
		// si header n'est pas défini, aucune observation ne possède de champ étendu
 - 
 
326 
		// et nous n'ajoutons ni colonnes, ni valeurs.
 - 
 
327 
		if(! isset(self::$cache['etendu']['header'])) return;
 - 
 
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);
 - 
 
338 
			return;
 - 
 
339 
		}
 - 
 
340 
 
 - 
 
341 
		foreach(self::$cache['etendu']['header'] as $colonne) {
 - 
 
342 
			if(!isset($ligne_etendue_aplatie[$colonne])) {
 - 
 
343 
				$ligne_etendue_fmt[$colonne] = '';
- 
 
344 
			} else {
 - 
 
345 
				$ligne_etendue_fmt[$colonne] = $ligne_etendue_aplatie[$colonne];
 - 
 
346 
			}
 - 
 
347 
		}
 - 
 
348 
 
 - 
 
349 
		// XXX/ array_merge() ?
 - 
 
350 
		$ligne += $ligne_etendue_fmt;
 - 
 
351 
	}
 - 
 
352 
 
 319
353 
	static function filtrerDonneesSensibles($ligne) {
 320 
	static function filtrerDonneesSensibles($ligne) {
354 
		if(stripos($ligne['mots_cles_texte'], 'sensible') !== false) {
 321 
		if(stripos($ligne['mots_cles_texte'], 'sensible') !== false) {
355 
			$ligne['latitude'] = '';
 322 
			$ligne['latitude'] = '';
356 
			$ligne['longitude'] = '';
 323 
			$ligne['longitude'] = '';
357 
		}
 324 
		}
358 
		return $ligne;
 325 
		return $ligne;
359 
	}
 326 
	}
360
327
361 
	private function doitEtPeutExporterObsPrivees($criteres) {
 328 
	private function doitEtPeutExporterObsPrivees($criteres) {
362 
		return isset($criteres['ce_utilisateur']) &&
329 
		return isset($criteres['ce_utilisateur']) &&
363 
					$this->peutExporterObsPrivees($criteres['ce_utilisateur']);
 330 
					$this->peutExporterObsPrivees($criteres['ce_utilisateur']);
364 
	}
 331 
	}
365
332
366 
	private function peutExporterObsPrivees($id_utilisateur) {
 333 
	private function peutExporterObsPrivees($id_utilisateur) {
367 
		$gestion_utilisateur = new User($this->config);
 334 
		$gestion_utilisateur = new User($this->config);
368 
		$utilisateur = $gestion_utilisateur->obtenirIdentiteConnectee();
 335 
		$utilisateur = $gestion_utilisateur->obtenirIdentiteConnectee();
369 
		return ! empty($utilisateur['id_utilisateur']) && $id_utilisateur == $utilisateur['id_utilisateur'];
 336 
		return ! empty($utilisateur['id_utilisateur']) && $id_utilisateur == $utilisateur['id_utilisateur'];
370 
	}
 337 
	}
371 
 
 338 
 
372 
	static function traiterObsIds($range_param) {
 339 
	static function traiterObsIds($range_param) {
373 
		if (!isset($range_param)) return NULL;
 340 
		if (!isset($range_param)) return NULL;
374 
		// trim() car: `POST http://url<<<"range=*"`
 341 
		// trim() car: `POST http://url<<<"range=*"`
375 
		if (trim($range_param) == '*') return NULL;
 342 
		if (trim($range_param) == '*') return NULL;
376 
		return self::rangeToList(trim($range_param));
 343 
		return self::rangeToList(trim($range_param));
377 
	}
 344 
	}
378 
 
 345 
 
379 
	/*
 346 
	/*
380 
	 * @param $fieldSets: un range, eg: 1-5,8,32,58-101
 347 
	 * @param $fieldSets: un range, eg: 1-5,8,32,58-101
381 
	 * @return un tableau trié, eg: 1,2,3,4,5,8,32,58,...,101
 348 
	 * @return un tableau trié, eg: 1,2,3,4,5,8,32,58,...,101
382 
	 * http://stackoverflow.com/questions/7698664/converting-a-range-or-partial-array-in-the-form-3-6-or-3-6-12-into-an-arra
 349 
	 * http://stackoverflow.com/questions/7698664/converting-a-range-or-partial-array-in-the-form-3-6-or-3-6-12-into-an-arra
383 
	 */
 350 
	 */
384 
	static function rangeToList($in = '') {
 351 
	static function rangeToList($in = '') {
385 
		$inSets = explode(',', trim($in, ','));
 352 
		$inSets = explode(',', trim($in, ','));
386 
		$outSets = array();
 353 
		$outSets = array();
387 
 
 354 
 
388 
		foreach($inSets as $inSet) {
 355 
		foreach($inSets as $inSet) {
389 
			list($start,$end) = explode('-', $inSet . '-' . $inSet);
 356 
			list($start,$end) = explode('-', $inSet . '-' . $inSet);
390 
			// ignore les ranges trop importants
 357 
			// ignore les ranges trop importants
391 
			if($start > 10000000 || $end > 10000000 || abs($start-$end) > 10000) continue;
 358 
			if($start > 10000000 || $end > 10000000 || abs($start-$end) > 10000) continue;
392 
			$outSets = array_merge($outSets,range($start,$end));
 359 
			$outSets = array_merge($outSets,range($start,$end));
393 
		}
 360 
		}
394 
		$outSets = array_unique($outSets);
 361 
		$outSets = array_unique($outSets);
395 
		$outSets = array_filter($outSets, 'is_numeric');
 362 
		$outSets = array_filter($outSets, 'is_numeric');
396 
		sort($outSets);
 363 
		sort($outSets);
397 
		return $outSets;
 364 
		return $outSets;
398 
	}
 365 
	}
399 
}
 366 
}
400 
?>
 367 
?>