Subversion Repositories eFlore/Applications.coel

<?php
/**
 * Exemple lancement:
 * /opt/lampp/bin/php -d memory_limit=3500M cli.php import -n
 */
class Import extends Script {
        private $bdd = null;
        private $auteurs = array();
        protected $parametres_autorises = array(
                        '-n' => array(true, false, 'Nom du fichier à importer.'),
                        '-u' => array(false, false, 'Infos utilisateur sous forme de JSON contenant : id, session et ip'));
        
        protected $table_publication = null;
        protected $table_auteur = null;
        protected $table_publication_a_auteur = null;
        protected $table_meta = null;
        
        protected $id_table_publication = null;
        protected $id_table_publication_personne = null;
        
        protected $id_role_auteur = null;
        
        protected $colonnes_obligatoires = array();
        protected $colonnes_acceptees = array();
        
        protected $cache_auteur = array();
        protected $auteurs_a_publis = array();
        protected $publis_a_auteurs = array();
        
        protected $id_utilisateur = 0;
        protected $id_session = 0;
        protected $ip_utilisateur = "127.0.01";
        
        const ETAT_AJOUTER = 1;
        
        public function __construct($script_nom, $parametres) {
                parent::__construct($script_nom, $parametres);
                $this->bdd = new Bdd();
        }
        
        public function executer() {
                try {
                        $this->initialiserScript();
                        $cmd = $this->getParametre('a');
                        $fichier = $this->getParametre('n');
                        $utilisateur = $this->getParametre('u');
                        
                        $this->traiterInfosUtilisateur($utilisateur);
                        
                        switch ($cmd) {
                                case "collections" :
                                        $resultat = $this->chargerCollections($fichier); break;
                                case "publi" :
                                        $resultat = $this->chargerPubli($fichier); break;
                                default :
                                        $this->traiterErreur('Erreur : la commande "%s" n\'existe pas!', array($cmd));
                        }
                } catch (Exception $erreur) {
                        $this->traiterErreur($erreur->getMessage());
                }
                
                // renvoi du résultat vers la sortie php
                // car le script est surtout destiné à être appelé par un web service
                echo $resultat;
                exit;
        }
        
        private function traiterInfosUtilisateur($utilisateur) {
                $utilisateur_infos = json_decode($utilisateur, true);
                if(!empty($utilisateur_infos)) {
                        $this->id_utilisateur = !empty($utilisateur_infos['id']) ? $utilisateur_infos['id'] : $this->id_utilisateur;
                        $this->id_session = !empty($utilisateur_infos['session']) ? $utilisateur_infos['session'] : $this->id_session;
                        $this->ip_utilisateur = !empty($utilisateur_infos['ip']) ? $utilisateur_infos['ip'] : $this->ip_utilisateur;
                }
        }
        
        private function initialiserScript() {
                $fichierIni = $this->getScriptChemin().'import.ini';
                if (file_exists($fichierIni)) {
                        Config::charger($fichierIni);
                } else {
                        $erreur = "Veuillez configurer le projet en créant le fichier 'import.ini' ".
                                        "dans le dossier du module de script du projet à partir du fichier 'import.defaut.ini'.";
                        throw new Exception($erreur);
                }
                
                $this->colonnes_obligatoires= Config::get('champs_obligatoires');
                $this->colonnes_acceptees = Config::get('champs');
                
                $tables = Config::get('tables');
                $this->table_publication = $tables['publication'];
                $this->table_auteur = $tables['auteur'];
                $this->table_publication_a_auteur = $tables['publication_a_auteur'];
                $this->table_meta = $tables['meta'];
                
                $this->id_table_publication = $tables['id_table_publication'];
                $this->id_table_publication_personne = $tables['id_table_publication_personne'];
                
                $this->id_role_auteur = $tables['id_role_auteur'];
        }
        
        private function chargerCollections($fichier) {
                //ouvrir le fichier - collection
                // vérifier le nom des colonnes
                // tester l'existence de la structure
                // si oui récupérer l'id
                //sinon créer la structure et récupérer son id
                // remplacer le nom de la structure par son id
                // créer les collections et récupérer leur id
                //ouvrir le fichier collection botanique
                // vérifier les colonnes
                // remplacer les noms des collections par leur id (créé précédemment)
                // créer/importer
                
        }

