Subversion Repositories eFlore/Applications.cel

<?php

// declare(encoding='UTF-8');

/**

 * Service d'import de données d'observation du CEL au format XLS

 *

 * Sont define()'d commme n° de colonne tous les abbrevs retournés par

 * FormateurGroupeColonne::nomEnsembleVersListeColonnes() préfixés par C_  cf: detectionEntete()

 *

 * Exemple d'un test:

 * $ GET "/jrest/ExportXLS/22506?format=csv&range=*&limite=13" \

 *   | curl -F "upload=@-" -F utilisateur=22506 "/jrest/ImportXLS"

 * # 13 observations importées

 * + cf MySQL general_log = 1

 *

 * @internal   Mininum PHP version : 5.2

 * @category   CEL

 * @package    Services

 * @subpackage Observations

 * @version    0.1

 * @author     Mathias CHOUET <mathias@tela-botanica.org>

 * @author     Raphaël DROZ <raphael@tela-botanica.org>

 * @author     Jean-Pascal MILCENT <jpm@tela-botanica.org>

 * @author     Aurelien 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>

 * @copyright  1999-2014 Tela Botanica <accueil@tela-botanica.org>

 */

set_include_path(get_include_path() . PATH_SEPARATOR . dirname(dirname(realpath(__FILE__))) . '/lib');

// TERM

error_reporting(-1);

ini_set('html_errors', 0);

ini_set('xdebug.cli_color', 2);

date_default_timezone_set('Europe/Paris');

require_once 'lib/PHPExcel/Classes/PHPExcel.php';

require_once 'bibliotheque/GestionMotsClesChemin.php';

// nombre d'INSERT à cumuler par requête SQL

// (= nombre de lignes XLS à bufferiser)

//define('NB_LIRE_LIGNE_SIMUL', 30);

define('NB_LIRE_LIGNE_SIMUL', 5);

// en cas d'import d'un fichier CSV, utilise fgetcsv() plutôt

// que PHPExcel ce qui se traduit par un gain de performances très substanciel

define('QUICK_CSV_IMPORT', TRUE);

// Numbers of days between January 1, 1900 and 1970 (including 19 leap years)

// see traiterDateObs()

// define("MIN_DATES_DIFF", 25569);

class MyReadFilter implements PHPExcel_Reader_IReadFilter {

	// exclusion de colonnes

	public $exclues = array();

	// lecture par morceaux

	public $ligne_debut = 0;

	public $ligne_fin = 0;

	public static $gestion_mots_cles = null;

	public function __construct() {}

	public function def_interval($debut, $nb) {

		$this->ligne_debut = $debut;

		$this->ligne_fin = $debut + $nb;

	}

	public function readCell($colonne, $ligne, $worksheetName = '') {

		if(@$this->exclues[$colonne]) return false;

		// si des n° de morceaux ont été initialisés, on filtre...

		if($this->ligne_debut && ($ligne < $this->ligne_debut || $ligne >= $this->ligne_fin)) return false;

		return true;

	}

}

function __anonyme_1($v) {	return !$v['importable']; }

function __anonyme_2(&$v) {	$v = $v['nom']; }

function __anonyme_3($cell) { return !is_null($cell); };

function __anonyme_5($item) { return is_null($item) ? '?' : $item; }

function __anonyme_6() { return NULL; }

class ImportXLS extends Cel  {

	static function __anonyme_4(&$item, $key) { $item = self::quoteNonNull(trim($item)); }

	static $ordre_BDD = Array(

		'ce_utilisateur',

		'prenom_utilisateur',

		'nom_utilisateur',

		'courriel_utilisateur',

		'ordre',

		'nom_sel',

		'nom_sel_nn',

		'nom_ret',

		'nom_ret_nn',

		'nt',

		'famille',

		'nom_referentiel',

		'pays',

		'zone_geo',

		'ce_zone_geo',

		'date_observation',

		'lieudit',

		'station',

		'milieu',

		'mots_cles_texte',

		'commentaire',

		'transmission',

		'date_creation',

		'date_modification',

		'date_transmission',

		'latitude',

		'longitude',

		'altitude',

		'abondance',

		'certitude',

		'phenologie',

		'code_insee_calcule'

	);

	// cf: initialiser_pdo_ordered_statements()

	// eg: "INSERT INTO cel_obs (ce_utilisateur, ..., phenologie, code_insee_calcule) VALUES"

	// colonnes statiques d'abord, les autres ensuite, dans l'ordre de $ordre_BDD

	static $insert_prefix_ordre;

	// eg: "(<id>, <prenom>, <nom>, <email>, now(), now(), ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)"

	// dont le nombre de placeholder dépend du nombre de colonnes non-statiques

	// colonnes statiques d'abord, les autres ensuite, dans l'ordre de $ordre_BDD

	static $insert_ligne_pattern_ordre;

	// seconde (meilleure) possibilité

	// cf: initialiser_pdo_statements()

	// eg: "INSERT INTO cel_obs (ce_utilisateur, ..., date_creation, ...phenologie, code_insee_calcule) VALUES"

	static $insert_prefix;

	// eg: "(<id>, <prenom>, <nom>, <email>, ?, ?, ?, now(), now(), ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)"

	// dont le nombre de placeholder dépend du nombre de colonnes non-statiques

	static $insert_ligne_pattern;

	/*

	 Ces colonnes:

	 - sont propres à l'ensemble des enregistrements uploadés

	 - sont indépendantes du numéro de lignes

	 - n'ont pas de valeur par défaut dans la structure de la table

	 - nécessitent une initialisation dans le cadre de l'upload

	 initialiser_colonnes_statiques() y merge les données d'identification utilisateur

	*/

