WebSVN – eFlore/Applications.cel – Diff – /trunk/jrest/services/CelWidgetExport.php


<?php
/**
* Service fournissant des informations concernant le CEL au format RSS1, RSS2 ou ATOM.
* Encodage en entrée : utf8
* Encodage en sortie : utf8
* Format du service :
* /CelWidgetExport/format
* /CelWidgetExport/csv
*
* Les paramêtres :
*  - "start" indique le numéro du premier item à afficher
*  - "limit" nombre d'items à afficher
*
* @author Aurélien Peronnet <aurelien@tela-botanica.org>
* @license GPL v3 <http://www.gnu.org/licenses/gpl.txt>
* @license CECILL v2 <http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt>
* @version $Id$
* @copyright 2012
*/
 
set_include_path(get_include_path() . PATH_SEPARATOR . dirname(dirname(realpath(__FILE__))) . '/lib');
// la sortie est binaire (xls), mais OLE n'est pas compatible E_ALL en PHP-5.4
error_reporting(error_reporting() & ~E_STRICT);
require_once("lib/OLE.php");
require_once("lib/Spreadsheet/Excel/Writer.php");
 
class CelWidgetExport extends Cel {
	
	private $nom_fichier_export = 'cel_export';
	// certains paramètres apparaissent plusieurs fois car ils ont des alias
	// dans certains widgets
	private $parametres_autorises = array(
		'id_utilisateur' => 'ce_utilisateur',
		'utilisateur' => 'courriel_utilisateur',
		'commune' => 'zone_geo',
		'zone_geo' => 'zone_geo',
		'dept' => 'departement',
		'departement' => 'departement',
		'lieudit' => 'lieudit',
		'station' => 'station',
		'projet' => 'mots_cles',
		'num_taxon' => 'nt',
		'date_debut' => 'date_debut',
		'date_fin' => 'date_fin',
		'taxon' => 'taxon',
		'annee' => 'annee',
		'mois' => 'mois',
		'jour' => 'jour',
		'recherche' => 'recherche',
		'id_mots_cles' => 'id_mots_cles',
		'mots_cles' => 'mots_cles',
		'debut' => 'debut',
		'limite' => 'limite',
		'format' => 'format',
		'colonnes' => 'colonnes',
		'transmission' => 'transmission',
		'obsids' => 'obsids',
	);
	
	private $limite_decoupage_defaut = 9000; 
	
	private $format = 'csv';
	
	public $id_utilisateur = null;
	
	public function getRessource() {
		return $this->getElement(array());
	}
		
	/**
	 * Méthode appelée avec une requête de type GET.
	 */
	public function getElement($params = array()) {		
		if(count($params) > 0) {
			switch(strtolower($params[0])) {
				case 'calcul':
					$this->getCalcul();
				break;
				
				case 'export':
					$this->getExport();
				break;
				
				default:
					$this->getExport();
			}
		} else {
			$this->getExport();
		}
	}
	
	private function getCalcul() {
		$criteres = $this->traiterParametresAutorises($_GET);
 
		$criteres['transmission'] = 1;
		if($this->doitEtPeutExporterObsPrivees($criteres)) {
			unset($criteres['transmission']);
			$this->id_utilisateur = $criteres['id_utilisateur'];
		}
		$chercheur_observations = new RechercheObservation($this->config);
		
		$numero_page = isset($criteres['debut']) ? $criteres['debut'] : 0;
		$limite = isset($criteres['limite']) ? $criteres['limite'] : 0;
		$colonnes = isset($criteres['colonnes']) ? $criteres['colonnes'] : 'standard,avance';
		
		unset($criteres['limite']);
		unset($criteres['debut']);
		unset($criteres['format']);
		unset($criteres['colonnes']);
		
		$nb_observations = $chercheur_observations->compterObservations(null, $criteres);
		$limite_decoupage = $this->calculerNbLignesMaxParFichier();
		
		$url_telechargements = array();
		$intervalle = 0;
		
		$params_url = $criteres;
		unset($params_url['transmission']);
		do {
			$base_url = $this->config['settings']['baseURLAbsolu'].'CelWidgetExport/export';
			$params_url['debut'] = $intervalle;
			$params_url['limite'] = $limite_decoupage;
			$url_telechargement_fichier = $base_url;
			$url_telechargements[] = $base_url.'?'.http_build_query($params_url).'&format='.$this->format.'&colonnes='.$colonnes;
			$intervalle += $limite_decoupage;
			$nb_observations -= $limite_decoupage;
		} while($nb_observations >= $limite_decoupage);
		
		$this->envoyerJson($url_telechargements);
	}
	
