Subversion Repositories eFlore/Applications.cel

Rev

Rev 3474 | Blame | Compare with Previous | Last modification | View Log | RSS feed

<?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é
                // dans ce cas on met à jour le référentiel avec celui passé dans le champ espèce
                if (isset($determ->ref)) {
                        $referentiel = $determ->ref;
                }

                // succès de la détection
                // nom_sel est remplacé, mais seulement si un motif spécial à été utilisé (bdtfx:nn:4567)
                if ($taxon_info_webservice->is_notation_spe) {
                        $espece[C_NOM_SEL] = $determ->nom_sci;
                }

                // écrasement des numéros (nomenclatural, taxonomique) saisis...
                $espece[C_NOM_SEL_NN] = $determ->id;
                $espece[C_NOM_RET] = RechercheInfosTaxonBeta::supprimerBiblio($determ->nom_retenu_complet);
                $espece[C_NOM_RET_NN] = $determ->{"nom_retenu.id"};
                $espece[C_NT] = $determ->num_taxonomique;
                $espece[C_FAMILLE] = $determ->famille;
                return;
        }

        static function detectFromNom($nom) {
                $r = Cel::db()->requeter(sprintf("SELECT num_nom, num_tax_sup FROM bdtfx_v1_01 WHERE (nom_sci LIKE '%s') ".
                        "ORDER BY nom_sci ASC LIMIT 0, 1",
                        Cel::db()->proteger($nom)));
                if ($r) {
                        return $r;
                }

                Cel::db()->requeter(sprintf("SELECT num_nom, num_tax_sup FROM bdtfx_v1_01 WHERE (nom_sci LIKE '%s' OR nom LIKE '%s') ".
                        "ORDER BY nom_sci ASC LIMIT 0, 1",
                        Cel::db()->proteger($nom),
                        Cel::db()->proteger(str_replace(' ', '% ', $nom))));
                return $r;
        }

        static function traiterLocalisation($ligne, Array &$localisation) {
                if (empty($ligne[C_ZONE_GEO])) {
                        $ligne[C_ZONE_GEO] = NULL;
                }
                if (empty($ligne[C_CE_ZONE_GEO])) {
                        $ligne[C_CE_ZONE_GEO] = NULL;
                }

                $identifiant_commune = trim($ligne[C_ZONE_GEO]);
                if (!$identifiant_commune) {
                        $departement = trim($ligne[C_CE_ZONE_GEO]);

                        if (strpos($departement, 'INSEE-C:', 0) === 0) {
                                $localisation[C_CE_ZONE_GEO] = trim($ligne[C_CE_ZONE_GEO]);
                                if (array_key_exists($localisation[C_CE_ZONE_GEO], self::$cache['geo'])) {
                                        $localisation[C_ZONE_GEO] = self::$cache['geo'][$localisation[C_CE_ZONE_GEO]];
                                } else {
                                        $nom = Cel::db()->requeter(sprintf("SELECT nom FROM cel_zones_geo WHERE code = %s LIMIT 1",
                                                self::quoteNonNull(substr($localisation[C_CE_ZONE_GEO], strlen("INSEE-C:")))));
                                        if ($nom) {
                                                $localisation[C_ZONE_GEO] = $nom[0]['nom'];
                                        }
                                        self::$cache['geo'][$localisation[C_CE_ZONE_GEO]] = @$nom[0]['nom'];
                                }
                                return;
                        }

                        if (!is_numeric($departement)) {
                                $localisation[C_CE_ZONE_GEO] = $ligne[C_CE_ZONE_GEO];
                                return;
                        }

                        $cache_attempted = FALSE;
                        if(array_key_exists($departement, self::$cache['geo'])) {
                                $cache_attempted = TRUE;
                                if (self::$cache['geo'][$departement][0] && self::$cache['geo'][$departement][1]) {
                                        $localisation[C_ZONE_GEO] = self::$cache['geo'][$departement][0];
                                        $localisation[C_CE_ZONE_GEO] = self::$cache['geo'][$departement][1];
                                        return;
                                }
                        }

                        $requete = "SELECT DISTINCT nom, CONCAT('INSEE-C:', code) AS code ".
                                'FROM cel_zones_geo '.
                                'WHERE code = %s '.
                                'LIMIT 1 '.
                                ' -- '.__FILE__.':'.__LINE__;
                        $resultat_commune = Cel::db()->requeter(sprintf($requete, self::quoteNonNull($departement)));
                        if (! $cache_attempted && $resultat_commune) {
                                $localisation[C_ZONE_GEO] = $resultat_commune[0]['nom'];
                                $localisation[C_CE_ZONE_GEO] = $resultat_commune[0]['code'];
                                self::$cache['geo'][$departement] = array($resultat_commune[0]['nom'], $resultat_commune[0]['code']);
                                return;
                        }
                        $localisation[C_CE_ZONE_GEO] = $ligne[C_CE_ZONE_GEO];
                        return;
                }

                $select = "SELECT DISTINCT nom, code FROM cel_zones_geo";

                if (preg_match('/(.+) \((\d{1,5})\)/', $identifiant_commune, $elements)) {
                        // commune + departement : montpellier (34)
                        $nom_commune=$elements[1];
                        $code_commune=$elements[2];
                        if (strlen($code_commune) <= 2) {
                                $requete = sprintf("%s WHERE nom = %s AND code LIKE %s",
                                        $select, self::quoteNonNull($nom_commune),
                                        self::quoteNonNull($code_commune.'%'));
                        } else {
                                $requete = sprintf("%s WHERE nom = %s AND code = %d",
                                        $select, self::quoteNonNull($nom_commune),
                                        $code_commune);
                        }
                } elseif (preg_match('/^(\d+|(2[ab]\d+))$/i', $identifiant_commune, $elements)) {
                        // Code insee seul
                        $code_insee_commune=$elements[1];
                        $requete = sprintf("%s WHERE code = %s", $select, self::quoteNonNull($code_insee_commune));
                } else {
                        // Commune seule (le departement sera recupere dans la colonne departement si elle est presente)
                        // on prend le risque ici de retourner une mauvaise Commune
                        $nom_commune = str_replace(" ", "%", iconv('UTF-8', 'ASCII//TRANSLIT', $identifiant_commune));
                        $requete = sprintf("%s WHERE nom LIKE %s", $select, self::quoteNonNull($nom_commune.'%'));
                }

                if (array_key_exists($identifiant_commune, self::$cache['geo'])) {
                        $resultat_commune = self::$cache['geo'][$identifiant_commune];
                } else {
                        $resultat_commune = Cel::db()->requeter($requete);
                        self::$cache['geo'][$identifiant_commune] = $resultat_commune;
                }

                // cas de la commune introuvable dans le référentiel
                // réinitialisation aux valeurs du fichier XLS
                if (! $resultat_commune) {
                        $localisation[C_ZONE_GEO] = trim($ligne[C_ZONE_GEO]);
                        $localisation[C_CE_ZONE_GEO] = trim($ligne[C_CE_ZONE_GEO]);
                } else {
                        $localisation[C_ZONE_GEO] = $resultat_commune[0]['nom'];
                        $localisation[C_CE_ZONE_GEO] = "INSEE-C:" . $resultat_commune[0]['code'];
                        return;
                }

                $departement =& $localisation[C_CE_ZONE_GEO];

                if (strpos($departement, "INSEE-C:", 0) === 0) {
                        $localisation[C_ZONE_GEO] = $localisation[C_ZONE_GEO];
                        $localisation[C_CE_ZONE_GEO] = $localisation[C_CE_ZONE_GEO];
                }

                if (!is_numeric($departement)) {
                        $localisation[C_ZONE_GEO] = $localisation[C_ZONE_GEO];
                        $localisation[C_CE_ZONE_GEO] = $localisation[C_CE_ZONE_GEO];
                }

                if (strlen($departement) == 4) {
                        $departement = "INSEE-C:0$departement";
                }
                if (strlen($departement) == 5) {
                        $departement = "INSEE-C:$departement";
                }
                $departement = trim($departement);

                $localisation[C_ZONE_GEO] = $localisation[C_ZONE_GEO];
                $localisation[C_CE_ZONE_GEO] = $localisation[C_CE_ZONE_GEO];
        }

        public static function stockerChampsEtendus($champs_etendus, $ordre_ids, $config) {
                // singleton du pauvre mais l'export est suffisamment inefficace pour s'en priver
                self::$gestion_champs_etendus = self::$gestion_champs_etendus == null ?
                        new GestionChampsEtendus($config, 'obs') :
                        self::$gestion_champs_etendus;

                $champs_etendus_obs = array();
                foreach ($champs_etendus as $champ_etendu_a_obs) {
                        $id_obs = $ordre_ids[$champ_etendu_a_obs['ordre']]; // id réel de l'observation correspondant à l'ordre
                        foreach ($champ_etendu_a_obs['champs_etendus'] as $label => $champ) {
                                // XXX: insère t'on des valeurs vides ?
                                $valeur = $champ;
                                $cle = $label;

                                if (!empty($cle) && !empty($valeur)) {
                                        $champ_etendu_a_inserer = new ObsEtendue();
                                        $champ_etendu_a_inserer->id = $id_obs;
                                        $champ_etendu_a_inserer->cle = $cle;
                                        $champ_etendu_a_inserer->valeur = $valeur;

                                        $champs_etendus_obs[] = $champ_etendu_a_inserer;
                                }
                        }
                }

                self::$gestion_champs_etendus->ajouterParLots($champs_etendus_obs);
                //TODO: que faire si l'insertion des champs étendus échoue ?
                return count($champs_etendus_obs);
        }

        /* HELPERS */

        // http://stackoverflow.com/questions/348410/sort-an-array-based-on-another-array
        // XXX; utilisé aussi (temporairement ?) par FormateurGroupeColonne.
        static function sortArrayByArray($array, $orderArray) {
                $ordered = array();
                foreach($orderArray as $key) {
                        if (array_key_exists($key, $array)) {
                                $ordered[$key] = $array[$key];
                                unset($array[$key]);
                        }
                }
                return $ordered + $array;
        }

        // retourne une BBox [N,S,E,O) pour un référentiel donné
        static function getReferentielBBox($referentiel) {
                if ($referentiel == 'bdtfx') {
                        return Array(
                                'NORD' => 51.2, // Dunkerque
                                'SUD' => 41.3, // Bonifacio
                                'EST' => 9.7, // Corse
                                'OUEST' => -5.2); // Ouessan
                }
                return FALSE;
        }

        // ces valeurs ne sont pas inséré via les placeholders du PDO::preparedStatement
        // et doivent donc être échappées correctement.
        public function initialiser_colonnes_statiques() {
                $this->colonnes_statiques = array_merge($this->colonnes_statiques,
                        array(
                                'ce_utilisateur' => self::quoteNonNull($this->id_utilisateur), // peut-être un hash ou un id
                                'prenom_utilisateur' => self::quoteNonNull($this->utilisateur['prenom']),
                                'nom_utilisateur' => self::quoteNonNull($this->utilisateur['nom']),
                                'courriel_utilisateur' => self::quoteNonNull($this->utilisateur['courriel']),
                        ));
        }

        static function initialiser_pdo_ordered_statements($colonnes_statiques) {
                return Array(
                        // insert_ligne_pattern_ordre
                        sprintf('INSERT INTO cel_obs (%s, %s) VALUES',
                                implode(', ', array_keys($colonnes_statiques)),
                                implode(', ', array_diff(self::$ordre_BDD, array_keys($colonnes_statiques)))),

                        // insert_ligne_pattern_ordre
                        sprintf('(%s, %s ?)',
                                implode(', ', $colonnes_statiques),
                                str_repeat('?, ', count(self::$ordre_BDD) - count($colonnes_statiques) - 1))
                );
        }

        static function initialiser_pdo_statements($colonnes_statiques) {
                return Array(
                        // insert_prefix
                        sprintf('INSERT INTO cel_obs (%s) VALUES ',
                                implode(', ', self::$ordre_BDD)),


                        // insert_ligne_pattern, cf: self::$insert_ligne_pattern
                        '(' .
                        // 3) créé une chaîne de liste de champ à inséré en DB
                        implode(', ', array_values(
                        // 2) garde les valeurs fixes (de $colonnes_statiques),
                        // mais remplace les NULL par des "?"
                        array_map('__anonyme_5',
                                  // 1) créé un tableau genre (nom_sel_nn => NULL) depuis self::$ordre_BDD
                                  // et écrase certaines valeurs avec $colonnes_statiques (initilisé avec les données utilisateur)
                                  array_merge(array_map('__anonyme_6', array_flip(self::$ordre_BDD)), $colonnes_statiques
                                  )))) .
                        ')'
                );
        }

        // équivalent à Bdd->proteger() (qui wrap PDO::quote),
        // sans transformer NULL en ""
        static function quoteNonNull($chaine) {
                if (is_null($chaine)) {
                        return 'NULL';
                }
                if (!is_string($chaine) && !is_integer($chaine)) {
                        die('erreur: ' . __FILE__ . ':' . __LINE__);
                }
                return Cel::db()->quote($chaine);
        }

        public function erreurs_stock($errno, $errstr) {
                $this->bilan[] = $errstr;
        }
}
?>