	public $colonnes_statiques = array(

		'ce_utilisateur' => NULL,

		'prenom_utilisateur' => NULL,

		'nom_utilisateur' => NULL,

		'courriel_utilisateur' => NULL,

		// fixes (fonction SQL)

		// XXX future: mais pourraient varier dans le futur si la mise-à-jour

		// d'observation est implémentée

		'date_creation' => 'NOW()',

		'date_modification' => 'NOW()',

	);

	public static $prefixe_colonnes_etendues = 'ext:';

	public static $indexes_colonnes_etendues = Array();

	public static $gestion_champs_etendus = null;

	public $id_utilisateur = NULL;

	// erreurs d'import

	public $bilan = Array();

	// cache (pour traiterLocalisation() pour l'instant)

	static $cache = Array('geo' => array());

	public function createElement($pairs) {

		if (!isset($pairs['utilisateur']) || trim($pairs['utilisateur']) == '') {

			exit('0');

		}

		$id_utilisateur = intval($pairs['utilisateur']);

		$this->id_utilisateur = $id_utilisateur; // pour traiterImage();

		if (!isset($_SESSION)) {

			session_start();

		}

		$this->controleUtilisateur($id_utilisateur);

		$this->utilisateur = $this->getInfosComplementairesUtilisateur($id_utilisateur);

		$this->initialiser_colonnes_statiques($id_utilisateur);

		list(self::$insert_prefix, self::$insert_ligne_pattern) = $this->initialiser_pdo_statements($this->colonnes_statiques);

		$infos_fichier = array_pop($_FILES);

		// renomme le fichier pour lui ajouter son extension initiale, ce qui

		// permet (une sorte) d'autodétection du format.

		$fichier = $infos_fichier['tmp_name'];

		$extension = pathinfo($infos_fichier['name'], PATHINFO_EXTENSION);

		if ( (strlen($extension) == 3 || strlen($extension) == 4) && (@rename($fichier, "$fichier.$extension"))) {

			$fichier = "$fichier.$extension";

		}

		$objReader = PHPExcel_IOFactory::createReaderForFile($fichier);

		// TODO: check if compatible with toArray(<1>,<2>,TRUE,<4>)

		$objReader->setReadDataOnly(true);

		// TODO: is_a obsolete entre 5.0 et 5.3, retirer le @ à terme

		$IS_CSV = @is_a($objReader, 'PHPExcel_Reader_CSV') && QUICK_CSV_IMPORT;

		// en cas d'usage de fgetcsv, testons que nous pouvons compter les lignes

		if ($IS_CSV) {

			$nb_lignes = intval(exec("wc -l $fichier"));

		}

		// et, le cas échéant, fallback sur PHPExcel à nouveau. La raison de ce test ici est

		// l'instabilité du serveur (safe_mode, safe_mode_exec_dir, symlink vers binaires pour exec(), ... multiples points-of-failure)

		if ($IS_CSV && !$nb_lignes) {

			$IS_CSV = FALSE;

		}

		if ($IS_CSV) {

			$objReader->setDelimiter(',')

				->setEnclosure('"')

				->setLineEnding("\n")

				->setSheetIndex(0);

		}

		// on ne conserve que l'en-tête

		$filtre = new MyReadFilter();

		$filtre->def_interval(1, 2);

		$objReader->setReadFilter($filtre);

		$objPHPExcel = $objReader->load($fichier);

		$obj_infos = $objReader->listWorksheetInfo($fichier);

		if ($IS_CSV) {

			// $nb_lignes est déjà défini ci-dessus

			$csvFileHandler = fopen($fichier, 'r');

			// nous utilisons la valeur de retour dans un but informatif de l'utilisateur à la

			// fin de l'import, *mais aussi* dans un array_diff_key() ci-dessous car bien que dans le

			// fond le "parser" fgetcsv() n'ait pas d'intérêt à connaître les colonnes à ignorer,

			// il se trouve que celles-ci peuvent interférer sur des fonctions comme traiterEspece()

			// cf test "ref-nom-num.test.php" pour lequel l'élément C_NOM_SEL vaudrait 3 et $ligne serait array(3 => -42)

			$filtre->exclues = self::detectionEntete(fgetcsv($csvFileHandler), TRUE);

		} else {

			// XXX: indépendant du readFilter ?

			$nb_lignes = $obj_infos[0]['totalRows'];

			$donnees = $objPHPExcel->getActiveSheet()->toArray(NULL, FALSE, TRUE, TRUE);

			$filtre->exclues = self::detectionEntete($donnees[1]);

		}

		$obs_ajouts = 0;

		$obs_maj = 0;

		$nb_images_ajoutees = 0;

		$nb_mots_cle_ajoutes = 0;

		$nb_champs_etendus_inseres = 0;

		$dernier_ordre = Cel::db()->requeter("SELECT MAX(ordre) AS ordre FROM cel_obs WHERE ce_utilisateur = $id_utilisateur");

		$dernier_ordre = intval($dernier_ordre[0]['ordre']) + 1;

		if (! $dernier_ordre) {

			$dernier_ordre = 0;

		}

		// on catch to les trigger_error(E_USER_NOTICE);

		set_error_handler(array($this, 'erreurs_stock'), E_USER_NOTICE);

		$this->taxon_info_webservice = new RechercheInfosTaxonBeta($this->config, NULL);

		// lecture par morceaux (chunks), NB_LIRE_LIGNE_SIMUL lignes à fois

		// pour aboutir des requêtes SQL d'insert groupés.

		for ($ligne = 2; $ligne < $nb_lignes + NB_LIRE_LIGNE_SIMUL; $ligne += NB_LIRE_LIGNE_SIMUL) {

			if (!$IS_CSV) {

				$filtre->def_interval($ligne, NB_LIRE_LIGNE_SIMUL);

				$objReader->setReadFilter($filtre);

				$objPHPExcel = $objReader->load($fichier)->getActiveSheet();

				// set col typing

				if (C_CE_ZONE_GEO != 'C_CE_ZONE_GEO') {

					$objPHPExcel->getStyle(C_CE_ZONE_GEO . '2:' . C_CE_ZONE_GEO . $objPHPExcel->getHighestRow())->getNumberFormat()->setFormatCode('00000');

				}

				// TODO: set to string type

				if (C_ZONE_GEO != 'C_ZONE_GEO') {

					$objPHPExcel->getStyle(C_ZONE_GEO . '2:' . C_ZONE_GEO . $objPHPExcel->getHighestRow())->getNumberFormat()->setFormatCode('00000');

				}

				$donnees = $objPHPExcel->toArray(NULL, FALSE, TRUE, TRUE);

			} else {

				$i = NB_LIRE_LIGNE_SIMUL;

				$donnees = array();

				while ($i--) {

					$tab = fgetcsv($csvFileHandler);

					if (!$tab) {

						continue;

					}

					$donnees[] = array_diff_key($tab, $filtre->exclues);

				}

			}

			list($enregistrements, $images, $mots_cle, $champs_etendus) = self::chargerLignes($this, $donnees, $this->colonnes_statiques, $dernier_ordre, $config);

			if (! $enregistrements) {

				break;

			}

			self::trierColonnes($enregistrements);

			// normalement: NB_LIRE_LIGNE_SIMUL, sauf si une enregistrement ne semble pas valide

			// ou bien lors du dernier chunk

			$nb_rec = count($enregistrements);

			$sql_pattern = self::$insert_prefix.

				str_repeat(self::$insert_ligne_pattern.', ', $nb_rec - 1).

				self::$insert_ligne_pattern;

			Cel::db()->beginTransaction();

			$stmt = Cel::db()->prepare($sql_pattern);

			$donnees = array();

			foreach ($enregistrements as $e) {

				$donnees = array_merge($donnees, array_values($e));

			}

			$stmt->execute($donnees);

			# @TODO lier les mots-clées de l'arbre à l'obs nouvellement insérée, sinon seuls les mots-clés texte

			# seront à jour, et ils seront écrasés à la prochaine modification de mots-clés pour cette obs...

			# => nécessite d'insérer les obs une par une pour avoir le dernier id inséré

			$dernier_autoinc = Cel::db()->lastInsertId();

			Cel::db()->commit();

			if (! $dernier_autoinc) {

				trigger_error("l'insertion semble avoir échoué", E_USER_NOTICE);

			}

			$obs_ajouts += count($enregistrements);

			$ordre_ids = self::chargerCorrespondancesIdOrdre($this, $enregistrements);

			$nb_images_ajoutees += self::stockerImages($enregistrements, $images, $ordre_ids);

			$nb_mots_cle_ajoutes += self::stockerMotsCle($enregistrements, $mots_cle, $dernier_autoinc);

			$nb_champs_etendus_inseres += self::stockerChampsEtendus($champs_etendus, $ordre_ids, $this->config);

		}

		restore_error_handler();

		// le cast en string des nombres permet d'unifier le parsing du retour

		// car il n'est destiné qu'à être affiché

		$retour = array(

					'import_obs_ajoutees' => (string)$obs_ajouts,

					'import_images_ajoutees' => (string)$nb_images_ajoutees,

					'import_mots_cles_ajoutes' => (string)$nb_mots_cle_ajoutes,

					'import_colonnes_non_traitees' => implode(', ', $filtre->exclues)

		);

		// Ajout d'éventuelles erreurs

		if ($this->bilan) {

			$retour += array('import_erreurs' => implode("\n", $this->bilan) . "\n");

		}

		// Dans le cas où le client ne sait pas lire le retour d'upload

		// on stocke les stats en session pour les appeler plus tard

		// car ceci peut poser notamment problème pour les requêtes CORS

		$_SESSION['upload_stats'] = $retour;

		// On envoie quand même les stats pour les clients qui savent ou peuvent

		// les lire directement après l'upload

		$this->envoyerJson($retour);

		die();

	}

