Subversion Repositories eFlore/Applications.coel

Rev

Rev 1882 | Details | Compare with Previous | Last modification | View Log | RSS feed

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