1855 |
delphine |
1 |
<?php
|
|
|
2 |
/**
|
|
|
3 |
* Exemple lancement:
|
|
|
4 |
* /opt/lampp/bin/php -d memory_limit=3500M cli.php import -n
|
|
|
5 |
*/
|
|
|
6 |
class Import extends Script {
|
|
|
7 |
private $bdd = null;
|
|
|
8 |
private $auteurs = array();
|
|
|
9 |
protected $parametres_autorises = array(
|
1882 |
aurelien |
10 |
'-n' => array(true, false, 'Nom du fichier à importer.'),
|
|
|
11 |
'-u' => array(false, false, 'Infos utilisateur sous forme de JSON contenant : id, session et ip'));
|
1855 |
delphine |
12 |
|
1857 |
aurelien |
13 |
protected $table_publication = null;
|
|
|
14 |
protected $table_auteur = null;
|
1862 |
aurelien |
15 |
protected $table_publication_a_auteur = null;
|
1882 |
aurelien |
16 |
protected $table_meta = null;
|
1857 |
aurelien |
17 |
|
1882 |
aurelien |
18 |
protected $id_table_publication = null;
|
|
|
19 |
protected $id_table_publication_personne = null;
|
|
|
20 |
|
1862 |
aurelien |
21 |
protected $id_role_auteur = null;
|
|
|
22 |
|
1856 |
aurelien |
23 |
protected $colonnes_obligatoires = array();
|
|
|
24 |
protected $colonnes_acceptees = array();
|
1855 |
delphine |
25 |
|
1856 |
aurelien |
26 |
protected $cache_auteur = array();
|
1862 |
aurelien |
27 |
protected $auteurs_a_publis = array();
|
|
|
28 |
protected $publis_a_auteurs = array();
|
1856 |
aurelien |
29 |
|
1882 |
aurelien |
30 |
protected $id_utilisateur = 0;
|
|
|
31 |
protected $id_session = 0;
|
|
|
32 |
protected $ip_utilisateur = "127.0.01";
|
|
|
33 |
|
|
|
34 |
const ETAT_AJOUTER = 1;
|
|
|
35 |
|
1855 |
delphine |
36 |
public function __construct($script_nom, $parametres) {
|
|
|
37 |
parent::__construct($script_nom, $parametres);
|
|
|
38 |
$this->bdd = new Bdd();
|
|
|
39 |
}
|
|
|
40 |
|
|
|
41 |
public function executer() {
|
|
|
42 |
try {
|
|
|
43 |
$this->initialiserScript();
|
|
|
44 |
$cmd = $this->getParametre('a');
|
|
|
45 |
$fichier = $this->getParametre('n');
|
1882 |
aurelien |
46 |
$utilisateur = $this->getParametre('u');
|
|
|
47 |
|
|
|
48 |
$this->traiterInfosUtilisateur($utilisateur);
|
|
|
49 |
|
1855 |
delphine |
50 |
switch ($cmd) {
|
1928 |
delphine |
51 |
case "collections" :
|
|
|
52 |
$resultat = $this->chargerCollections($fichier); break;
|
|
|
53 |
case "publi" :
|
|
|
54 |
$resultat = $this->chargerPubli($fichier); break;
|
1855 |
delphine |
55 |
default :
|
|
|
56 |
$this->traiterErreur('Erreur : la commande "%s" n\'existe pas!', array($cmd));
|
|
|
57 |
}
|
|
|
58 |
} catch (Exception $erreur) {
|
|
|
59 |
$this->traiterErreur($erreur->getMessage());
|
|
|
60 |
}
|
1857 |
aurelien |
61 |
|
|
|
62 |
// renvoi du résultat vers la sortie php
|
1862 |
aurelien |
63 |
// car le script est surtout destiné à être appelé par un web service
|
1857 |
aurelien |
64 |
echo $resultat;
|
1875 |
aurelien |
65 |
exit;
|
1855 |
delphine |
66 |
}
|
|
|
67 |
|
1882 |
aurelien |
68 |
private function traiterInfosUtilisateur($utilisateur) {
|
|
|
69 |
$utilisateur_infos = json_decode($utilisateur, true);
|
|
|
70 |
if(!empty($utilisateur_infos)) {
|
|
|
71 |
$this->id_utilisateur = !empty($utilisateur_infos['id']) ? $utilisateur_infos['id'] : $this->id_utilisateur;
|
|
|
72 |
$this->id_session = !empty($utilisateur_infos['session']) ? $utilisateur_infos['session'] : $this->id_session;
|
|
|
73 |
$this->ip_utilisateur = !empty($utilisateur_infos['ip']) ? $utilisateur_infos['ip'] : $this->ip_utilisateur;
|
|
|
74 |
}
|
|
|
75 |
}
|
|
|
76 |
|
1855 |
delphine |
77 |
private function initialiserScript() {
|
|
|
78 |
$fichierIni = $this->getScriptChemin().'import.ini';
|
|
|
79 |
if (file_exists($fichierIni)) {
|
|
|
80 |
Config::charger($fichierIni);
|
|
|
81 |
} else {
|
1856 |
aurelien |
82 |
$erreur = "Veuillez configurer le projet en créant le fichier 'import.ini' ".
|
|
|
83 |
"dans le dossier du module de script du projet à partir du fichier 'import.defaut.ini'.";
|
1855 |
delphine |
84 |
throw new Exception($erreur);
|
|
|
85 |
}
|
1856 |
aurelien |
86 |
|
|
|
87 |
$this->colonnes_obligatoires= Config::get('champs_obligatoires');
|
|
|
88 |
$this->colonnes_acceptees = Config::get('champs');
|
1857 |
aurelien |
89 |
|
|
|
90 |
$tables = Config::get('tables');
|
|
|
91 |
$this->table_publication = $tables['publication'];
|
|
|
92 |
$this->table_auteur = $tables['auteur'];
|
1862 |
aurelien |
93 |
$this->table_publication_a_auteur = $tables['publication_a_auteur'];
|
1882 |
aurelien |
94 |
$this->table_meta = $tables['meta'];
|
1862 |
aurelien |
95 |
|
1882 |
aurelien |
96 |
$this->id_table_publication = $tables['id_table_publication'];
|
|
|
97 |
$this->id_table_publication_personne = $tables['id_table_publication_personne'];
|
|
|
98 |
|
1862 |
aurelien |
99 |
$this->id_role_auteur = $tables['id_role_auteur'];
|
1855 |
delphine |
100 |
}
|
1928 |
delphine |
101 |
|
|
|
102 |
private function chargerCollections($fichier) {
|
|
|
103 |
//ouvrir le fichier - collection
|
|
|
104 |
// vérifier le nom des colonnes
|
|
|
105 |
// tester l'existence de la structure
|
|
|
106 |
// si oui récupérer l'id
|
|
|
107 |
//sinon créer la structure et récupérer son id
|
|
|
108 |
// remplacer le nom de la structure par son id
|
|
|
109 |
// créer les collections et récupérer leur id
|
|
|
110 |
//ouvrir le fichier collection botanique
|
|
|
111 |
// vérifier les colonnes
|
|
|
112 |
// remplacer les noms des collections par leur id (créé précédemment)
|
|
|
113 |
// créer/importer
|
|
|
114 |
|
|
|
115 |
}
|
1855 |
delphine |
116 |
|
1928 |
delphine |
117 |
private function chargerPubli($fichier) {
|
1855 |
delphine |
118 |
|
1856 |
aurelien |
119 |
// vérification existence fichier
|
|
|
120 |
if(!file_exists(Config::get('dossiertmp').$fichier)) {
|
|
|
121 |
$erreur = "Le fichier ".Config::get('dossiertmp').$fichier." n'existe pas.";
|
|
|
122 |
throw new Exception($erreur);
|
|
|
123 |
}
|
|
|
124 |
|
|
|
125 |
$pointeur = fopen(Config::get('dossiertmp').$fichier, "r");
|
|
|
126 |
// Chargement de la première colonne (qui contient les noms de colonnes à importer
|
|
|
127 |
$colonnes = fgetcsv($pointeur, 0, ";");
|
|
|
128 |
|
|
|
129 |
// Vérification des colonnes obligatoires et en même temps du séparateur
|
|
|
130 |
if(count($colonnes) < 2 || !array_intersect(array_keys($this->colonnes_obligatoires), $colonnes)) {
|
|
|
131 |
$erreur = "Le fichier ne contient pas les colonnes obligatoires : ".implode(',', array_keys($this->colonnes_obligatoires))."\n";
|
|
|
132 |
$erreur .= "ou bien n'est pas séparé par le caractère ';' ";
|
|
|
133 |
throw new Exception($erreur);
|
|
|
134 |
}
|
|
|
135 |
|
1862 |
aurelien |
136 |
|
|
|
137 |
//TODO: vérifier si les deux index ci dessous ne font pas double emploi
|
|
|
138 |
|
|
|
139 |
// Création d'un index des colonnes qui seront importées dans la fiche en les associant
|
|
|
140 |
// au numéro de colonne dans la feuille csv
|
1856 |
aurelien |
141 |
$index_colonnes_importees = array_intersect(array_keys($this->colonnes_acceptees), $colonnes);
|
|
|
142 |
$colonnes_importees = array();
|
|
|
143 |
foreach($index_colonnes_importees as $index_colonne_importee) {
|
|
|
144 |
$colonnes_importees[] = $this->colonnes_acceptees[$index_colonne_importee];
|
|
|
145 |
}
|
|
|
146 |
|
|
|
147 |
$index_colonnes_refusees = array_keys(array_diff($colonnes, array_keys($this->colonnes_acceptees)));
|
|
|
148 |
// Création d'un index associant chaque numéro de colonne importée à son rôle
|
|
|
149 |
// pour y apporter des traitement spécifiques
|
|
|
150 |
$index_colonnes_importees = $colonnes;
|
|
|
151 |
foreach($index_colonnes_refusees as $colonne_refusee) {
|
|
|
152 |
unset($index_colonnes_importees[$colonne_refusee]);
|
|
|
153 |
}
|
1862 |
aurelien |
154 |
|
|
|
155 |
$roles_a_num_colonnes = array_flip($index_colonnes_importees);
|
1882 |
aurelien |
156 |
|
|
|
157 |
// Ajout de la colonne nom complet aux champs de la requête
|
|
|
158 |
$colonnes_importees[] = 'cpu_fmt_nom_complet';
|
1856 |
aurelien |
159 |
|
1882 |
aurelien |
160 |
$nb_publis_inserees = 0;
|
1856 |
aurelien |
161 |
$lignes = array();
|
|
|
162 |
while($ligne = fgetcsv($pointeur, 0, ";")) {
|
|
|
163 |
$ligne_inseree = array();
|
1882 |
aurelien |
164 |
|
|
|
165 |
// Traitement des champs suivant leur role
|
1856 |
aurelien |
166 |
foreach($ligne as $index => &$valeur) {
|
|
|
167 |
if(!in_array($index, $index_colonnes_refusees)) {
|
|
|
168 |
$ligne_inseree[] = $this->traiterChamp($valeur, $index_colonnes_importees[$index]);
|
|
|
169 |
}
|
|
|
170 |
}
|
1882 |
aurelien |
171 |
|
1856 |
aurelien |
172 |
// Ajout du nom complet formaté de la publication
|
1862 |
aurelien |
173 |
$nom_complet = $this->bdd->proteger($this->formaterNomComplet($ligne, $index_colonnes_importees));
|
|
|
174 |
$ligne_inseree[] = $nom_complet;
|
1882 |
aurelien |
175 |
|
|
|
176 |
$id_publication = $this->insererPublication($colonnes_importees, $ligne_inseree);
|
|
|
177 |
// TODO: quoi faire en cas d'échec pour une publication ?
|
|
|
178 |
if(!empty($id_publication)) {
|
|
|
179 |
$nb_publis_inserees++;
|
|
|
180 |
// Pour aller plus vite on pourrait éventuellement faire une grosse requete d'ajout des publications
|
|
|
181 |
// à personne à la fin, mais ça nous priverait de faire une transaction (TODO: faire une transaction)
|
|
|
182 |
$nb_auteurs_lies = $this->insererLiensPublicationAuteurs($id_publication, $ligne[$roles_a_num_colonnes['auteur']]);
|
|
|
183 |
}
|
1862 |
aurelien |
184 |
|
1856 |
aurelien |
185 |
}
|
1862 |
aurelien |
186 |
|
|
|
187 |
return $nb_publis_inserees;
|
1855 |
delphine |
188 |
}
|
1856 |
aurelien |
189 |
|
1882 |
aurelien |
190 |
|
|
|
191 |
private function insererPublication(&$colonnes, &$publication) {
|
|
|
192 |
$requete = "INSERT INTO ".$this->table_publication." ".
|
|
|
193 |
"(".implode(',', $colonnes).") ".
|
|
|
194 |
"VALUES (".implode(",", $publication).")";
|
|
|
195 |
|
|
|
196 |
$insertion = $this->bdd->executer($requete);
|
|
|
197 |
$id_publi = $this->bdd->recupererIdDernierAjout();
|
|
|
198 |
|
|
|
199 |
// Historisation de l'ajout
|
|
|
200 |
$histo = $this->creerXmlHisto(array_combine($colonnes, $publication));
|
|
|
201 |
$id_meta = $this->historiser($this->id_table_publication, $id_publi, $histo);
|
|
|
202 |
// Affectation des méta données concernat l'ajout à la publication
|
|
|
203 |
$requete_affectation_meta = "UPDATE ".$this->table_publication." ".
|
|
|
204 |
"SET cpu_ce_meta = ".$id_meta." ".
|
|
|
205 |
"WHERE cpu_id_publication = ".$id_publi;
|
|
|
206 |
|
|
|
207 |
$this->bdd->executer($requete_affectation_meta);
|
|
|
208 |
|
|
|
209 |
return $id_publi;
|
1862 |
aurelien |
210 |
}
|
|
|
211 |
|
1882 |
aurelien |
212 |
protected function insererLiensPublicationAuteurs($id_publication, &$auteurs) {
|
|
|
213 |
$colonnes = array('cpuap_id_publication', 'cpuap_id_personne', 'cpuap_id_role', 'cpuap_ce_truk_type', 'cpuap_ordre', 'cpuap_ce_meta');
|
|
|
214 |
$requete = "INSERT IGNORE INTO ".$this->table_publication_a_auteur." ".
|
|
|
215 |
"(".implode(",", $colonnes).") VALUES ";
|
|
|
216 |
|
|
|
217 |
// L'ordre des auteurs commence à 1
|
|
|
218 |
$ordre_auteur = 1;
|
|
|
219 |
|
|
|
220 |
// Découpage des différents auteurs
|
|
|
221 |
$auteurs_tab = explode(',', $auteurs);
|
|
|
222 |
$auteurs_tab = array_filter($auteurs_tab);
|
|
|
223 |
|
|
|
224 |
// Les auteurs sont normalement cités dans l'ordre dans l'import
|
|
|
225 |
foreach($auteurs_tab as $auteur) {
|
|
|
226 |
// si les infos auteurs sont un tableau dans le cache alors l'id existe bien en base de données
|
|
|
227 |
if(is_array($this->cache_auteur[$auteur])) {
|
|
|
228 |
$id_auteur = $this->cache_auteur[$auteur]['cp_id_personne'];
|
1862 |
aurelien |
229 |
|
1882 |
aurelien |
230 |
$valeurs = array($id_publication, $id_auteur, $this->id_role_auteur, "NULL", $ordre_auteur, "0");
|
1862 |
aurelien |
231 |
|
1882 |
aurelien |
232 |
$requete_insertion = $requete." (".implode(',', $valeurs).") ";
|
|
|
233 |
$liaison = $this->bdd->executer($requete_insertion);
|
|
|
234 |
|
|
|
235 |
// Historisation de l'ajout
|
|
|
236 |
$histo = $this->creerXmlHisto(array_combine($colonnes, $liaison));
|
|
|
237 |
$cle_liaison = $id_publication.'-'.$this->id_role_auteur.'-'.$id_auteur;
|
|
|
238 |
$id_meta = $this->historiser($this->id_table_publication_personne, $cle_liaison, $histo);
|
1862 |
aurelien |
239 |
|
1882 |
aurelien |
240 |
// Affectation des méta données concernant l'ajout à la publication à auteur
|
|
|
241 |
$requete_affectation_meta = "UPDATE ".$this->table_publication_a_auteur." ".
|
|
|
242 |
"SET cpuap_ce_meta = ".$id_meta;
|
|
|
243 |
$this->bdd->executer($requete_affectation_meta);
|
|
|
244 |
}
|
|
|
245 |
// L'ordre des auteurs est conservé même pour ceux qui n'existe pas dans la bdd
|
|
|
246 |
$ordre_auteur++;
|
1862 |
aurelien |
247 |
}
|
|
|
248 |
}
|
|
|
249 |
|
1882 |
aurelien |
250 |
protected function creerXmlHisto($donnees) {
|
|
|
251 |
// Création du xml de l'enregistrement à historiser
|
|
|
252 |
$info = null;
|
|
|
253 |
$xml_tpl = '<?xml version="1.0" encoding="UTF-8" ?>'."\n<resultset>\n<row>\n%s</row>\n</resultset>";
|
|
|
254 |
$xml = null;
|
|
|
255 |
|
|
|
256 |
foreach ($donnees as $cle => $valeur) {
|
|
|
257 |
// Pour éviter un éventuel double échappement des valeurs
|
|
|
258 |
$valeur = stripslashes($valeur);
|
|
|
259 |
$valeur = trim($valeur, "'");
|
|
|
260 |
if (!is_null($valeur) && $valeur != '') {
|
|
|
261 |
$xml .= "<$cle>$valeur</$cle>\n";
|
|
|
262 |
}
|
|
|
263 |
}
|
|
|
264 |
if ($xml !== null) {
|
|
|
265 |
$info = sprintf($xml_tpl, $xml);
|
|
|
266 |
$info = $this->bdd->proteger($info);
|
|
|
267 |
}
|
|
|
268 |
|
|
|
269 |
return $info;
|
|
|
270 |
}
|
|
|
271 |
|
|
|
272 |
protected function historiser($table_id, $ligne_cle, $info) {
|
|
|
273 |
date_default_timezone_set('Europe/Paris');
|
|
|
274 |
// Pré-traitement des variables
|
|
|
275 |
$info = (is_null($info)) ? 'NULL' : $info;
|
|
|
276 |
|
|
|
277 |
// Historisation (Ajout des méta-données)
|
|
|
278 |
$requete = 'INSERT INTO coel_meta_historique_ligne '.
|
|
|
279 |
' (cmhl_ce_table, cmhl_cle_ligne, cmhl_enregistrement, cmhl_date_modification, cmhl_ce_modifier_par, cmhl_ce_etat, cmhl_ip, cmhl_session_id) '.
|
|
|
280 |
'VALUES ('.
|
|
|
281 |
" $table_id, ".
|
|
|
282 |
' "'.$ligne_cle.'", '.
|
|
|
283 |
" $info, ".
|
|
|
284 |
' "'.date('Y-m-d H:i:s', time()).'", '.
|
|
|
285 |
" $this->id_utilisateur, ".
|
|
|
286 |
" ".self::ETAT_AJOUTER.", ".
|
|
|
287 |
' "'.$this->ip_utilisateur.'", '.
|
|
|
288 |
' "'.$this->id_session.'") ';
|
|
|
289 |
$resultat = $this->bdd->executer($requete);
|
|
|
290 |
return $this->bdd->recupererIdDernierAjout();
|
|
|
291 |
}
|
|
|
292 |
|
1856 |
aurelien |
293 |
protected function formaterNomComplet($ligne, $roles) {
|
1857 |
aurelien |
294 |
|
|
|
295 |
$roles = array_flip($roles);
|
|
|
296 |
|
|
|
297 |
// Intitulé de la publication complet : fmt_auteur, date_parution(année). titre. Editeur (nom), collection, fascicule, indication_nvt. pages.
|
|
|
298 |
// indication_nvt = serie_tome
|
|
|
299 |
$champs_nom_complet = array('auteur', 'annee', 'titre', 'editeur', 'intitule_revue', 'fascicule', 'serie_tome', 'pages');
|
|
|
300 |
$champs_fmt = array();
|
|
|
301 |
|
|
|
302 |
$fmt_nom_complet = "";
|
|
|
303 |
|
|
|
304 |
foreach($champs_nom_complet as $champ) {
|
|
|
305 |
$index = $roles[$champ];
|
|
|
306 |
if(!isset($ligne[$index])) {
|
|
|
307 |
$champs_fmt[$champ] = "";
|
|
|
308 |
} else {
|
|
|
309 |
$champs_fmt[$champ] = $ligne[$index];
|
|
|
310 |
}
|
|
|
311 |
}
|
|
|
312 |
|
|
|
313 |
$indication_nvt_pages = array($champs_fmt['serie_tome'], $champs_fmt['pages']);
|
|
|
314 |
$indication_nvt_pages = array_filter($indication_nvt_pages, 'strlen');
|
|
|
315 |
$indication_nvt_pages = trim(implode(". ", $indication_nvt_pages));
|
|
|
316 |
$indication_nvt_pages .= !empty($indication_nvt_pages) ? "." : "";
|
|
|
317 |
|
|
|
318 |
$annee_titre_editeur = array($champs_fmt['annee'], $champs_fmt['titre'], $champs_fmt['editeur']);
|
|
|
319 |
$annee_titre_editeur = array_filter($annee_titre_editeur, 'strlen');
|
|
|
320 |
$annee_titre_editeur = trim(implode(". ", $annee_titre_editeur));
|
|
|
321 |
|
|
|
322 |
$fmt_nom_complet = array($champs_fmt['auteur'],
|
|
|
323 |
$annee_titre_editeur,
|
|
|
324 |
$champs_fmt['intitule_revue'],
|
|
|
325 |
$champs_fmt['fascicule'],
|
|
|
326 |
$indication_nvt_pages);
|
|
|
327 |
|
|
|
328 |
$fmt_nom_complet = array_filter($fmt_nom_complet, 'strlen');
|
|
|
329 |
$fmt_nom_complet = implode(", ", $fmt_nom_complet);
|
|
|
330 |
|
|
|
331 |
return $fmt_nom_complet;
|
1856 |
aurelien |
332 |
}
|
|
|
333 |
|
|
|
334 |
private function traiterChamp($valeur, $role) {
|
|
|
335 |
switch($role) {
|
|
|
336 |
case 'auteur':
|
1862 |
aurelien |
337 |
$valeur = $this->traiterChampAuteur($valeur);
|
1856 |
aurelien |
338 |
break;
|
|
|
339 |
case 'editeur':
|
1862 |
aurelien |
340 |
$valeur = 'AUTRE##'.$valeur;
|
1856 |
aurelien |
341 |
break;
|
|
|
342 |
}
|
|
|
343 |
|
|
|
344 |
return $this->bdd->proteger($valeur);
|
|
|
345 |
}
|
1862 |
aurelien |
346 |
|
|
|
347 |
private function traiterChampAuteur($auteur_intitule) {
|
|
|
348 |
$auteurs_fmt = array();
|
|
|
349 |
$auteurs_tab = explode(',', $auteur_intitule);
|
|
|
350 |
foreach($auteurs_tab as $auteur) {
|
1875 |
aurelien |
351 |
if(!empty(trim($auteur))) {
|
|
|
352 |
$auteurs_fmt[] = $this->obtenirInfosAuteur($auteur);
|
|
|
353 |
}
|
1862 |
aurelien |
354 |
}
|
|
|
355 |
|
|
|
356 |
return implode(', ', $auteurs_fmt);
|
|
|
357 |
}
|
1856 |
aurelien |
358 |
|
1857 |
aurelien |
359 |
private function obtenirInfosAuteur($auteur_intitule) {
|
1862 |
aurelien |
360 |
$retour = $auteur_intitule;
|
|
|
361 |
// Si on déjà recherché et trouvé (ou non l'auteur)
|
1857 |
aurelien |
362 |
if(isset($this->cache_auteur[$auteur_intitule])) {
|
1876 |
aurelien |
363 |
// On renvoie son nom complet formaté s'il existe en bdd ou sinon
|
1862 |
aurelien |
364 |
// le nom qui a été donné dans la feuille csv
|
1876 |
aurelien |
365 |
$retour = !empty($this->cache_auteur[$auteur_intitule]['cp_fmt_nom_complet']) ?
|
|
|
366 |
$this->cache_auteur[$auteur_intitule]['cp_fmt_nom_complet'] :
|
|
|
367 |
$auteur_intitule;
|
1856 |
aurelien |
368 |
} else {
|
1862 |
aurelien |
369 |
// Recherche de l'auteur sur un maximum du combinaisons possible des variations
|
|
|
370 |
// de son nom et prénom
|
1857 |
aurelien |
371 |
$auteur = $this->fabriquerCombinaisonsAuteur($auteur_intitule);
|
1856 |
aurelien |
372 |
$auteur_req = "(".implode(', ', $auteur).")";
|
|
|
373 |
|
1857 |
aurelien |
374 |
$requete = "SELECT cp_id_personne, cp_fmt_nom_complet FROM ".$this->table_auteur." WHERE cp_fmt_nom_complet IN ".$auteur_req;
|
1856 |
aurelien |
375 |
$infos_auteur = $this->bdd->recupererTous($requete);
|
1882 |
aurelien |
376 |
|
1862 |
aurelien |
377 |
// Stockage en cache de la ligne de bdd si trouvé,
|
|
|
378 |
// de la valeur brute sinon
|
1856 |
aurelien |
379 |
if(!empty($infos_auteur)) {
|
1862 |
aurelien |
380 |
$retour = $infos_auteur[0]['cp_fmt_nom_complet'];
|
1857 |
aurelien |
381 |
$this->cache_auteur[$auteur_intitule] = $infos_auteur[0];
|
1882 |
aurelien |
382 |
// Stocker le nom d'auteur sous les deux formes (fmt nom complet et tel que saisi), facilite la recherche
|
|
|
383 |
// plus tard lors de la liaison des publications aux auteurs
|
|
|
384 |
$this->cache_auteur[$infos_auteur[0]['cp_fmt_nom_complet']] = $infos_auteur[0];
|
1856 |
aurelien |
385 |
} else {
|
1857 |
aurelien |
386 |
$retour = $auteur_intitule;
|
|
|
387 |
$this->cache_auteur[$auteur_intitule] = $auteur_intitule;
|
1856 |
aurelien |
388 |
}
|
|
|
389 |
}
|
|
|
390 |
|
|
|
391 |
return $retour;
|
|
|
392 |
}
|
|
|
393 |
|
|
|
394 |
private function fabriquerCombinaisonsAuteur($auteur) {
|
|
|
395 |
|
|
|
396 |
$auteur = trim($auteur);
|
|
|
397 |
$auteurs_formates = array($this->bdd->proteger($auteur));
|
|
|
398 |
|
|
|
399 |
// Séparation des élements de l'auteur des espaces pour obtenir
|
|
|
400 |
// les noms et prénoms (Ex. "Carl Von Linné" => "Carl", "Von", "Linné")
|
|
|
401 |
$auteur_tab = explode(' ', $auteur);
|
|
|
402 |
$auteur_tab = array_filter($auteur_tab);
|
|
|
403 |
|
|
|
404 |
$combinaisons = array();
|
|
|
405 |
foreach($auteur_tab as &$element_auteur) {
|
|
|
406 |
$combinaisons[] = array(
|
|
|
407 |
// élement tel quel (Ex: "Linné")
|
|
|
408 |
$element_auteur,
|
|
|
409 |
// possibilité de l'initiale seule (Ex: "L")
|
|
|
410 |
substr($element_auteur, 0, 1),
|
|
|
411 |
// possibilité de l'initiale avec un point du genre (Ex: "L.")
|
|
|
412 |
substr($element_auteur, 0, 1)."."
|
|
|
413 |
);
|
|
|
414 |
}
|
|
|
415 |
|
|
|
416 |
// Fabrication de toutes les combinaisons possibles des parties de noms ci-dessus
|
|
|
417 |
// pour deux et trois élements en faisant plusieurs produits cartésiens
|
|
|
418 |
// car le nom peut être combiné différement de celui en base de données
|
|
|
419 |
// (Ex. : "Carl Von Linné" VS "C. Von Linné" ou "C. V. Linné" ou encore "Von Linné C." etc...)
|
|
|
420 |
|
|
|
421 |
// C'est moche et pas très élégant mais bon ça marche dans 90% des cas
|
|
|
422 |
// On ne teste pas plus que 3 combinaisons, car ça serait très très couteux
|
|
|
423 |
// TODO: faire mieux et factoriser les appels ci dessous
|
|
|
424 |
if(count($auteur_tab) > 2) {
|
|
|
425 |
// Cas du nom à trois parties (genre "Carl Von Linné")
|
|
|
426 |
$possibilites_auteurs = $this->cartesian(array($combinaisons[0], $combinaisons[1], $combinaisons[2]));
|
|
|
427 |
$possibilites_auteurs = array_merge($possibilites_auteurs, $this->cartesian(array($combinaisons[0], $combinaisons[2], $combinaisons[1])));
|
|
|
428 |
$possibilites_auteurs = array_merge($possibilites_auteurs, $this->cartesian(array($combinaisons[1], $combinaisons[2], $combinaisons[0])));
|
|
|
429 |
$possibilites_auteurs = array_merge($possibilites_auteurs, $this->cartesian(array($combinaisons[1], $combinaisons[0], $combinaisons[2])));
|
|
|
430 |
$possibilites_auteurs = array_merge($possibilites_auteurs, $this->cartesian(array($combinaisons[2], $combinaisons[1], $combinaisons[0])));
|
|
|
431 |
$possibilites_auteurs = array_merge($possibilites_auteurs, $this->cartesian(array($combinaisons[2], $combinaisons[0], $combinaisons[1])));
|
|
|
432 |
} else {
|
|
|
433 |
// Cas du nom à trois parties (genre "Carl Linné")
|
|
|
434 |
$possibilites_auteurs = $this->cartesian(array($combinaisons[0], $combinaisons[1]));
|
|
|
435 |
$possibilites_auteurs = array_merge($possibilites_auteurs, $this->cartesian(array($combinaisons[1], $combinaisons[0])));
|
|
|
436 |
}
|
|
|
437 |
|
|
|
438 |
$auteurs_formates = array();
|
|
|
439 |
foreach($possibilites_auteurs as &$possibilite) {
|
|
|
440 |
$initiales = true;
|
|
|
441 |
// Suppression des possibilités ne contenant que des initiales avec ou sans point
|
|
|
442 |
foreach($possibilite as &$chars) {
|
|
|
443 |
$initiales = $initiales && mb_strlen($chars) <= 2;
|
|
|
444 |
}
|
1855 |
delphine |
445 |
|
1856 |
aurelien |
446 |
if(!$initiales) {
|
|
|
447 |
$auteurs_formates[] = $this->bdd->proteger(implode(" ", $possibilite));
|
|
|
448 |
}
|
|
|
449 |
}
|
|
|
450 |
|
|
|
451 |
return $auteurs_formates;
|
|
|
452 |
}
|
|
|
453 |
|
|
|
454 |
// http://stackoverflow.com/questions/6311779/finding-cartesian-product-with-php-associative-arrays
|
|
|
455 |
function cartesian($input) {
|
|
|
456 |
// filter out empty values
|
|
|
457 |
$input = array_filter($input);
|
|
|
458 |
|
|
|
459 |
$result = array(array());
|
|
|
460 |
|
|
|
461 |
foreach ($input as $key => $values) {
|
|
|
462 |
$append = array();
|
|
|
463 |
|
|
|
464 |
foreach($result as $product) {
|
|
|
465 |
foreach($values as $item) {
|
|
|
466 |
$product[$key] = $item;
|
|
|
467 |
$append[] = $product;
|
|
|
468 |
}
|
|
|
469 |
}
|
|
|
470 |
|
|
|
471 |
$result = $append;
|
|
|
472 |
}
|
|
|
473 |
|
|
|
474 |
return $result;
|
|
|
475 |
}
|
1855 |
delphine |
476 |
}
|
|
|
477 |
?>
|