	public function getElement($uid) {

		if($uid[0] == "template") {

			$tpl_dir = dirname(__FILE__).DIRECTORY_SEPARATOR.'squelettes'.DIRECTORY_SEPARATOR;

			$tpl = $tpl_dir.'modele_import.xls';

			$lecteur = PHPExcel_IOFactory::createReaderForFile($tpl);

			$classeur_tpl = $lecteur->load($tpl);

			$feuille_tpl = $classeur_tpl->getActiveSheet();

			// Détection de la dernière colonne pour connaitre la position d'ajout des champs étendus

			// Si un groupe est demandé

			$lettre_colonne_max = $feuille_tpl->getHighestColumn();

			$nb_colonne_max = PHPExcel_Cell::columnIndexFromString($lettre_colonne_max);

			$ligne = 1;

			$nb_colonne_en_cours = $nb_colonne_max;

			// Obtention des descriptions de champs communs et spécifiques

			$descriptions = $this->obtenirDescriptions($tpl_dir.'modele_import_description.txt');

			if(!empty($_GET['groupe'])) {

				$descriptions = $this->obtenirDescriptions($tpl_dir.'modele_import_description_'.$_GET['groupe'].'.txt', $descriptions);

			}

			// Association de la description des champs commun

			for($i = 0; $i < $nb_colonne_max; $i++) {

				$lettre_colonne = PHPExcel_Cell::stringFromColumnIndex($i);

				$champ_obl = $feuille_tpl->getCell($lettre_colonne.$ligne)->getValue();

				if(!empty($descriptions[$champ_obl])) {

					$feuille_tpl->getComment($lettre_colonne.$ligne)->getText()->createTextRun($descriptions[$champ_obl]);

					$feuille_tpl->getComment($lettre_colonne.$ligne)->setWidth(400);

				}

			}

			$nom_fichier = 'import';

			// Ajout des colonnes spécifiques si un groupe de champ est demandé

			if(!empty($_GET['groupe'])) {

				$requete = "SELECT * FROM cel_catalogue_champs_etendus_liaison WHERE groupe = ".Cel::db()->proteger($_GET['groupe']);

				$champs = Cel::db()->requeter($requete);

				foreach($champs as $champ) {

					$lettre_colonne = PHPExcel_Cell::stringFromColumnIndex($nb_colonne_en_cours);

					// Les champs étendus sont préfixés par "ext:" pour ne pas être ignoré lors d'un import

					// l'import ignore les noms de colonnes qu'il ne connait pas

					$feuille_tpl->setCellValue($lettre_colonne.$ligne, 'ext:'.$champ['champ']);

					// Ajout de la description dans le commentaire si elle est présente

					if(!empty($descriptions[$champ['champ']])) {

						$feuille_tpl->getComment($lettre_colonne.$ligne)->getText()->createTextRun($descriptions[$champ['champ']]);

						$feuille_tpl->getComment($lettre_colonne.$ligne)->setWidth(400);

					}

					$nb_colonne_en_cours++;

				}

				$nom_fichier .= '_'.$_GET['groupe'];

			}

			// Seul le format xlsx permet l'association de commentaires de colonnes dans PHPExcel

			// C'est triste mais bon mais c'est trop pratique pour qu'on s'en passe

			header('Content-type: application/vnd.ms-excel');

			header('Content-Disposition: attachment; filename="'.$nom_fichier.'.xlsx"');

			$generateur = PHPExcel_IOFactory::createWriter($classeur_tpl, 'Excel2007');

			$generateur->save('php://output');

			exit;

		}

	}

