Subversion Repositories eFlore/Applications.cel

Rev

Rev 1933 | Rev 2122 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | RSS feed

<?php
/**
 * @category  PHP
 * @package   jrest
 * @author    Raphaël Droz <raphael@tela-botania.org>
 * @copyright 2013 Tela-Botanica
 * @license   http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt Licence CECILL
 * @license GPL v3 <http://www.gnu.org/licenses/gpl.txt>
 */

/**
 * 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
 *  
 **/

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);
require_once('lib/PHPExcel/Classes/PHPExcel.php');
require_once('FormateurGroupeColonne.php');


date_default_timezone_set("Europe/Paris");

// 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 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;
    } 
} 

// XXX: PHP 5.3
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",
        "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 $id_utilisateur = NULL;

    // erreurs d'import
    public $bilan = Array();

    // cache (pour traiterLocalisation() pour l'instant)
    static $cache = Array('geo' => array());

    function ImportXLS($config) {
        parent::__construct($config);
    }

    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);

        // initialisation du statement PDO/MySQL
        // première version, pattern de requête pas génial
        /* list(self;;$insert_prefix_ordre, self::$insert_ligne_pattern_ordre) =
           $this->initialiser_pdo_ordered_statements($this->colonnes_statiques); */
        list(self::$insert_prefix, self::$insert_ligne_pattern) =
            $this->initialiser_pdo_statements($this->colonnes_statiques);

        $infos_fichier = array_pop($_FILES);
                
        /*$objPHPExcel = PHPExcel_IOFactory::load($infos_fichier['tmp_name']);
          $donnees = $objPHPExcel->getActiveSheet()->toArray(NULL,FALSE,FALSE,TRUE);*/

        /*$objReader = PHPExcel_IOFactory::createReader("Excel5");
          $objReader->setReadDataOnly(true);
          $objPHPExcel = $objReader->load($infos_fichier['tmp_name']);*/

        //var_dump($donnees);

        // 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))) { // XXX: @ safe-mode
            $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;

        $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);

                /* recharge avec $filtre actif (filtre sur lignes colonnes):
                   - exclue les colonnes inutiles/inutilisables)
                   - ne selectionne que les lignes dans le range [$ligne - $ligne + NB_LIRE_LIGNE_SIMUL] */
                $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);
                }

            }

            // var_dump($donnees, get_defined_constants(true)['user']);die;
            // ici on appel la fonction qui fera effectivement l'insertion multiple
            // à partir des (au plus) NB_LIRE_LIGNE_SIMUL lignes

            // TODO: passer $this, ne sert que pour appeler des méthodes publiques qui pourraient être statiques
            list($enregistrements, $images, $mots_cle) =
                self::chargerLignes($this, $donnees, $this->colonnes_statiques, $dernier_ordre);
            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_ordre . ', ', $nb_rec - 1) .
                self::$insert_ligne_pattern_ordre;

            $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));

             // echo $sql_pattern . "\n"; var_dump($enregistrements, $donnees); die; // debug ici

            $stmt->execute($donnees);

            // $stmt->debugDumpParams(); // https://bugs.php.net/bug.php?id=52384
            $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);
            // $obs_ajouts += count($enregistrements['insert']);
            // $obs_maj += count($enregistrements['update']);
            
            $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);
        }

        restore_error_handler();

        if($this->bilan) echo implode("\n", $this->bilan) . "\n";
        printf('%1$d observation%2$s ajoutée%2$s' . "\n" .
               '%3$d image%4$s attachée%4$s' . "\n" .
               // '%5$d mot%6$c-clef ajouté%6$c [TODO]' . "\n" . // TODO
               (count($filtre->exclues) > 0 ? 'colonne%7$s non-traitée%7$s: %8$s' . "\n" : ''),

               $obs_ajouts,
               $obs_ajouts > 1 ? 's' : '',
               $nb_images_ajoutees,
               $nb_images_ajoutees > 1 ? 's' : '',
               $nb_mots_cle_ajoutes,
               $nb_mots_cle_ajoutes > 1 ? 's' : '',
               count($filtre->exclues) > 1 ? 's' : '',
               implode(', ', $filtre->exclues));
        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;
                }
            }
        }
        // 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

        // eg: diff ( Array( H => Commune, I => rien ) , Array( H => 1, K => 1 )
        // ==> Array( I => rien )
        $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');

        // intersect ( Array ( N => Milieu, S => Ordre ), Array ( ordre => Ordre, phenologie => Phénologie ) )
        // ==> Array ( S => Ordre, AA => Phénologie )
        $colonnesID_a_exclure = array_intersect($entete, $colonnes_automatiques);

        if($numeric_keys) {
            return $colonnesID_non_reconnues + $colonnesID_a_exclure;
        }
        // TODO: pourquoi ne pas comparer avec les abbrevs aussi ?
        // merge ( Array( I => rien ) , Array ( S => Ordre, AA => Phénologie ) )
        // ==> Array ( I => rien, AA => Phénologie )
        return array_merge($colonnesID_non_reconnues, $colonnesID_a_exclure);
    }
    
    static function chargerCorrespondancesIdOrdre($cel, $lignes) {
        
        $ordre_ids = array();
    
        $requete_obs_ids = "SELECT id_observation, ordre FROM cel_obs WHERE ordre IN (";
        foreach($lignes as &$ligne) {
                $requete_obs_ids .= $ligne['ordre'].',';
        }
        $requete_obs_ids = rtrim($requete_obs_ids, ',');
        $requete_obs_ids .= ") AND ce_utilisateur = ".Cel::db()->proteger($cel->id_utilisateur);
        
        
        $obs_ids = Cel::db()->requeter($requete_obs_ids);
        foreach($obs_ids as &$obs) {
                $ordre_ids[$obs['ordre']] = $obs['id_observation'];
        }
        return $ordre_ids;
    }

    /*
     * charge un groupe de lignes
     */
    static function chargerLignes($cel, $lignes, $colonnes_statiques, &$dernier_ordre) {
        $enregistrement = NULL;
        $enregistrements = Array();
        $toutes_images = Array();
        $tous_mots_cle = 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;

            //$ligne = array_filter($ligne, function($cell) { return !is_null($cell); });
            //if(!$ligne) 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)) ) {
                // $enregistrements[] = array_merge($colonnes_statiques, $enregistrement);
                $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 cel_obs_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);
                    // la version inlinée des mots est enregistrées dans cel_obs
                    // mais cel_mots_cles_obs fait foi.
                    // XXX: postponer l'ajout de ces informations dans cel_obs *après* l'insertion effective
                    // des records dans cel_mots_cles_obs ?
                    unset($last['_mots_cle']);
                }

                $dernier_ordre++;
            }
        }

        // XXX future: return Array($enregistrements_a_inserer, $enregistrements_a_MAJ, $toutes_images);
        return Array($enregistrements, $toutes_images, $tous_mots_cle);
    }


    static function trierColonnes(&$enregistrements) {
        foreach($enregistrements as &$enregistrement) {
            $enregistrement = self::sortArrayByArray($enregistrement, self::$ordre_BDD);
            //array_walk($enregistrement, function(&$item, $k) { $item = is_null($item) ? "NULL" : $item; });
            //$req .= implode(', ', $enregistrement) . "\n";
        }
    }


    static function stockerMotsCle($enregistrements, $tous_mots_cle, $lastid) {
        $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) {
        $images_insert = 'INSERT INTO cel_obs_images (id_image, id_observation) VALUES %s ON DUPLICATE KEY UPDATE id_image = id_image';
        $images_obs_assoc = 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
            foreach($images_pour_obs['images'] as $image) {
                $images_obs_assoc[] = sprintf('(%d,%d)',
                                              $image['id_image'], // intval() useless
                                              $id_obs); // intval() useless
            }
        }

        if($images_obs_assoc) {
            $requete = sprintf($images_insert, implode(', ', $images_obs_assoc));
            // debug echo "$requete\n";
            Cel::db()->requeter($requete);
        }

        return count($images_obs_assoc);
    }

    /*
      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) {
        // é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);

        // $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,

            "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);

        return $enregistrement;
    }

    static function traiterImage($str, $id_utilisateur, &$enregistrement) {
        $liste_images = array_filter(explode("/", $str));

        //array_walk($liste_images, '__anonyme_4');
        array_walk($liste_images, array(__CLASS__, '__anonyme_4'));
        $requete = sprintf(
            "SELECT id_image, nom_original FROM cel_images WHERE ce_utilisateur = %d AND nom_original IN (%s)",
            $id_utilisateur,
            implode(',', $liste_images));

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

        if($resultat) $enregistrement['_images'] = $resultat;
    }

    static function traiterMotsCle($str, $id_utilisateur, &$enregistrement) {
        $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'));

        // TODO!!!! remplace > (pour les tests uniquement) par un = et supprimer le group by mot_cle
        $requete = sprintf("SELECT id_mot_cle_obs, mot_cle FROM cel_mots_cles_obs WHERE id_utilisateur > %d ".
                           "AND mot_cle IN (%s) ".
                           "GROUP BY mot_cle",
                           $id_utilisateur,
                           implode(',', $liste_mots_cle_recherche));

        $resultat_sql = Cel::db()->requeter($requete);
        if(!$resultat_sql) return;

        $resultat = array();
        foreach($resultat_sql as $v) $resultat[$v['id_mot_cle_obs']] = $v['mot_cle'];

        $enregistrement['mots_cles_texte'] = implode(',', $liste_mots_cle);
        $enregistrement['_mots_cle'] = array("existing" => $resultat,
                                             "to_insert" => array_diff($liste_mots_cle, $resultat));
    }


    /* 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";
            trigger_error("ligne \"{$ref_ligne}\": " .
                          "Attention: date antérieure à 1970 et format de cellule \"DATE\" utilisés ensemble",
                          E_USER_NOTICE);

            // throw new Exception("erreur: date antérieure à 1970 et format de cellule \"DATE\" utilisés ensemble");

            // attention, UNIX timestamp, car Excel les décompte depuis 1900
            // cf http://fczaja.blogspot.fr/2011/06/convert-excel-date-into-timestamp.html
            // $timestamp = ($date - MIN_DATES_DIFF) * 60 * 60 * 24 - time(); // NON

            // $timestamp = PHPExcel_Calculation::getInstance()->calculateFormula("=" . $date . "-DATE(1970,1,1)*60*60*24"); // NON

            // echo strftime("%Y/%m/%d 00:00:00", $timestamp); // NON
        }
        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) trigger_error("ligne \"{$ref_ligne}\": Attention: date erronée ($date)", 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 'bdnff'; //:4.02';
        if(strpos($referentiel, 'bdnff') !== FALSE) return 'bdtfx';
        if(strpos($referentiel, 'isfan') !== FALSE) return 'isfan'; //:v1.00';
        if(strpos($referentiel, 'autre') !== FALSE) return 'autre';

        if($referentiel && isset($ligne[C_NOM_SEL]) && $ligne[C_NOM_SEL]) {
            trigger_error("ligne \"{$ref_ligne}\": Attention: référentiel \"{$referentiel}\" inconnu", E_USER_NOTICE);
            return 'autre';
        }

        // pas de référentiel ou pas de NOM_SEL: NULL
        return NULL;
        /* TODO: cf story,
           En cas de NULL faire une seconde passe de détection à partir du nom saisi
           + accepter les n° de version */
    }

    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;

        /* limite france métropole si bdtfx ? ou bdtxa ? ...
           NON!
           Un taxon d'un référentiel donné peut être théoriquement observé n'importe où sur le globe.
           Il n'y a pas lieu d'effectuer des restriction ici.
           Cependant des erreurs fréquentes (0,0 ou lon/lat inversées) peuvent être détectés ici.
           TODO */
        $bbox = self::getReferentielBBox($referentiel);
        if(!$bbox) return NULL;

        if($lon) {
            if($lon < $bbox['EST'] && $lon > $bbox['OUEST']) return is_numeric($lon) ? $lon : NULL;
            else return NULL;
        }
        if($lat) {
            if($lat < $bbox['NORD'] && $lat > $bbox['SUD']) return is_numeric($lat) ? $lat : NULL;
            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])) {
            // TODO: nous ne déclarons pas "Numéro nomenclatural" comme colonne importable
            // Nous ne pouvons donc pas tenter d'être sympa sur la détermination par num_nom
            /* if(!empty($ligne[C_NOM_SEL_NN]) && $referentiel != Cel::$fallback_referentiel)
               $ligne[C_NOM_SEL] = $referentiel . ':nn:' . $ligne[C_NOM_SEL_NN];
               else */
            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]);

        // TODO: si empty(C_NOM_SEL) et !empty(C_NOM_SEL_NN) : recherche info à partir de C_NOM_SEL_NN
        // echo "rechercherInformationsComplementairesSurNom()\n";
        /*
          SELECT num_nom, nom_sci, num_nom_retenu ,auteur, annee, biblio_origine, nom_sci,auteur  FROM bdtfx_v1_01  WHERE (nom_sci LIKE 'Heliotropium europaeum')  ORDER BY nom_sci ASC   LIMIT 0, 1
          #
          SELECT num_nom, nom_sci, num_nom_retenu ,auteur, annee, biblio_origine, nom_sci,auteur  FROM bdtfx_v1_01  WHERE (nom_sci LIKE 'eliotropium euro')  ORDER BY nom_sci ASC   LIMIT 0, 1
          SELECT num_nom, nom_sci, num_nom_retenu ,auteur, annee, biblio_origine, nom_sci,auteur  FROM bdtfx_v1_01  WHERE (nom_sci LIKE 'eliotropium')  ORDER BY nom_sci ASC   LIMIT 0, 1
          SELECT num_nom, nom_sci, num_nom_retenu ,auteur, annee, biblio_origine, nom_sci,auteur  FROM bdtfx_v1_01  WHERE (nom_sci LIKE 'eliotropium% euro%')  ORDER BY nom_sci ASC   LIMIT 0, 1
          #

          SELECT nom_sci, num_nom_retenu, nom_sci_html, auteur, annee, biblio_origine FROM bdtfx_v1_01 WHERE num_nom = 31468
        */
        // $determ = $taxon_info_webservice->rechercherInformationsComplementairesSurNom($ligne[C_NOM_SEL]);
        // permet une reconnaissance de bdtfx:nn:XXXX
        $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;
        // et des info complémentaires

        /*
        // GET /service:eflore:0.1/bdtfx/noms/31468?retour.champs=nom_sci,auteur,id,nom_retenu_complet,nom_retenu.id,num_taxonomique,famille
        /home/raphael/eflore/projets/services/modules/0.1/bdtfx/Noms.php:280
        SELECT  *, nom_sci   FROM bdtfx_v1_01    WHERE num_nom = '31468' 
        SELECT nom_sci, num_nom_retenu, nom_sci_html, auteur, annee, biblio_origine FROM bdtfx_v1_01 WHERE num_nom = 31468
        SELECT nom_sci, num_nom_retenu, nom_sci_html, auteur, annee, biblio_origine FROM bdtfx_v1_01 WHERE num_nom = 86535
        */


        //var_dump($complement, $espece);die;
    }

    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;
    }


    /*
     * TODO: analyse rigoureuse:
     * == Identifiant Commune
     * - INSEE-C:\d{5}
     * - \d{5}
     * - \d{2}
     * == Commune
     * - \w+ (\d{2})
     * - \w+ (\d{5})
     * - \w+
     *
     */
    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;
                }
            }

            if(! $cache_attempted && ($resultat_commune = Cel::db()->requeter(sprintf("SELECT DISTINCT nom, CONCAT('INSEE-C:', code) AS code FROM cel_zones_geo WHERE code = %s LIMIT 1",
                                                                                      self::quoteNonNull($departement)))) ) {
                $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;
            }
            ;
            // if(strlen($departement) == 4) $departement = "INSEE-C:0" . $departement;
            // if(strlen($departement) == 5) $departement = "INSEE-C:" . $departement;
            // if(strlen($departement) <= 9) return "INSEE-C:0" . $departement; // ? ... TODO

            $departement = trim($departement); // TODO

            $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;
        }
        // TODO: levenstein sort ?
        // TODO: count résultat !

        // 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;
        // if(strlen($departement) <= 9) return "INSEE-C:0" . $departement; // ? ... TODO

        $departement = trim($departement); // TODO

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

    /*
      static function traiterLocalisation($ligne, Array &$localisation) {
      $identifiant_commune = trim($ligne[C_ZONE_GEO]);
      if(!$identifiant_commune) {
      $departement = trim($ligne[C_CE_ZONE_GEO]);
      goto testdepartement;
      }


      $select = "SELECT DISTINCT nom, code  FROM cel_zones_geo";
        
      if (preg_match('/(.*) \((\d+)\)/', $identifiant_commune, $elements)) {
      // commune + departement : montpellier (34)
      $nom_commune=$elements[1];
      $code_commune=$elements[2];
      $requete = sprintf("%s WHERE nom = %s AND code LIKE %s",
      $select, self::quoteNonNull($nom_commune), self::quoteNonNull($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.'%'));
      }
        
      $resultat_commune = Cel::db()->requeter($requete);
      // TODO: levenstein sort ?

      // 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] = $resultat_commune[0]['code'];
      }

      $departement = &$localisation[C_CE_ZONE_GEO];

      testdepartement:
      if(strpos($departement, "INSEE-C:", 0) === 0) goto protectloc;

      if(!is_numeric($departement)) goto protectloc; // TODO ?
      if(strlen($departement) == 4) $departement = "INSEE-C:0" . $departement;
      if(strlen($departement) == 5) $departement = "INSEE-C:" . $departement;
      // if(strlen($departement) <= 9) return "INSEE-C:0" . $departement; // ? ... TODO

      $departement = trim($departement); // TODO

      protectloc:
      $localisation[C_ZONE_GEO] = $localisation[C_ZONE_GEO];
      $localisation[C_CE_ZONE_GEO] = $localisation[C_CE_ZONE_GEO];
      }
    */


    /* 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 à Bdd2->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;
    }
}