Subversion Repositories eFlore/Applications.cel

Rev

Rev 1646 | Rev 1649 | 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 ExportXLS::nomEnsembleVersListeColonnes()
// préfixés par C_  cf: detectionEntete()

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('ExportXLS.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);

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

class ImportXLS extends Cel  {

        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",
                "commentaire",
                "transmission",
                "date_creation",
                "date_modification",
                "latitude",
                "longitude",
                "phenologie",
                "code_insee_calcule"
        );

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

        // seconde possibilité
        // 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
        // colonnes statiques d'abord, les autres ensuite, dans l'ordre de $ordre_BDD
        static $insert_ligne_pattern_ordre;

        // seconde possibilité:
        // 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
        */
        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();

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

        function createElement($pairs) {
                if(!isset($pairs['utilisateur']) || trim($pairs['utilisateur']) == '') {
                        echo '0'; exit;
                }
                $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
                self::$insert_prefix_ordre = 'INSERT INTO cel_obs ('.
                        implode(', ', array_keys($this->colonnes_statiques)) .
                        ', ' .
                        implode(', ', array_diff(self::$ordre_BDD, array_keys($this->colonnes_statiques))) .
                        ') VALUES ';

                self::$insert_prefix = 'INSERT INTO cel_obs ('.
                        implode(', ', self::$ordre_BDD) . ') VALUES ';

                self::$insert_ligne_pattern_ordre =
                        '(' .
                        implode(', ', $this->colonnes_statiques) .
                        ', ' .
                        str_repeat('?, ', count(self::$ordre_BDD) - count($this->colonnes_statiques) - 1) .
                        '?' .
                        ')';

                self::$insert_ligne_pattern =
                        '(' .
                        implode(', ', array_values(array_map(
                                function($item) { return is_null($item) ? '?' : $item; },
                                array_merge(
                                        array_map(function() { return NULL; }, array_flip(self::$ordre_BDD)),
                                        $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))) {
                        $fichier = $fichier . '.' . $extension;
                }

                $objReader = PHPExcel_IOFactory::createReaderForFile($fichier);
                $objReader->setReadDataOnly(true);

                if(is_a($objReader, 'PHPExcel_Reader_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);
                // XXX: indépendant du readFilter ?
                $nb_lignes = $obj_infos[0]['totalRows'];

                $donnees = $objPHPExcel->getActiveSheet()->toArray(NULL, FALSE, FALSE, TRUE);
                $filtre->exclues = self::detectionEntete($donnees[1]);

                $obs_ajouts = 0;
                $obs_maj = 0;
                $dernier_ordre = $this->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);

                // 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) {
                        $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);
                        $donnees = $objPHPExcel->getActiveSheet()->toArray(NULL, FALSE, FALSE, TRUE);

                        // 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 public qui pourraient être statiques
                        // notamment dans RechercheInfosTaxonBeta.php
                        list($enregistrements, $images) =
                                self::chargerLignes($this, $donnees, $this->colonnes_statiques, $dernier_ordre);
                        if(! $enregistrements) break;

                        echo "===chunk\n";
                        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;

                        $this->bdd->beginTransaction();
                        $stmt = $this->bdd->prepare($sql_pattern);
                        $donnees = array();
                        foreach($enregistrements as $e) $donnees = array_merge($donnees, array_values($e));

                        echo $sql_pattern;
                        var_dump($enregistrements);
                        var_dump($donnees);die;

                        $stmt->execute($donnees);

                        // $stmt->debugDumpParams(); // https://bugs.php.net/bug.php?id=52384
                        //$this->bdd->commit();
                        $dernier_autoinc = $this->bdd->lastInsertId();
                        var_dump($dernier_autoinc);
                        die;



                        $obs_ajouts += count($enregistrements);
                        // $obs_ajouts += count($enregistrements['insert']);
                        // $obs_maj += count($enregistrements['update']);
                        self::stockerImages($this, $enregistrements, $images, $dernier_autoinc);
                }

                restore_error_handler();

                if($this->bilan) echo implode("\n", $this->bilan) . "\n";
                // fin: renvoi summary
                die("$obs_ajouts observations ajoutées");
        }

        static function detectionEntete($entete) {
                $colonnes_reconnues = Array();
                $cols = ExportXLS::nomEnsembleVersListeColonnes('standard');
                foreach($entete as $k => $v) {
                        $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;
                                }
                        }
                }

                // 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 ExportXLS::nomEnsembleVersListeColonnes()
                // ne retient que celles marquées "importables"
                $colonnes_automatiques = array_filter($cols, function($v) {     return !$v['importable']; });

                // ne conserve que le nom long pour matcher avec la ligne XLS d'entête
                array_walk($colonnes_automatiques, function(&$v) {      $v = $v['nom']; });

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

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

        /*
         * charge un groupe de lignes
         */
        static function chargerLignes($cel, $lignes, $colonnes_statiques, &$dernier_ordre) {
                $enregistrement = NULL;
                $enregistrements = Array();
                $toutes_images = Array();

                foreach($lignes as $ligne) {
                        //$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, function($cell) { return !is_null($cell); })) continue;

                        if( ($enregistrement = self::chargerLigne($ligne, $dernier_ordre, $cel)) ) {
                                // $enregistrements[] = array_merge($colonnes_statiques, $enregistrement);
                                $enregistrements[] = $enregistrement;

                                if(isset($enregistrement['_images'])) {
                                        $pos = count($enregistrements) - 1;
                                        $last = &$enregistrements[$pos];
                                        // 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 a faire partie de l'insertion dans cel_obs,
                                        // mais est utile pour cel_obs_images
                                        unset($last['_images']);
                                }

                                $dernier_ordre++;
                        }
                }

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


        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 stockerImages($cel, $enregistrements, $toutes_images, $lastid) {
                if(! $lastid) $lastid = rand();

                $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 = $lastid // dernier autoinc inséré
                                - count($enregistrements) - 1 // correspondrait au premier autoinc
                                + $images_pour_obs["obs_pos"]; // ordre d'insertion = ordre dans le tableau $enregistrements
                        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));
                        echo "$requete\n";
                }
        }


        static function chargerLigne($ligne, $dernier_ordre, $cel) {
                // en premier car le résultat est utile pour
                // traiter longitude et latitude (traiterLonLat())
                $referentiel = self::identReferentiel($ligne[C_NOM_REFERENTIEL]);

                // $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, $cel);

                // $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, $cel);

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

                        // $this->quoteNonNull() est déjà appliquée dans traiterEspece()
                        "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" => $cel->quoteNonNull($referentiel),

                        // $this->quoteNonNull() est déjà appliquée dans traiterLocalisation()
                        "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" => $cel->quoteNonNull(self::traiterDateObs($ligne[C_DATE_OBSERVATION], $ligne)),

                        "lieudit" => $cel->quoteNonNull(trim($ligne[C_LIEUDIT])),
                        "station" => $cel->quoteNonNull(trim($ligne[C_STATION])),
                        "milieu" => $cel->quoteNonNull(trim($ligne[C_MILIEU])),
                        "commentaire" => NULL, //$cel->quoteNonNull(trim($ligne[C_COMMENTAIRE])), // TODO: foreign-key


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

                        // $ligne: uniquement pour les infos en cas de gestion d'erreurs (lon/lat incompréhensible)
                        "latitude" => self::traiterLonLat(NULL, $ligne[C_LATITUDE], $referentiel, $ligne),
                        "longitude" => self::traiterLonLat($ligne[C_LONGITUDE], NULL, $referentiel, $ligne),

                        // @ 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" => $localisation[C_CE_ZONE_GEO] // TODO ?
                );

                // 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, $enregistrement);

                return $enregistrement;
        }

        static function traiterImage($str, $cel, &$enregistrement) {
                $liste_images = array_filter(explode("/", $str));
                array_walk($liste_images,
                                   function($item, $key, $obj) { $item = $obj->quoteNonNull_real(trim($item)); },
                                   $cel);
                $requete = sprintf(
                        "SELECT id_image, nom_original FROM cel_images WHERE ce_utilisateur = %d AND nom_original IN (\"%s\")",
                        $cel->id_utilisateur,
                        implode('","', $liste_images));

                $resultat = $cel->requeter($requete);

                if($resultat) $enregistrement['_images'] = $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, $ligne) {
                // TODO: see https://github.com/PHPOffice/PHPExcel/issues/208
                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 \"{$ligne[C_NOM_SEL]}\": " .
                                                  "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 {
                        $timestamp = strtotime($date);
                        if(! $timestamp) {
                                if($date) trigger_error("ligne \"{$ligne[C_NOM_SEL]}\": Attention: date erronée ($date)", E_USER_NOTICE);
                                return NULL;
                        }
                        return strftime("%Y-%m-%d 00:00:00", strtotime($date));
                }
        }

        static function identReferentiel($referentiel) {
                // SELECT DISTINCT nom_referentiel, COUNT(id_observation) AS count FROM cel_obs GROUP BY nom_referentiel ORDER BY count DESC;
                if(strpos(strtolower($referentiel), 'bdtfx') !== FALSE) return 'bdtfx:v1.01';
                if(strpos(strtolower($referentiel), 'bdtxa') !== FALSE) return 'bdtxa:v1.00';
                if(strpos(strtolower($referentiel), 'bdnff') !== FALSE) return 'bdnff:4.02';
                if(strpos(strtolower($referentiel), 'isfan') !== FALSE) return 'isfan:v1.00';

                if($referentiel) {
                        trigger_error("ligne \"{$ligne[C_NOM_SEL]}\": Attention: référentiel inconnu", E_USER_NOTICE);
                }
                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:v1.01', $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 \"{$ligne[C_NOM_SEL]}\": " .
                                                  "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;
                }
        }


        static function traiterEspece($ligne, Array &$espece, $cel) {
                if(!$ligne[C_NOM_SEL]) return;

                $taxon_info_webservice = new RechercheInfosTaxonBeta($cel->config);

                $ascii = iconv('UTF-8', 'ASCII//TRANSLIT', $ligne[C_NOM_SEL]);
                // FALSE = recherche étendue (LIKE x%)
                $resultat_recherche_espece = $taxon_info_webservice->rechercherInfosSurTexteCodeOuNumTax($ligne[C_NOM_SEL]);

                // on supprime les noms retenus et renvoi tel quel
                // on réutilise les define pour les noms d'indexes, tant qu'à faire
                if (empty($resultat_recherche_espece['en_id_nom'])) {
                        $espece[C_NOM_SEL] = $cel->quoteNonNull(trim($ligne[C_NOM_SEL]));

                        // le reste reste à NULL
                        // TODO: si empty(C_NOM_SEL) et !empty(C_NOM_SEL_NN) : recherche info à partir de C_NOM_SEL_NN
                        $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, récupération des infos
                $espece[C_NOM_SEL] = $cel->quoteNonNull($resultat_recherche_espece['nom_sel']);
                $espece[C_NOM_SEL_NN] = $cel->quoteNonNull($resultat_recherche_espece['en_id_nom']);

                $complement = $taxon_info_webservice->rechercherInformationsComplementairesSurNumNom($resultat_recherche_espece['en_id_nom']);
                $espece[C_NOM_RET] = $cel->quoteNonNull($complement['Nom_Retenu']);
                $espece[C_NOM_RET_NN] = $cel->quoteNonNull($complement['Num_Nom_Retenu']);
                $espece[C_NT] = $cel->quoteNonNull($complement['Num_Taxon']);
                $espece[C_FAMILLE] = $cel->quoteNonNull($complement['Famille']);
        }


        static function traiterLocalisation($ligne, Array &$localisation, $cel) {
            $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, $cel->quoteNonNull_real($nom_commune), $cel->quoteNonNull_real($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, $cel->quoteNonNull_real($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, $cel->quoteNonNull_real($nom_commune.'%'));
                }
        
                $resultat_commune = $cel->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] = $cel->quoteNonNull($localisation[C_ZONE_GEO]);
                $localisation[C_CE_ZONE_GEO] = $cel->quoteNonNull($localisation[C_CE_ZONE_GEO]);
        }



        /* HELPERS */

        // http://stackoverflow.com/questions/348410/sort-an-array-based-on-another-array
        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:v1.01') return Array(
                        'NORD' => 51.2, // Dunkerque
                        'SUD' => 41.3, // Bonifacio
                        'EST' => 9.7, // Corse
                        'OUEST' => -5.2); // Ouessan
                return FALSE;
        }


        public function initialiser_colonnes_statiques() {
                $this->colonnes_statiques = array_merge($this->colonnes_statiques,
                                                                                                Array(
                                                                                                        "ce_utilisateur" => $this->id_utilisateur,
                                                                                                        "prenom_utilisateur" => $this->quoteNonNull_real($this->utilisateur['prenom']),
                                                                                                        "nom_utilisateur" => $this->quoteNonNull_real($this->utilisateur['nom']),
                                                                                                        "courriel_utilisateur" => $this->quoteNonNull_real($this->utilisateur['courriel']),
                                                                                                ));

        }

        private function quoteNonNull_real($chaine) {
                if(is_null($chaine)) return "NULL";
                if(!is_string($chaine)) die("erreur __FILE__, __LINE__");
                return $this->bdd->quote($chaine);
        }

        // équivalent à CEL->Bdd->proteger() (qui wrap PDO::quote),
        // sans transformer NULL en ""
        private function quoteNonNull($chaine) {
                return $chaine;
                if(is_null($chaine)) return "NULL";
                if(!is_string($chaine)) die("erreur __FILE__, __LINE__");
                return $this->bdd->quote($chaine);
        }

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