	private function obtenirDescriptions($fichier_description, $descriptions = array()) {

		if(file_exists($fichier_description)) {

			$descs_str = file_get_contents($fichier_description);

			$desc_items = explode("\n", $descs_str);

			foreach($desc_items as $item) {

				$cle_valeur = explode("=", $item);

				$valeur_desc = trim($cle_valeur[1]);

				// Les clés des fichiers sont écrasées dans l'ordre de lecture ce qui permet

				// d'avoir par exemple une description différente pour le champ station suivant le projet

				// les "<br />" sont remplacés par des sauts de lignes

				$descriptions[trim($cle_valeur[0])] = str_replace('<br />', "\n", $valeur_desc);

			}

		}

		return $descriptions;

	}

	public function getRessource() {

		return self::getStatsDernierUpload();

	}

	static function getStatsDernierUpload() {

		// renvoi des statistiques du dernier envoi de fichier

		$stats = !empty($_SESSION['upload_stats']) ? $_SESSION['upload_stats'] : null;

		header("Content-Type: application/json; charset=utf-8");

		echo json_encode($stats);

		die();

	}

	/* detectionEntete() sert deux rôles:

	 1) détecter le type de colonne attendu à partir des textes de la ligne d'en-tête afin de define()

	 2) permet d'identifier les colonnes non-supportées/inutiles afin d'alléger le processus de parsing de PHPExcel

	 grace au ReadFilter (C'est le rôle de la valeur de retour)

	 La raison de la présence du paramètre $numeric_keys est que pour réussir à identifier les colonnes à exclure nous

	 devons traiter un tableau représentant la ligne d'en-tête aussi bien:

	  - sous forme associative pour PHPExcel (les clefs sont les lettres de l'alphabet)

	  - sous forme de clefs numériques (fgetcsv())

	  Le détecter après coup est difficile et pourtant cette distinction est importante car le comportement

	  d'array_merge() (réordonnancement des clefs numérique) n'est pas souhaitable dans le second cas. */