	private function calculerNbLignesMaxParFichier() {
		$limite = $this->limite_decoupage_defaut;
		switch($this->format) {
			case 'csv':
				$limite = 20000;
				break;
			case 'xls':
				$limite = 8000;
				break;
			case 'pdf':
				$limite = 300;
				break;
		}
		return $limite;
	}
	
	private function getExport() {
		$criteres = $this->traiterParametresAutorises($_GET);
		$criteres['transmission'] = 1;
		if($this->doitEtPeutExporterObsPrivees($criteres)) {
			unset($criteres['transmission']);
		}
		$chercheur_observations = new RechercheObservation($this->config);
		
		$debut = isset($criteres['debut']) ? intval($criteres['debut']) : 0;
		$limite = isset($criteres['limite']) ? intval($criteres['limite']) : 0;
		$colonnes = isset($criteres['colonnes']) ? $criteres['colonnes'] : 'standard,avance';
 
		if($criteres['obsids']) $criteres['sql_brut'] = sprintf('id_observation IN (%s)',
																implode(',', $criteres['obsids']));
		
		unset($criteres['limite']);
		unset($criteres['debut']);
		unset($criteres['format']);
		unset($criteres['colonnes']);
		unset($criteres['obsids']);
 
		$observations = $chercheur_observations->rechercherObservations(null, $criteres, $debut, $limite, TRUE)->get();
		$ids = array();
		foreach($observations as &$obs) {
			$ids[] = $obs['id_observation'];
		}
 
		if($this->format == 'pdf') {
 
 
			$pdf = $this->convertirEnPdf($observations);
 
 
 
 
			$pdf->pdf->Output('etiquettes.pdf', 'I');
			exit;
		}
 
		// cas XLS et CSV: on peut avoir besoin des champs étendus, des noms communs et des champs baseflor:
 
		// 1) champs étendus
		$gestion_champs_etendus = new GestionChampsEtendus($this->config, 'obs');
		$champs_supp_par_obs = $gestion_champs_etendus->consulterParLots($ids);
		$colonnes_champs_supp_par_obs = $gestion_champs_etendus->consulterClesParLots($ids);
 
		// 2) nom communs
		// $cache pourrait être utilisé par les fonctions de colonnes
		// * Pour "nom commun", "preload" retourne NULL, car c'est le cache statique de FormateurGroupeColonne
		// qu'il initialise et utilise en interne sans qu'un passage par paramètre ne soit nécessaire
		$cache = FormateurGroupeColonne::preload(FormateurGroupeColonne::nomEnsembleVersListeColonnes($colonnes),
												 $this,
												 $ids);
 
    	// TODO: tous les champs étendus et les paramètres supplémentaires devraient être passés en un seul
    	// tableau (et chaque formateur csv, xls etc... pourrait également être dans une classe à part)
		switch($this->format) {
		case 'csv':
			$csv = $this->convertirEnCsv($observations, $colonnes, $colonnes_champs_supp_par_obs, $champs_supp_par_obs);
			$this->envoyerCsv($csv);
			break;
		case 'xls':
			$xls = $this->convertirEnXls($observations, $colonnes, $colonnes_champs_supp_par_obs, $champs_supp_par_obs);
			$this->envoyerXls($xls);
			break;
 
 
 
 
		default:
		}
	}
	