        private function chargerPubli($fichier) {
                
                // vérification existence fichier
                if(!file_exists(Config::get('dossiertmp').$fichier)) {
                        $erreur = "Le fichier ".Config::get('dossiertmp').$fichier." n'existe pas.";
                        throw new Exception($erreur);
                }
                
                $pointeur = fopen(Config::get('dossiertmp').$fichier, "r");
                // Chargement de la première colonne (qui contient les noms de colonnes à importer
                $colonnes = fgetcsv($pointeur, 0, ";");

                // Vérification des colonnes obligatoires et en même temps du séparateur 
                if(count($colonnes) < 2 || !array_intersect(array_keys($this->colonnes_obligatoires), $colonnes)) {
                        $erreur = "Le fichier ne contient pas les colonnes obligatoires : ".implode(',', array_keys($this->colonnes_obligatoires))."\n";
                        $erreur .= "ou bien n'est pas séparé par le caractère ';' ";
                        throw new Exception($erreur);
                }
                
                
                //TODO: vérifier si les deux index ci dessous ne font pas double emploi
                
                // Création d'un index des colonnes qui seront importées dans la fiche en les associant 
                // au numéro de colonne dans la feuille csv
                $index_colonnes_importees = array_intersect(array_keys($this->colonnes_acceptees), $colonnes);
                $colonnes_importees = array();
                foreach($index_colonnes_importees as $index_colonne_importee) {
                        $colonnes_importees[] = $this->colonnes_acceptees[$index_colonne_importee];
                }
                
                $index_colonnes_refusees = array_keys(array_diff($colonnes, array_keys($this->colonnes_acceptees)));
                // Création d'un index associant chaque numéro de colonne importée à son rôle
                // pour y apporter des traitement spécifiques
                $index_colonnes_importees = $colonnes;
                foreach($index_colonnes_refusees as $colonne_refusee) {
                        unset($index_colonnes_importees[$colonne_refusee]);
                }
                
                $roles_a_num_colonnes = array_flip($index_colonnes_importees);
                        
                // Ajout de la colonne nom complet aux champs de la requête
                $colonnes_importees[] = 'cpu_fmt_nom_complet';

                $nb_publis_inserees = 0;
                $lignes = array();
                while($ligne = fgetcsv($pointeur, 0, ";")) {
                        $ligne_inseree = array();
                        
                        // Traitement des champs suivant leur role
                        foreach($ligne as $index => &$valeur) {
                                if(!in_array($index, $index_colonnes_refusees)) {
                                        $ligne_inseree[] = $this->traiterChamp($valeur, $index_colonnes_importees[$index]);
                                }
                        }
                        
                        // Ajout du nom complet formaté de la publication
                        $nom_complet = $this->bdd->proteger($this->formaterNomComplet($ligne, $index_colonnes_importees));
                        $ligne_inseree[] = $nom_complet;
                        
                        $id_publication = $this->insererPublication($colonnes_importees, $ligne_inseree);
                        // TODO: quoi faire en cas d'échec pour une publication ?
                        if(!empty($id_publication)) {   
                                $nb_publis_inserees++;
                                // Pour aller plus vite on pourrait éventuellement faire une grosse requete d'ajout des publications
                                // à personne à la fin, mais ça nous priverait de faire une transaction (TODO: faire une transaction)
                                $nb_auteurs_lies = $this->insererLiensPublicationAuteurs($id_publication, $ligne[$roles_a_num_colonnes['auteur']]);
                        }

                }
                        
                return $nb_publis_inserees;
        }
        
        
        private function insererPublication(&$colonnes, &$publication) {                
                $requete = "INSERT INTO ".$this->table_publication." ".
                                "(".implode(',', $colonnes).") ".
                                "VALUES (".implode(",", $publication).")";
                                        
                $insertion = $this->bdd->executer($requete);
                $id_publi = $this->bdd->recupererIdDernierAjout();

                // Historisation de l'ajout
                $histo = $this->creerXmlHisto(array_combine($colonnes, $publication));
                $id_meta = $this->historiser($this->id_table_publication, $id_publi, $histo);
                // Affectation des méta données concernat l'ajout à la publication
                $requete_affectation_meta = "UPDATE  ".$this->table_publication." ".
                                "SET cpu_ce_meta = ".$id_meta." ".
                                "WHERE cpu_id_publication = ".$id_publi;

                $this->bdd->executer($requete_affectation_meta);
                
                return $id_publi;
        }
        