	static function detectionEntete($entete, $numeric_keys = FALSE) {

		$colonnes_reconnues = Array();

		$cols = FormateurGroupeColonne::nomEnsembleVersListeColonnes('standard,avance');

		foreach ($entete as $k => $v) {

			// traite les colonnes en faisant fi de la casse et des accents

			$entete_simple = iconv('UTF-8', 'ASCII//TRANSLIT', strtolower(trim($v)));

			foreach ($cols as $col) {

				$entete_officiel_simple = iconv('UTF-8', 'ASCII//TRANSLIT', strtolower(trim($col['nom'])));

				$entete_officiel_abbrev = $col['abbrev'];

				if ($entete_simple == $entete_officiel_simple || $entete_simple == $entete_officiel_abbrev) {

					// debug echo "define C_" . strtoupper($entete_officiel_abbrev) . ", $k ($v)\n";

					define("C_" . strtoupper($entete_officiel_abbrev), $k);

					$colonnes_reconnues[$k] = 1;

					break;

				}

				if (strpos($v, self::$prefixe_colonnes_etendues) === 0) {

					$colonnes_reconnues[$k] = 1;

					self::$indexes_colonnes_etendues[$k] = $v;

					break;

				}

			}

		}

		// défini tous les index que nous utilisons à une valeur d'index de colonne Excel qui n'existe pas dans

		// le tableau renvoyé par PHPExcel

		// Attention cependant d'utiliser des indexes différenciés car traiterLonLat() et traiterEspece()

		// les utilisent

		foreach ($cols as $col) {

			if (!defined('C_'.strtoupper($col['abbrev']))) {

				define('C_'.strtoupper($col['abbrev']), 'C_'.strtoupper($col['abbrev']));

			}

		}

		// prépare le filtre de PHPExcel qui évitera le traitement de toutes les colonnes superflues

		$colonnesID_non_reconnues = array_diff_key($entete, $colonnes_reconnues);

		// des colonnes de FormateurGroupeColonne::nomEnsembleVersListeColonnes()

		// ne retient que celles marquées "importables"

		$colonnes_automatiques = array_filter($cols, '__anonyme_1');

		// ne conserve que le nom long pour matcher avec la ligne XLS d'entête

		array_walk($colonnes_automatiques, '__anonyme_2');

		$colonnesID_a_exclure = array_intersect($entete, $colonnes_automatiques);

		if ($numeric_keys) {

			return $colonnesID_non_reconnues + $colonnesID_a_exclure;

		}

		return array_merge($colonnesID_non_reconnues, $colonnesID_a_exclure);

	}

	static function chargerCorrespondancesIdOrdre($cel, $lignes) {

		$ordresObs = array();

		foreach ($lignes as &$ligne) {

			$ordresObs[] = $ligne['ordre'];

		}

		$ordresObsConcat = implode(',', $ordresObs);

		$idUtilisateurP = Cel::db()->proteger($cel->id_utilisateur);

		$requete = 'SELECT id_observation, ordre '.

			'FROM cel_obs '.

			"WHERE ordre IN ($ordresObsConcat) ".

			"AND ce_utilisateur = $idUtilisateurP ".

			' -- '.__FILE__.':'.__LINE__;

		$resultats = Cel::db()->requeter($requete);

		$ordresIds = array();

		foreach ($resultats as &$infos) {

			$ordresIds[$infos['ordre']] = $infos['id_observation'];

		}

		return $ordresIds;

	}

	/*

	 * charge un groupe de lignes

	 */

	static function chargerLignes($cel, $lignes, $colonnes_statiques, &$dernier_ordre, $config) {

		$enregistrement = NULL;

		$enregistrements = array();

		$toutes_images = array();

		$tous_mots_cle = array();

		$tous_champs_etendus = array();

		foreach ($lignes as $ligne) {

			// dans le cas de fgetcsv, on peut avoir des false additionnel (cf do/while l. 279)

			if ($ligne === false) {

				continue;

			}

			// on a besoin des NULL pour éviter des notice d'index indéfini

			if (! array_filter($ligne, '__anonyme_3')) {

				continue;

			}

			if ($enregistrement = self::chargerLigne($ligne, $dernier_ordre, $cel, $config)) {

				// $enregistrements[] = array_merge($colonnes_statiques, $enregistrement);

				if ($enregistrement['latitude'] == NULL && $enregistrement['longitude'] == NULL) {

					if (isset($enregistrement['_champs_etendus']['latitudeDebutRue'])) {

						$enregistrement['latitude'] = $enregistrement['_champs_etendus']['latitudeDebutRue'];

						$enregistrement['longitude'] = $enregistrement['_champs_etendus']['longitudeDebutRue'];

					}

				}

				$enregistrements[] = $enregistrement;

				$pos = count($enregistrements) - 1;

				$last = &$enregistrements[$pos];

				if (isset($enregistrement['_images'])) {

					// ne dépend pas de cel_obs, et seront insérées *après* les enregistrements

					// mais nous ne voulons pas nous priver de faire des INSERT multiples pour autant

					$toutes_images[] = array(

						'images' => $last['_images'],

						'obs_pos' => $pos);

					// ce champ n'a pas à faire partie de l'insertion dans cel_obs,

					// mais est utile pour la liaison avec les images

					unset($last['_images']);

				}

				if (isset($enregistrement['_mots_cle'])) {

					// ne dépend pas de cel_obs, et seront insérés *après* les enregistrements

					// mais nous ne voulons pas nous priver de faire des INSERT multiples pour autant

					$tous_mots_cle[] = array(

						'mots_cle' => $last['_mots_cle'],

						'obs_pos' => $pos);

					unset($last['_mots_cle']);

				}

				if (isset($enregistrement['_champs_etendus'])) {

					$tous_champs_etendus[] = array(

						'champs_etendus' => $last['_champs_etendus'],

						'ordre' => $dernier_ordre);

					unset($last['_champs_etendus']);

				}

				$dernier_ordre++;

			}

		}

		return array($enregistrements, $toutes_images, $tous_mots_cle, $tous_champs_etendus);

	}

	static function trierColonnes(&$enregistrements) {

		foreach ($enregistrements as &$enregistrement) {

			$enregistrement = self::sortArrayByArray($enregistrement, self::$ordre_BDD);

		}

	}

	static function stockerMotsCle($enregistrements, $tous_mots_cle) {

		$c = 0;

		// debug: var_dump($tous_mots_cle);die;

		foreach ($tous_mots_cle as $v) {

			$c += count($v['mots_cle']['to_insert']);

		}

		return $c;

	}

