| New file |
|---|
| 0,0 → 1,1240 |
|---|
| <?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; |
| } |
| } |
| ?> |
| Property changes: |
|---|
| Added: svnkit:entry:sha1-checksum |
|---|
| +e0804924c0e3cfd0355754a5dbd2050a5012db06 |
|---|
| \ No newline at end of property |
|---|