        protected function insererLiensPublicationAuteurs($id_publication, &$auteurs) {
                $colonnes = array('cpuap_id_publication', 'cpuap_id_personne', 'cpuap_id_role', 'cpuap_ce_truk_type', 'cpuap_ordre', 'cpuap_ce_meta');
                $requete = "INSERT IGNORE INTO ".$this->table_publication_a_auteur." ".
                                "(".implode(",", $colonnes).") VALUES ";
                
                // L'ordre des auteurs commence à 1
                $ordre_auteur = 1; 
                
                // Découpage des différents auteurs
                $auteurs_tab = explode(',', $auteurs);
                $auteurs_tab = array_filter($auteurs_tab);
                
                // Les auteurs sont normalement cités dans l'ordre dans l'import
                foreach($auteurs_tab as $auteur) {                      
                        // si les infos auteurs sont un tableau dans le cache alors l'id existe bien en base de données
                        if(is_array($this->cache_auteur[$auteur])) {                            
                                $id_auteur = $this->cache_auteur[$auteur]['cp_id_personne'];
                                
                                $valeurs = array($id_publication, $id_auteur, $this->id_role_auteur, "NULL", $ordre_auteur, "0");
                        
                                $requete_insertion = $requete." (".implode(',', $valeurs).") ";
                                $liaison = $this->bdd->executer($requete_insertion);
                                                                
                                // Historisation de l'ajout
                                $histo = $this->creerXmlHisto(array_combine($colonnes, $liaison));
                                $cle_liaison = $id_publication.'-'.$this->id_role_auteur.'-'.$id_auteur;
                                $id_meta = $this->historiser($this->id_table_publication_personne, $cle_liaison, $histo);
                                
                                // Affectation des méta données concernant l'ajout à la publication à auteur
                                $requete_affectation_meta = "UPDATE  ".$this->table_publication_a_auteur." ".
                                                "SET cpuap_ce_meta = ".$id_meta;
                                $this->bdd->executer($requete_affectation_meta);
                        }
                        // L'ordre des auteurs est conservé même pour ceux qui n'existe pas dans la bdd 
                        $ordre_auteur++;
                }
        }
        
        protected function creerXmlHisto($donnees) {
                // Création du xml de l'enregistrement à historiser
                $info = null;
                $xml_tpl = '<?xml version="1.0" encoding="UTF-8" ?>'."\n<resultset>\n<row>\n%s</row>\n</resultset>";
                $xml = null;
                        
                foreach ($donnees as $cle => $valeur) {
                        // Pour éviter un éventuel double échappement des valeurs
                        $valeur = stripslashes($valeur);
                        $valeur = trim($valeur, "'");
                        if (!is_null($valeur) && $valeur != '') {
                                $xml .= "<$cle>$valeur</$cle>\n";
                        }
                }
                if ($xml !== null) {
                        $info = sprintf($xml_tpl, $xml);
                        $info = $this->bdd->proteger($info);
                }
        
                return $info;
        }
        
        protected function historiser($table_id, $ligne_cle, $info) {
                date_default_timezone_set('Europe/Paris');
                // Pré-traitement des variables
                $info = (is_null($info)) ? 'NULL' : $info;
        
                // Historisation (Ajout des méta-données)
                $requete =      'INSERT INTO coel_meta_historique_ligne '.
                                '       (cmhl_ce_table, cmhl_cle_ligne, cmhl_enregistrement, cmhl_date_modification, cmhl_ce_modifier_par, cmhl_ce_etat, cmhl_ip, cmhl_session_id) '.
                                'VALUES ('.
                                "               $table_id, ".
                                '               "'.$ligne_cle.'", '.
                                "               $info, ".
                                '               "'.date('Y-m-d H:i:s', time()).'", '.
                                "               $this->id_utilisateur, ".
                                "               ".self::ETAT_AJOUTER.", ".
                                '               "'.$this->ip_utilisateur.'", '.
                                '               "'.$this->id_session.'") ';
                $resultat = $this->bdd->executer($requete);
                return $this->bdd->recupererIdDernierAjout();
        }
        