	static function stockerImages($enregistrements, $toutes_images, $ordre_ids) {

		$valuesSql = array();

		foreach ($toutes_images as $images_pour_obs) {

			$obs = $enregistrements[$images_pour_obs['obs_pos']];

			$id_obs = $ordre_ids[$obs['ordre']]; // id réel de l'observation correspondant à l'ordre

			$transmission = $obs['transmission'];

			$date_transmission = 'NOW()'; // par défaut pour les nouveaux imports

			if ($obs['date_transmission'] != null) { // peut être NULL selon la valeur par défaut de la colonne, la version du SGBD, etc.

				$date_transmission = $obs['date_transmission'];

			}

			foreach ($images_pour_obs['images'] as $image) {

				$id_img = $image['id_image'];

				$valuesSql[] = "($id_img, $id_obs, NOW(), $transmission, $date_transmission)";

			}

		}

		if ($valuesSql) {

			$clauseValues = implode(', ', $valuesSql);

			// Utilisation de INSERT pour faire des UPDATE multiples en une seule requête

			$requete = 'INSERT INTO cel_images '.

				'(id_image, ce_observation, date_liaison, transmission, date_transmission) '.

				"VALUES $clauseValues ".

				'ON DUPLICATE KEY UPDATE '.

				'ce_observation = VALUES(ce_observation), '.

				'date_liaison = NOW(), '.

				'transmission = VALUES(transmission), '.

				'date_transmission = VALUES(date_transmission) '.

				' -- '.__FILE__.':'.__LINE__;

			Cel::db()->executer($requete);

		}

		return count($valuesSql);

	}

	/*

	 Aucune des valeurs présentes dans $enregistrement n'est quotée

	 cad aucune des valeurs retournée par traiter{Espece|Localisation}()

	 car ce tableau est passé à un PDO::preparedStatement() qui applique

	  proprement les règle d'échappement.

	*/

	static function chargerLigne($ligne, $dernier_ordre, $cel, $config) {

		// évite des notices d'index lors des trigger_error()

		$ref_ligne = !empty($ligne[C_NOM_SEL]) ? trim($ligne[C_NOM_SEL]) : '';

		// en premier car le résultat est utile pour

		// * traiter espèce (traiterEspece())

		// * traiter longitude et latitude (traiterLonLat())

		$referentiel = self::identReferentiel(trim(strtolower(@$ligne[C_NOM_REFERENTIEL])), $ligne, $ref_ligne);

		// $espece est rempli de plusieurs informations

		$espece = array(

			C_NOM_SEL => NULL,

			C_NOM_SEL_NN => NULL,

			C_NOM_RET => NULL,

			C_NOM_RET_NN => NULL,

			C_NT => NULL,

			C_FAMILLE => NULL);

		self::traiterEspece($ligne, $espece, $referentiel, $cel->taxon_info_webservice);

		if (!$espece[C_NOM_SEL]) {

			$referentiel = Cel::$fallback_referentiel;

		}

		if ($espece[C_NOM_SEL] && !$espece[C_NOM_SEL_NN]) {

			$referentiel = Cel::$fallback_referentiel;

		}

		// $localisation est rempli à partir de plusieurs champs: C_ZONE_GEO et C_CE_ZONE_GEO

		$localisation = Array(C_ZONE_GEO => NULL, C_CE_ZONE_GEO => NULL);

		self::traiterLocalisation($ligne, $localisation);

		//TODO: le jour où c'est efficace, traiter le pays à l'import

		// $transmission est utilisé pour date_transmission

		// XXX: @ contre "Undefined index"

		@$transmission = in_array(strtolower(trim($ligne[C_TRANSMISSION])), array(1, 'oui')) ? 1 : 0;

		// Dans ce tableau, seules devraient apparaître les données variable pour chaque ligne.

		// Dans ce tableau, l'ordre des clefs n'importe pas (cf: self::sortArrayByArray())

		$enregistrement = array(

			"ordre" => $dernier_ordre,

			"nom_sel" => $espece[C_NOM_SEL],

			"nom_sel_nn" => $espece[C_NOM_SEL_NN],

			"nom_ret" => $espece[C_NOM_RET],

			"nom_ret_nn" => $espece[C_NOM_RET_NN],

			"nt" => $espece[C_NT],

			"famille" => $espece[C_FAMILLE],

			"nom_referentiel" => $referentiel,

			"pays" => $ligne[C_PAYS],

			"zone_geo" => $localisation[C_ZONE_GEO],

			"ce_zone_geo" => $localisation[C_CE_ZONE_GEO],

			// $ligne: uniquement pour les infos en cas de gestion d'erreurs (date incompréhensible)

			"date_observation" => isset($ligne[C_DATE_OBSERVATION]) ? self::traiterDateObs($ligne[C_DATE_OBSERVATION], $ref_ligne) : null,

			"lieudit" => isset($ligne[C_LIEUDIT]) ? trim($ligne[C_LIEUDIT]) : null,

			"station" => isset($ligne[C_STATION]) ? trim($ligne[C_STATION]) : null,

			"milieu" => isset($ligne[C_MILIEU]) ? trim($ligne[C_MILIEU]) : null,

			"mots_cles_texte" => NULL, // TODO: foreign-key

			// XXX: @ contre "Undefined index"

			"commentaire" => isset($ligne[C_COMMENTAIRE]) ? trim($ligne[C_COMMENTAIRE]) : null,

			"transmission" => $transmission,

			"date_transmission" => $transmission ? date('Y-m-d H:i:s') : null, // pas de fonction SQL dans un PDO statement, <=> now()

			// $ligne: uniquement pour les infos en cas de gestion d'erreurs (lon/lat incompréhensible)

			"latitude" => isset($ligne[C_LATITUDE]) ? self::traiterLonLat(null, $ligne[C_LATITUDE], $referentiel, $ref_ligne) : null,

			"longitude" => isset($ligne[C_LONGITUDE]) ? self::traiterLonLat($ligne[C_LONGITUDE], null, $referentiel, $ref_ligne) : null,

			"altitude" => isset($ligne[C_ALTITUDE]) ? intval($ligne[C_ALTITUDE]) : null, // TODO: guess alt from lon/lat

			// @ car potentiellement optionnelles ou toutes vides => pas d'index dans PHPExcel (tableau optimisé)

			"abondance" => @$ligne[C_ABONDANCE],

			"certitude" => @$ligne[C_CERTITUDE],

			"phenologie" => @$ligne[C_PHENOLOGIE],

			"code_insee_calcule" => substr($localisation[C_CE_ZONE_GEO], -5) // varchar(5)

		);

		// passage de $enregistrement par référence, ainsi ['_images'] n'est défini

		// que si des résultats sont trouvés

		// "@" car PHPExcel supprime les colonnes null sur toute la feuille (ou tout le chunk)

		if (@$ligne[C_IMAGES]) {

			self::traiterImage($ligne[C_IMAGES], $cel->id_utilisateur, $enregistrement);

		}

		if (@$ligne[C_MOTS_CLES_TEXTE]) {

			self::traiterMotsCle($ligne[C_MOTS_CLES_TEXTE], $cel->id_utilisateur, $enregistrement, $config);

		}

		$champs_etendus = self::traiterChampsEtendus($ligne, self::$indexes_colonnes_etendues);

		if (!empty($champs_etendus)) {

			$enregistrement['_champs_etendus'] = $champs_etendus;

		}

		return $enregistrement;

	}