	protected function traiterParametresAutorises(Array $parametres) {
		$parametres_traites = array();
		$this->format = (isset($parametres['format']) && $parametres['format'] != '') ? $parametres['format'] : $this->format;
		foreach($parametres as $cle => $valeur) {
			if(trim($valeur) != '' && isset($this->parametres_autorises[$cle])) {
				$parametres_traites[$this->parametres_autorises[$cle]] = $valeur;
			}
		}
		$parametres_traites['obsids'] = @self::traiterObsIds($parametres['obsids']);
		return $parametres_traites;
	}
	
	private function envoyerCsv($csv) {
		header('Content-Type: text/csv; charset=UTF-8');
		header('Content-Disposition: attachment;filename='.$this->nom_fichier_export.'.csv');
		echo $csv;
		exit;
	}
	
	private function envoyerXls($workbook) {
		$workbook->close();
		exit;
	}
	
	private function convertirEnCsv(&$data, &$colonnes, &$colonnes_supplementaires, &$champs_supplementaires = array()) {
		$chemin_temp = "php://temp";
		$outstream = fopen($chemin_temp, 'r+');
 
		$groupe_colonnes = FormateurGroupeColonne::nomEnsembleVersListeColonnes($colonnes);
 
		$intitule_champs = array_merge(FormateurGroupeColonne::getIntitulesColonnes($groupe_colonnes));
		// en premier car utilisé génériquement dans getLigneObservation()
		if(strpos($colonnes, 'avance') !== false) {
			$intitule_champs = array_merge($intitule_champs, FormateurGroupeColonne::$baseflor_col);
		}
		// en second car manuellement appellé plus bas, TODO: utiliser l'API du FormateurGroupeColonne
		$intitule_champs = array_merge($intitule_champs, array_values($colonnes_supplementaires));
 
		// header
		fputcsv($outstream, $intitule_champs, ',', '"');			
		// lignes
		foreach($data as &$ligne) {
			$id_obs = $ligne['id_observation'];
			$ligne = self::filtrerDonneesSensibles($ligne);
			$ligne = FormateurGroupeColonne::getLigneObservation($ligne, $groupe_colonnes, $this);
			$ligne_etendue_aplatie = self::aplatirChampsEtendus($champs_supplementaires[$id_obs]);
			self::traiterLigneEtendue($ligne, $colonnes_supplementaires, $ligne_etendue_aplatie);
			fputcsv($outstream, $ligne, ',', '"');
		}
		rewind($outstream);
		$csv = stream_get_contents($outstream);
		fclose($outstream);
		return $csv;
	}
	
	private function convertirEnXls(&$data, &$colonnes,  &$colonnes_supplementaires, &$champs_supplementaires = array()) {		
		$this->extendSpreadsheetProductor = new SpreadsheetProductor();
		$this->extendSpreadsheetProductor->initSpreadsheet();
		
		$workbook = new Spreadsheet_Excel_Writer();
		$worksheet = $workbook->addWorksheet('Liste');
		$workbook->setTempDir($this->config['cel']['chemin_stockage_temp']);
		$workbook->setVersion(8);
 
		$worksheet->setInputEncoding('utf-8');
		$workbook->send($this->nom_fichier_export.'.xls');
		
		$nb_lignes = 1;
		$groupe_colonnes = FormateurGroupeColonne::nomEnsembleVersListeColonnes($colonnes);
 
		$intitule_champs = array_merge(FormateurGroupeColonne::getIntitulesColonnes($groupe_colonnes));
		// en premier car utilisé génériquement dans getLigneObservation()
		if(strpos($colonnes, 'avance') !== false) {
			$intitule_champs = array_merge($intitule_champs, FormateurGroupeColonne::$baseflor_col);
		}
		// en second car manuellement appellé plus bas, TODO: utiliser l'API du FormateurGroupeColonne
		$intitule_champs = array_merge($intitule_champs, array_values($colonnes_supplementaires));
 
		// header
		$indice = 0;
		foreach ($intitule_champs as &$intitule) {	
			$worksheet->write(0,$indice++,$intitule);
		}
 
		foreach($data as &$ligne) {
			$id_obs = $ligne['id_observation'];
			$ligne = self::filtrerDonneesSensibles($ligne);
			$ligne = FormateurGroupeColonne::getLigneObservation($ligne, $groupe_colonnes, $this);
 
			$ligne_etendue_aplatie = self::aplatirChampsEtendus($champs_supplementaires[$id_obs]);
			$ligne_supp = self::traiterLigneEtendue($ligne, $colonnes_supplementaires, $ligne_etendue_aplatie);
			$indice = 0;
			foreach($ligne as &$champ) {
				$worksheet->write($nb_lignes,$indice++,$champ);
			}
			$nb_lignes++;
		}
		return $workbook;
	}
	