        protected function formaterNomComplet($ligne, $roles) {
                
                $roles = array_flip($roles);
                
                // Intitulé de la publication complet : fmt_auteur, date_parution(année). titre. Editeur (nom), collection, fascicule, indication_nvt. pages.
                // indication_nvt = serie_tome 
                $champs_nom_complet = array('auteur', 'annee', 'titre', 'editeur', 'intitule_revue', 'fascicule', 'serie_tome', 'pages');
                $champs_fmt = array();
                
                $fmt_nom_complet = "";
                
                foreach($champs_nom_complet as $champ) {
                        $index = $roles[$champ];
                        if(!isset($ligne[$index])) {                            
                                $champs_fmt[$champ] = "";
                        } else {
                                $champs_fmt[$champ] = $ligne[$index];
                        }
                }
                
                $indication_nvt_pages = array($champs_fmt['serie_tome'], $champs_fmt['pages']);
                $indication_nvt_pages = array_filter($indication_nvt_pages, 'strlen');
                $indication_nvt_pages = trim(implode(". ", $indication_nvt_pages));
                $indication_nvt_pages .= !empty($indication_nvt_pages) ? "." : "";
                
                $annee_titre_editeur = array($champs_fmt['annee'], $champs_fmt['titre'], $champs_fmt['editeur']);
                $annee_titre_editeur = array_filter($annee_titre_editeur, 'strlen');
                $annee_titre_editeur = trim(implode(". ", $annee_titre_editeur));
                
                $fmt_nom_complet =  array($champs_fmt['auteur'], 
                                                        $annee_titre_editeur, 
                                                        $champs_fmt['intitule_revue'],
                                                        $champs_fmt['fascicule'],
                                                        $indication_nvt_pages);
                
                $fmt_nom_complet = array_filter($fmt_nom_complet, 'strlen');
                $fmt_nom_complet = implode(", ", $fmt_nom_complet);
                
                return $fmt_nom_complet;
        }
        
        private function traiterChamp($valeur, $role) {
                switch($role) {
                        case 'auteur':
                                $valeur = $this->traiterChampAuteur($valeur);
                        break;
                        case 'editeur':
                                $valeur = 'AUTRE##'.$valeur;
                        break;
                }
                
                return $this->bdd->proteger($valeur);
        }
        
        private function traiterChampAuteur($auteur_intitule) {
                $auteurs_fmt = array();
                $auteurs_tab = explode(',', $auteur_intitule);
                foreach($auteurs_tab as $auteur) {
                        if(!empty(trim($auteur))) {
                                $auteurs_fmt[] = $this->obtenirInfosAuteur($auteur);
                        }
                }
                
                return implode(', ', $auteurs_fmt);
        }
        
        private function obtenirInfosAuteur($auteur_intitule) {
                $retour = $auteur_intitule;
                // Si on déjà recherché et trouvé (ou non l'auteur)
                if(isset($this->cache_auteur[$auteur_intitule])) {
                        // On renvoie son nom complet formaté s'il existe en bdd ou sinon
                        // le nom qui a été donné dans la feuille csv
                        $retour = !empty($this->cache_auteur[$auteur_intitule]['cp_fmt_nom_complet']) ?
                                $this->cache_auteur[$auteur_intitule]['cp_fmt_nom_complet'] :
                                $auteur_intitule;
                } else {
                        // Recherche de l'auteur sur un maximum du combinaisons possible des variations
                        // de son nom et prénom
                        $auteur = $this->fabriquerCombinaisonsAuteur($auteur_intitule);
                        $auteur_req = "(".implode(', ', $auteur).")";
                        
                        $requete = "SELECT cp_id_personne, cp_fmt_nom_complet FROM ".$this->table_auteur." WHERE cp_fmt_nom_complet IN ".$auteur_req;
                        $infos_auteur = $this->bdd->recupererTous($requete);
                                                
                        // Stockage en cache de la ligne de bdd si trouvé,
                        // de la valeur brute sinon
                        if(!empty($infos_auteur)) {
                                $retour = $infos_auteur[0]['cp_fmt_nom_complet'];
                                $this->cache_auteur[$auteur_intitule] = $infos_auteur[0];
                                // Stocker le nom d'auteur sous les deux formes (fmt nom complet et tel que saisi), facilite la recherche
                                // plus tard lors de la liaison des publications aux auteurs
                                $this->cache_auteur[$infos_auteur[0]['cp_fmt_nom_complet']] = $infos_auteur[0];
                        } else {
                                $retour = $auteur_intitule;
                                $this->cache_auteur[$auteur_intitule] = $auteur_intitule;
                        }
                }
                
                return $retour;
        }
                        