	static function traiterChampsEtendus(&$ligne, &$indexes_colonnes_etendues) {

		$champs_etendus_indexes = array();

		foreach($indexes_colonnes_etendues as $index_num => $label) {

			if (isset($ligne[$index_num])) {

				$champs_etendus_indexes[str_replace(self::$prefixe_colonnes_etendues, '', $label)] = $ligne[$index_num];

			}

		}

		return $champs_etendus_indexes;

	}

	static function traiterImage($str, $id_utilisateur, &$enregistrement) {

		$liste_images = array_filter(explode('/', $str));

		array_walk($liste_images, array(__CLASS__, '__anonyme_4'));

		$nomsOrignalConcat = implode(',', $liste_images);

		$requete = 'SELECT id_image, nom_original '.

			'FROM cel_images '.

			"WHERE ce_utilisateur = $id_utilisateur AND nom_original IN ($nomsOrignalConcat) ".

			' -- '.__FILE__.':'.__LINE__;

		$resultat = Cel::db()->requeter($requete);

		if ($resultat) {

			$enregistrement['_images'] = $resultat;

		}

	}

	static function traiterMotsCle($str, $id_utilisateur, &$enregistrement, $config) {

		$liste_mots_cle = $liste_mots_cle_recherche = array_map('trim', array_unique(array_filter(explode(',', $str))));

		array_walk($liste_mots_cle_recherche, array(__CLASS__, '__anonyme_4'));

		#if (self::$gestion_mots_cles == null) {

		if (true) {

			$gestion_mots_cles = new GestionMotsClesChemin($config, 'obs');

		}

		// Recherche des IDs des mots-cles

		$mots_cles_ids = $gestion_mots_cles->obtenirIdsMotClesPourMotsCles($liste_mots_cle, $id_utilisateur);

		// Y aura-t-il des nouvaux mots-cles

		foreach ($mots_cles_ids as $mot_cle) {

			$resultat[$mot_cle['id_mot_cle']] = $mot_cle['mot_cle'];

		}

		if ($resultat == null) {

			// array_diff() ne gère pas les NULL en entrée

			$nouveaux_mots_cles = $liste_mots_cle;

		} else {

			$nouveaux_mots_cles = array_diff($liste_mots_cle, $resultat);

		}

		// Ajout des mots-cles inexistants dans l'arbre

		if (count($nouveaux_mots_cles) > 0) {

			foreach ($nouveaux_mots_cles as $nmc) {

				$gestion_mots_cles->insererParChemin($nmc, '/', $id_utilisateur);

			}

			// Mise à jour des ids de mots-cles après ajout

			$mots_cles_ids = $gestion_mots_cles->obtenirIdsMotClesPourMotsCles($liste_mots_cle, $id_utilisateur);

		}

		$enregistrement['mots_cles_texte'] = implode(',', $liste_mots_cle);

		$enregistrement['_mots_cle'] = array(

			'existing' => $resultat,

			'to_insert' => $nouveaux_mots_cles

		);

	}

	/* FONCTIONS de TRANSFORMATION de VALEUR DE CELLULE */

	// TODO: PHP 5.3, utiliser date_parse_from_format()

	// TODO: parser les heures (cf product-owner)

	// TODO: passer par le timestamp pour s'assurer de la validité