	private function convertirEnPdf(&$observations) {
		if(count($observations) > 300) die('trop de données');
		//require_once('GenerateurPDF.php');
		$pdf = new GenerateurPDF();
		$pdf->export($observations);
		return $pdf;
	}
 
 
 
 
 
	
	static function traiterLigneEtendue(&$ligne, &$colonnes_etendues, $ligne_etendue_aplatie) {
		if(! $colonnes_etendues) return;
		if(! $ligne_etendue_aplatie) return;
		$nb_colonnes_supp = count($colonnes_etendues);
 
		$ligne_supp = array_fill(0, $nb_colonnes_supp, '');
		$ligne_etendue_fmt = array();
 
		foreach($colonnes_etendues as $colonne) {
			if(!isset($ligne_etendue_aplatie[$colonne])) {
				$ligne_etendue_fmt[$colonne] = ''; 
			} else {
				$ligne_etendue_fmt[$colonne] = $ligne_etendue_aplatie[$colonne];
			}
		}
 
		$ligne += $ligne_etendue_fmt;
	}
 
	static function aplatirChampsEtendus(&$ligne_champs_etendus) {
		$champs_etendus_fmt = array();
		if(!$ligne_champs_etendus) return $champs_etendus_fmt;
		foreach($ligne_champs_etendus as $champ) {
			$champs_etendus_fmt[$champ->cle] = $champ->valeur;
		}
		return $champs_etendus_fmt;
	}
	
	static function filtrerDonneesSensibles($ligne) {
		if(stripos($ligne['mots_cles_texte'], 'sensible') !== false) {
			$ligne['latitude'] = '';
			$ligne['longitude'] = '';
		}
		return $ligne;
	}
	
	private function doitEtPeutExporterObsPrivees($criteres) {
		return isset($criteres['ce_utilisateur']) && 
					$this->peutExporterObsPrivees($criteres['ce_utilisateur']);
	}
	
	private function peutExporterObsPrivees($id_utilisateur) {
		$gestion_utilisateur = new User($this->config);
		$utilisateur = $gestion_utilisateur->obtenirIdentiteConnectee();
 
 
		return ! empty($utilisateur['id_utilisateur']) && $id_utilisateur == $utilisateur['id_utilisateur'];
	}
 
	static function traiterObsIds($range_param) {
		if (!isset($range_param)) return NULL;
		// trim() car: `POST http://url<<<"range=*"`
		if (trim($range_param) == '*') return NULL;
		return self::rangeToList(trim($range_param));
	}
 
	/*
	 * @param $fieldSets: un range, eg: 1-5,8,32,58-101
	 * @return un tableau trié, eg: 1,2,3,4,5,8,32,58,...,101
	 * http://stackoverflow.com/questions/7698664/converting-a-range-or-partial-array-in-the-form-3-6-or-3-6-12-into-an-arra
	 */
	static function rangeToList($in = '') {
		$inSets = explode(',', trim($in, ','));
		$outSets = array();
 
		foreach($inSets as $inSet) {
			list($start,$end) = explode('-', $inSet . '-' . $inSet);
			// ignore les ranges trop importants
			if($start > 10000000 || $end > 10000000 || abs($start-$end) > 10000) continue;
			$outSets = array_merge($outSets,range($start,$end));
		}
		$outSets = array_unique($outSets);
		$outSets = array_filter($outSets, 'is_numeric');
		sort($outSets);
		return $outSets;
	}
}
?>

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

Subversion Repositories eFlore/Applications.cel

(root)/trunk/jrest/services/CelWidgetExport.php – Rev 1700 → 1703