        private function fabriquerCombinaisonsAuteur($auteur) {
                
                $auteur = trim($auteur);
                $auteurs_formates = array($this->bdd->proteger($auteur));
                
                // Séparation des élements de l'auteur des espaces pour obtenir
                // les noms et prénoms (Ex. "Carl Von Linné" => "Carl", "Von", "Linné")
                $auteur_tab = explode(' ', $auteur);
                $auteur_tab = array_filter($auteur_tab);
                
                $combinaisons = array();
                foreach($auteur_tab as &$element_auteur) {
                        $combinaisons[] = array(
                                                                // élement tel quel (Ex: "Linné")
                                                                $element_auteur,
                                                                // possibilité de l'initiale seule (Ex: "L")
                                                                substr($element_auteur, 0, 1),
                                                                // possibilité de l'initiale avec un point du genre (Ex: "L.")
                                                                substr($element_auteur, 0, 1)."."
                                                        );
                }
                
                // Fabrication de toutes les combinaisons possibles des parties de noms ci-dessus 
                // pour deux et trois élements en faisant plusieurs produits cartésiens
                // car le nom peut être combiné différement de celui en base de données
                // (Ex. : "Carl Von Linné" VS "C. Von Linné" ou "C. V. Linné" ou encore "Von Linné C." etc...)
                
                // C'est moche et pas très élégant mais bon ça marche dans 90% des cas
                // On ne teste pas plus que 3 combinaisons, car ça serait très très couteux
                // TODO: faire mieux et factoriser les appels ci dessous
                if(count($auteur_tab) > 2) {
                        // Cas du nom à trois parties (genre "Carl Von Linné")
                        $possibilites_auteurs = $this->cartesian(array($combinaisons[0], $combinaisons[1], $combinaisons[2]));
                        $possibilites_auteurs = array_merge($possibilites_auteurs, $this->cartesian(array($combinaisons[0], $combinaisons[2], $combinaisons[1])));
                        $possibilites_auteurs = array_merge($possibilites_auteurs, $this->cartesian(array($combinaisons[1], $combinaisons[2], $combinaisons[0])));
                        $possibilites_auteurs = array_merge($possibilites_auteurs, $this->cartesian(array($combinaisons[1], $combinaisons[0], $combinaisons[2])));
                        $possibilites_auteurs = array_merge($possibilites_auteurs, $this->cartesian(array($combinaisons[2], $combinaisons[1], $combinaisons[0])));
                        $possibilites_auteurs = array_merge($possibilites_auteurs, $this->cartesian(array($combinaisons[2], $combinaisons[0], $combinaisons[1])));
                } else {
                        // Cas du nom à trois parties (genre "Carl Linné")
                        $possibilites_auteurs = $this->cartesian(array($combinaisons[0], $combinaisons[1]));
                        $possibilites_auteurs = array_merge($possibilites_auteurs, $this->cartesian(array($combinaisons[1], $combinaisons[0])));
                }
                
                $auteurs_formates = array();
                foreach($possibilites_auteurs as &$possibilite) {
                        $initiales = true;
                        // Suppression des possibilités ne contenant que des initiales avec ou sans point
                        foreach($possibilite as &$chars) {
                                $initiales = $initiales && mb_strlen($chars) <= 2;
                        }

                        if(!$initiales) {
                                $auteurs_formates[] = $this->bdd->proteger(implode(" ", $possibilite));
                        }
                }

                return $auteurs_formates;
        }

        // http://stackoverflow.com/questions/6311779/finding-cartesian-product-with-php-associative-arrays
        function cartesian($input) {
                // filter out empty values
                $input = array_filter($input);
        
                $result = array(array());
        
                foreach ($input as $key => $values) {
                        $append = array();
        
                        foreach($result as $product) {
                                foreach($values as $item) {
                                        $product[$key] = $item;
                                        $append[] = $product;
                                }
                        }
        
                        $result = $append;
                }
        
                return $result;
        }
}
?>