	static function traiterDateObs($date, $ref_ligne) {

		// TODO: see https://github.com/PHPOffice/PHPExcel/issues/208

		// TODO: PHPExcel_Shared_Date::ExcelToPHP()

		if (is_double($date)) {

			if ($date > 0) {

				return PHPExcel_Style_NumberFormat::toFormattedString($date, PHPExcel_Style_NumberFormat::FORMAT_DATE_YYYYMMDD2) . " 00:00:00";

			}

			$msg = "ligne «{$ref_ligne}»: Attention: date antérieure à 1970 et format de cellule «DATE» utilisés ensemble";

			trigger_error($msg, E_USER_NOTICE);

		} else {

			// attend l'un des formats de

			// http://www.php.net/manual/fr/datetime.formats.date.php

			// le plus simple: YYYY/MM/DD (utilisé à l'export), mais DD-MM-YYYY est aussi supporté

			$matches = NULL;

			// et on essaie d'être sympa et supporter aussi DD/MM/YYYY

			if (preg_match(';^([0-3]?\d)/([01]\d)/([12]\d\d\d)$;', $date, $matches)) {

				$date = $matches[3] . '/' . $matches[2] . '/' . $matches[1];

			}

			$timestamp = strtotime($date);

			if (! $timestamp || $timestamp > time() + 3600 * 24 * 1) { // une journée d'avance maxi autorisée (décallage horaire ?)

				if ($date) {

					$msg = "ligne «{$ref_ligne}»: Attention: date erronée ($date)";

					trigger_error($msg, E_USER_NOTICE);

				}

				return NULL;

			}

			return strftime('%Y-%m-%d 00:00:00', $timestamp);

		}

	}

	static function identReferentiel($referentiel, $ligne, $ref_ligne) {

		// SELECT DISTINCT nom_referentiel, COUNT(id_observation) AS count FROM cel_obs GROUP BY nom_referentiel ORDER BY count DESC;

		if (strpos($referentiel, 'bdtfx') !== FALSE) {

			return 'bdtfx'; //:v1.01';

		}

		if (strpos($referentiel, 'bdtxa') !== FALSE) {

			return 'bdtxa'; //:v1.00';

		}

		if (strpos($referentiel, 'bdnff') !== FALSE) {

			return 'bdtfx';

		}

		if (strpos($referentiel, 'isfan') !== FALSE) {

			return 'isfan'; //:v1.00';

		}

		if (strpos($referentiel, 'apd') !== FALSE) {

			return 'apd'; //:v1.00';

		}

		if (strpos($referentiel, 'autre') !== FALSE) {

			return 'autre';

		}

		if ($referentiel && isset($ligne[C_NOM_SEL]) && $ligne[C_NOM_SEL]) {

			$msg = "ligne «{$ref_ligne}»: Attention: référentiel «{$referentiel}» inconnu";

			trigger_error($msg, E_USER_NOTICE);

			return 'autre';

		}

		return NULL;

	}

	static function traiterLonLat($lon = NULL, $lat = NULL, $referentiel = 'bdtfx', $ref_ligne) {

		// en CSV ces valeurs sont des string, avec séparateur en français (","; cf défauts dans ExportXLS)

		if ($lon && is_string($lon)) {

			$lon = str_replace(',', '.', $lon);

		}

		if ($lat && is_string($lat)) {

			$lat = str_replace(',', '.', $lat);

		}

		// sprintf applique une précision à 5 décimale (comme le ferait MySQL)

		// tout en uniformisant le format de séparateur des décimales (le ".")

		if ($lon && is_numeric($lon) && $lon >= -180 && $lon <= 180) {

			return sprintf('%.5F', $lon);

		}

		if ($lat && is_numeric($lat) && $lat >= -90 && $lat <= 90) {

			return sprintf('%.5F', $lat);

		}

		if ($lon || $lat) {

			trigger_error("ligne \"{$ref_ligne}\": " .

				  "Attention: longitude ou latitude erronée",

				  E_USER_NOTICE);

		}

		return NULL;

	}

	/*

	  TODO: s'affranchir du webservice pour la détermination du nom scientifique en s'appuyant sur cel_references,

	  pour des questions de performances

	*/

	static function traiterEspece($ligne, Array &$espece, &$referentiel, $taxon_info_webservice) {

		if (empty($ligne[C_NOM_SEL])) {

			return;

		}

		// nom_sel reste toujours celui de l'utilisateur

		$espece[C_NOM_SEL] = trim($ligne[C_NOM_SEL]);

		// XXX/attention, nous ne devrions pas accepter un référentiel absent !

		if (!$referentiel) {

			$referentiel = 'bdtfx';

		}

		$taxon_info_webservice->setReferentiel($referentiel);

		$ascii = iconv('UTF-8', 'ASCII//TRANSLIT', $ligne[C_NOM_SEL]);

		$determ = $taxon_info_webservice->rechercherInfosSurTexteCodeOuNumTax(trim($ligne[C_NOM_SEL]));

		// note: rechercherInfosSurTexteCodeOuNumTax peut ne retourner qu'une seule clef "nom_sel"

		if (! $determ) {

			// on supprime les noms retenus et renvoi tel quel

			// on réutilise les define pour les noms d'indexes, tant qu'à faire

			// XXX; tout à NULL sauf C_NOM_SEL ci-dessus ?

			$espece[C_NOM_SEL_NN] = @$ligne[C_NOM_SEL_NN];

			$espece[C_NOM_RET] = @$ligne[C_NOM_RET];

			$espece[C_NOM_RET_NN] = @$ligne[C_NOM_RET_NN];

			$espece[C_NT] = @$ligne[C_NT];

			$espece[C_FAMILLE] = @$ligne[C_FAMILLE];

			return;

		}

		// succès de la détection, mais résultat partiel

		if (!isset($determ->id)) {

			$determ = $taxon_info_webservice->effectuerRequeteInfosComplementairesSurNumNom($determ->{"nom_retenu.id"});

		}

		// ne devrait jamais arriver !

		if (!$determ) {

			die("erreur critique: " . __FILE__ . ':' . __LINE__);

		}

		// un schéma <ref>:(nt|nn):<num> (ie: bdtfx:nt:8503) a été passé