Subversion Repositories eFlore/Applications.coel

Rev

Rev 1874 | Go to most recent revision | 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(
10
			'-n' => array(true, false, 'Nom du fichier à importer.'));
11
 
1857 aurelien 12
	protected $table_publication = null;
13
	protected $table_auteur = null;
1862 aurelien 14
	protected $table_publication_a_auteur = null;
1857 aurelien 15
 
1862 aurelien 16
	protected $id_role_auteur = null;
17
 
1856 aurelien 18
	protected $colonnes_obligatoires = array();
19
	protected $colonnes_acceptees = array();
1855 delphine 20
 
1856 aurelien 21
	protected $cache_auteur = array();
1862 aurelien 22
	protected $auteurs_a_publis = array();
23
	protected $publis_a_auteurs = array();
1856 aurelien 24
 
1855 delphine 25
	public function __construct($script_nom, $parametres) {
26
		parent::__construct($script_nom, $parametres);
27
		$this->bdd = new Bdd();
28
	}
29
 
30
	public function executer() {
31
		try {
32
			$this->initialiserScript();
33
			$cmd = $this->getParametre('a');
34
			$fichier = $this->getParametre('n');
35
			switch ($cmd) {
36
				case "import" :
1857 aurelien 37
					$resultat = $this->charger($fichier); break;
1855 delphine 38
				default :
39
					$this->traiterErreur('Erreur : la commande "%s" n\'existe pas!', array($cmd));
40
			}
41
		} catch (Exception $erreur) {
42
			$this->traiterErreur($erreur->getMessage());
43
		}
1857 aurelien 44
 
45
		// renvoi du résultat vers la sortie php
1862 aurelien 46
		// car le script est surtout destiné à être appelé par un web service
1857 aurelien 47
		echo $resultat;
1874 aurelien 48
		exit;
1855 delphine 49
	}
50
 
51
	private function initialiserScript() {
52
		$fichierIni = $this->getScriptChemin().'import.ini';
53
		if (file_exists($fichierIni)) {
54
			Config::charger($fichierIni);
55
		} else {
1856 aurelien 56
			$erreur = "Veuillez configurer le projet en créant le fichier 'import.ini' ".
57
					"dans le dossier du module de script du projet à partir du fichier 'import.defaut.ini'.";
1855 delphine 58
			throw new Exception($erreur);
59
		}
1856 aurelien 60
 
61
		$this->colonnes_obligatoires= Config::get('champs_obligatoires');
62
		$this->colonnes_acceptees = Config::get('champs');
1857 aurelien 63
 
64
		$tables = Config::get('tables');
1874 aurelien 65
		$this->table_publication = $tables['publication'];
1857 aurelien 66
		$this->table_auteur = $tables['auteur'];
1862 aurelien 67
		$this->table_publication_a_auteur = $tables['publication_a_auteur'];
68
 
69
		$this->id_role_auteur = $tables['id_role_auteur'];
1855 delphine 70
	}
71
 
72
	private function charger($fichier) {
73
 
1856 aurelien 74
		// vérification existence fichier
75
		if(!file_exists(Config::get('dossiertmp').$fichier)) {
1874 aurelien 76
			$erreur = "Le fichier ".Config::get('dossiertmp').$fichier." n'existe pas.";
1856 aurelien 77
			throw new Exception($erreur);
78
		}
79
 
80
		$pointeur = fopen(Config::get('dossiertmp').$fichier, "r");
81
		// Chargement de la première colonne (qui contient les noms de colonnes à importer
82
		$colonnes = fgetcsv($pointeur, 0, ";");
83
 
84
		// Vérification des colonnes obligatoires et en même temps du séparateur
85
		if(count($colonnes) < 2 || !array_intersect(array_keys($this->colonnes_obligatoires), $colonnes)) {
86
			$erreur = "Le fichier ne contient pas les colonnes obligatoires : ".implode(',', array_keys($this->colonnes_obligatoires))."\n";
1874 aurelien 87
			$erreur .= "ou bien n'est pas séparé par le caractère ';' ";
1856 aurelien 88
			throw new Exception($erreur);
89
		}
90
 
1862 aurelien 91
 
92
		//TODO: vérifier si les deux index ci dessous ne font pas double emploi
93
 
94
		// Création d'un index des colonnes qui seront importées dans la fiche en les associant
95
		// au numéro de colonne dans la feuille csv
1856 aurelien 96
		$index_colonnes_importees = array_intersect(array_keys($this->colonnes_acceptees), $colonnes);
97
		$colonnes_importees = array();
98
		foreach($index_colonnes_importees as $index_colonne_importee) {
99
			$colonnes_importees[] = $this->colonnes_acceptees[$index_colonne_importee];
100
		}
101
 
102
		$index_colonnes_refusees = array_keys(array_diff($colonnes, array_keys($this->colonnes_acceptees)));
103
		// Création d'un index associant chaque numéro de colonne importée à son rôle
104
		// pour y apporter des traitement spécifiques
105
		$index_colonnes_importees = $colonnes;
106
		foreach($index_colonnes_refusees as $colonne_refusee) {
107
			unset($index_colonnes_importees[$colonne_refusee]);
108
		}
1862 aurelien 109
 
110
		$roles_a_num_colonnes = array_flip($index_colonnes_importees);
1856 aurelien 111
 
112
		$lignes = array();
113
		while($ligne = fgetcsv($pointeur, 0, ";")) {
114
			$ligne_inseree = array();
115
			foreach($ligne as $index => &$valeur) {
116
				if(!in_array($index, $index_colonnes_refusees)) {
117
					$ligne_inseree[] = $this->traiterChamp($valeur, $index_colonnes_importees[$index]);
118
				}
119
			}
120
			// Ajout du nom complet formaté de la publication
1862 aurelien 121
			$nom_complet = $this->bdd->proteger($this->formaterNomComplet($ligne, $index_colonnes_importees));
122
			$ligne_inseree[] = $nom_complet;
1856 aurelien 123
			$lignes[] = "(".implode(",", $ligne_inseree).")";
1862 aurelien 124
 
125
			$this->stockerAuteursPourLiaisons($ligne[$roles_a_num_colonnes['auteur']], $nom_complet);
1856 aurelien 126
		}
127
 
128
		// Ajout de la colonne nom complet aux champs de la requête
129
		$colonnes_importees[] = 'cpu_fmt_nom_complet';
1862 aurelien 130
 
1857 aurelien 131
		// le script renvoie le nombre de publications importées
1862 aurelien 132
		$nb_publis_inserees = $this->insererPublications($colonnes_importees, $lignes);
133
		$nb_auteurs_lies = $this->insererLiensPublicationsAuteurs();
134
 
135
		return $nb_publis_inserees;
1855 delphine 136
	}
1856 aurelien 137
 
1862 aurelien 138
	private function stockerAuteursPourLiaisons($infos_auteurs, $nom_complet_publication) {
139
		// Découpage des différents auteurs
140
		$auteurs_tab = explode(',', $infos_auteurs);
1874 aurelien 141
		$auteurs_tab = array_filter($auteurs_tab);
1862 aurelien 142
		foreach($auteurs_tab as $auteur) {
1874 aurelien 143
			// si les infos auteurs sont un tableau dans le cache alors son id existe bien en base de données
144
			if(is_array($this->cache_auteur[$auteur])) {
1862 aurelien 145
				// ajout d'une correspondance entre le nom complet de la publi et l'auteur (pour liaison ultérieure)
1874 aurelien 146
				// et vice versa, ce qui permet facilement de retrouver à quel auteur est lié quelle publi dans les deux sens
1862 aurelien 147
				$this->auteurs_a_publi[$auteur][] = $nom_complet_publication;
1874 aurelien 148
				$this->publis_a_auteurs[$nom_complet_publication][] = $auteur;
1862 aurelien 149
			}
150
		}
151
	}
152
 
153
	protected function insererLiensPublicationsAuteurs() {
154
 
155
		$champs = array('cpuap_id_publication', 'cpuap_id_personne', 'cpuap_id_role', 'cpuap_ce_truk_type', 'cpuap_ordre', 'cpuap_ce_meta');
156
		$requete = "INSERT IGNORE INTO ".$this->table_publication_a_auteur." ".
157
					"(".implode(",", $champs).") VALUES ";
1874 aurelien 158
 
1862 aurelien 159
		foreach($this->auteurs_a_publi as $auteur => $publis) {
160
 
161
			$id_auteur = $this->cache_auteur[$auteur]['cp_id_personne'];
162
 
163
			// Pour chaque publication importée à laquelle est liée l'auteur
164
			// il peut avoir un ordre différent
165
			foreach($publis as $publi) {
166
 
167
				// l'ordre des auteurs commence à 1, les auteurs sont stockés dans l'ordre dans publis_a_auteurs
168
				$ordre_auteur = array_search($auteur, $this->publis_a_auteurs[$publi]) + 1;
169
 
170
				// Le nom complet de la publication est normalement unique et donc peut servir à retrouver
1874 aurelien 171
				// les publications qui ont été insérées par lot (sans en récupérer l'id)
1862 aurelien 172
				$sous_requete_id_publi = "SELECT cpu_id_publication FROM coel_publication ".
173
							"WHERE cpu_fmt_nom_complet IN (".$publi.") ";
174
 
175
				$requete_insertion = $requete." (".
176
										" (".$sous_requete_id_publi."), ".
177
										$this->bdd->proteger($id_auteur).", ".
178
										$this->id_role_auteur.", ".
179
										"NULL ,".
180
										$ordre_auteur.", ".
181
										"NULL".
182
									") ";
183
				$insertion = $this->bdd->executer($requete_insertion);
1874 aurelien 184
			}
1862 aurelien 185
		}
186
		// TODO: quoi faire en ce qui concerne l'insertion des auteurs ?
187
		// et le nombre inséré, les éventuels échecs de la requête ?
188
	}
189
 
1856 aurelien 190
	protected function formaterNomComplet($ligne, $roles) {
1857 aurelien 191
 
192
		$roles = array_flip($roles);
193
 
194
		// Intitulé de la publication complet : fmt_auteur, date_parution(année). titre. Editeur (nom), collection, fascicule, indication_nvt. pages.
195
		// indication_nvt = serie_tome
196
		$champs_nom_complet = array('auteur', 'annee', 'titre', 'editeur', 'intitule_revue', 'fascicule', 'serie_tome', 'pages');
197
		$champs_fmt = array();
198
 
199
		$fmt_nom_complet = "";
200
 
201
		foreach($champs_nom_complet as $champ) {
202
			$index = $roles[$champ];
203
			if(!isset($ligne[$index])) {
204
				$champs_fmt[$champ] = "";
205
			} else {
206
				$champs_fmt[$champ] = $ligne[$index];
207
			}
208
		}
209
 
210
		$indication_nvt_pages = array($champs_fmt['serie_tome'], $champs_fmt['pages']);
211
		$indication_nvt_pages = array_filter($indication_nvt_pages, 'strlen');
212
		$indication_nvt_pages = trim(implode(". ", $indication_nvt_pages));
213
		$indication_nvt_pages .= !empty($indication_nvt_pages) ? "." : "";
214
 
215
		$annee_titre_editeur = array($champs_fmt['annee'], $champs_fmt['titre'], $champs_fmt['editeur']);
216
		$annee_titre_editeur = array_filter($annee_titre_editeur, 'strlen');
217
		$annee_titre_editeur = trim(implode(". ", $annee_titre_editeur));
218
 
219
		$fmt_nom_complet =  array($champs_fmt['auteur'],
220
							$annee_titre_editeur,
221
							$champs_fmt['intitule_revue'],
222
							$champs_fmt['fascicule'],
223
							$indication_nvt_pages);
224
 
225
		$fmt_nom_complet = array_filter($fmt_nom_complet, 'strlen');
226
		$fmt_nom_complet = implode(", ", $fmt_nom_complet);
227
 
228
		return $fmt_nom_complet;
1856 aurelien 229
	}
230
 
231
	private function insererPublications(&$colonnes, &$publications) {
1874 aurelien 232
 
233
		// Une insertion par tranche de 1000 permet d'insérer sans avoir de mysql
234
		// timeout qui nécessite de réveiller la connexion de temps en temps.
235
		// TODO: transactions ?
236
		$tranches_publis = array_chunk($publications, 1000);
237
		$nb_publis_inserees = 0;
238
 
239
		foreach($tranches_publis as $tranche) {
240
 
241
			$requete = "INSERT INTO ".$this->table_publication." ".
242
					   	"(".implode(',', $colonnes).") ".
243
					   "VALUES ".implode(","."\n", $tranche)."\n";
244
 
245
			$nb_publis_inserees += $this->bdd->executer($requete);
246
		}
1862 aurelien 247
 
1874 aurelien 248
		return $nb_publis_inserees;
1856 aurelien 249
	}
250
 
251
	private function traiterChamp($valeur, $role) {
252
		switch($role) {
253
			case 'auteur':
1862 aurelien 254
				$valeur = $this->traiterChampAuteur($valeur);
1856 aurelien 255
			break;
256
			case 'editeur':
1862 aurelien 257
				$valeur = 'AUTRE##'.$valeur;
1856 aurelien 258
			break;
259
		}
260
 
261
		return $this->bdd->proteger($valeur);
262
	}
1862 aurelien 263
 
264
	private function traiterChampAuteur($auteur_intitule) {
265
		$auteurs_fmt = array();
266
		$auteurs_tab = explode(',', $auteur_intitule);
267
		foreach($auteurs_tab as $auteur) {
1874 aurelien 268
			if(!empty(trim($auteur))) {
269
				$auteurs_fmt[] = $this->obtenirInfosAuteur($auteur);
270
			}
1862 aurelien 271
		}
272
 
273
		return implode(', ', $auteurs_fmt);
274
	}
1874 aurelien 275
 
1857 aurelien 276
	private function obtenirInfosAuteur($auteur_intitule) {
1862 aurelien 277
		$retour = $auteur_intitule;
1874 aurelien 278
		// Si on déjà recherché et trouvé (ou non l'auteur)
1857 aurelien 279
		if(isset($this->cache_auteur[$auteur_intitule])) {
1877 aurelien 280
			// On renvoie son nom complet formaté s'il existe en bdd ou sinon
1862 aurelien 281
			// le nom qui a été donné dans la feuille csv
1877 aurelien 282
			$retour = !empty($this->cache_auteur[$auteur_intitule]['cp_fmt_nom_complet']) ?
283
				$this->cache_auteur[$auteur_intitule]['cp_fmt_nom_complet'] :
284
				$auteur_intitule;
1856 aurelien 285
		} else {
1862 aurelien 286
			// Recherche de l'auteur sur un maximum du combinaisons possible des variations
287
			// de son nom et prénom
1857 aurelien 288
			$auteur = $this->fabriquerCombinaisonsAuteur($auteur_intitule);
1856 aurelien 289
			$auteur_req = "(".implode(', ', $auteur).")";
290
 
1857 aurelien 291
			$requete = "SELECT cp_id_personne, cp_fmt_nom_complet FROM ".$this->table_auteur." WHERE cp_fmt_nom_complet IN ".$auteur_req;
1856 aurelien 292
			$infos_auteur = $this->bdd->recupererTous($requete);
293
 
1862 aurelien 294
			// Stockage en cache de la ligne de bdd si trouvé,
295
			// de la valeur brute sinon
1856 aurelien 296
			if(!empty($infos_auteur)) {
1862 aurelien 297
				$retour = $infos_auteur[0]['cp_fmt_nom_complet'];
1857 aurelien 298
				$this->cache_auteur[$auteur_intitule] = $infos_auteur[0];
1856 aurelien 299
			} else {
1857 aurelien 300
				$retour = $auteur_intitule;
301
				$this->cache_auteur[$auteur_intitule] = $auteur_intitule;
1856 aurelien 302
			}
303
		}
304
 
1874 aurelien 305
		return $retour;
1856 aurelien 306
	}
307
 
308
	private function fabriquerCombinaisonsAuteur($auteur) {
309
 
310
		$auteur = trim($auteur);
311
		$auteurs_formates = array($this->bdd->proteger($auteur));
312
 
313
		// Séparation des élements de l'auteur des espaces pour obtenir
314
		// les noms et prénoms (Ex. "Carl Von Linné" => "Carl", "Von", "Linné")
315
		$auteur_tab = explode(' ', $auteur);
316
		$auteur_tab = array_filter($auteur_tab);
317
 
318
		$combinaisons = array();
319
		foreach($auteur_tab as &$element_auteur) {
320
			$combinaisons[] = array(
321
								// élement tel quel (Ex: "Linné")
322
								$element_auteur,
323
								// possibilité de l'initiale seule (Ex: "L")
324
								substr($element_auteur, 0, 1),
325
								// possibilité de l'initiale avec un point du genre (Ex: "L.")
326
								substr($element_auteur, 0, 1)."."
327
							);
328
		}
329
 
330
		// Fabrication de toutes les combinaisons possibles des parties de noms ci-dessus
331
		// pour deux et trois élements en faisant plusieurs produits cartésiens
332
		// car le nom peut être combiné différement de celui en base de données
333
		// (Ex. : "Carl Von Linné" VS "C. Von Linné" ou "C. V. Linné" ou encore "Von Linné C." etc...)
334
 
335
		// C'est moche et pas très élégant mais bon ça marche dans 90% des cas
336
		// On ne teste pas plus que 3 combinaisons, car ça serait très très couteux
337
		// TODO: faire mieux et factoriser les appels ci dessous
338
		if(count($auteur_tab) > 2) {
339
			// Cas du nom à trois parties (genre "Carl Von Linné")
340
			$possibilites_auteurs = $this->cartesian(array($combinaisons[0], $combinaisons[1], $combinaisons[2]));
341
			$possibilites_auteurs = array_merge($possibilites_auteurs, $this->cartesian(array($combinaisons[0], $combinaisons[2], $combinaisons[1])));
342
			$possibilites_auteurs = array_merge($possibilites_auteurs, $this->cartesian(array($combinaisons[1], $combinaisons[2], $combinaisons[0])));
343
			$possibilites_auteurs = array_merge($possibilites_auteurs, $this->cartesian(array($combinaisons[1], $combinaisons[0], $combinaisons[2])));
344
			$possibilites_auteurs = array_merge($possibilites_auteurs, $this->cartesian(array($combinaisons[2], $combinaisons[1], $combinaisons[0])));
345
			$possibilites_auteurs = array_merge($possibilites_auteurs, $this->cartesian(array($combinaisons[2], $combinaisons[0], $combinaisons[1])));
346
		} else {
347
			// Cas du nom à trois parties (genre "Carl Linné")
348
			$possibilites_auteurs = $this->cartesian(array($combinaisons[0], $combinaisons[1]));
349
			$possibilites_auteurs = array_merge($possibilites_auteurs, $this->cartesian(array($combinaisons[1], $combinaisons[0])));
350
		}
351
 
352
		$auteurs_formates = array();
353
		foreach($possibilites_auteurs as &$possibilite) {
354
			$initiales = true;
355
			// Suppression des possibilités ne contenant que des initiales avec ou sans point
356
			foreach($possibilite as &$chars) {
357
				$initiales = $initiales && mb_strlen($chars) <= 2;
358
			}
1855 delphine 359
 
1856 aurelien 360
			if(!$initiales) {
361
				$auteurs_formates[] = $this->bdd->proteger(implode(" ", $possibilite));
362
			}
363
		}
364
 
365
		return $auteurs_formates;
366
	}
367
 
1874 aurelien 368
	// http://stackoverflow.com/questions/6311779/finding-cartesian-product-with-php-associative-arrays
369
	function cartesian($input) {
370
		// filter out empty values
371
		$input = array_filter($input);
372
 
373
		$result = array(array());
374
 
375
		foreach ($input as $key => $values) {
376
			$append = array();
377
 
378
			foreach($result as $product) {
379
				foreach($values as $item) {
380
					$product[$key] = $item;
381
					$append[] = $product;
382
				}
383
			}
384
 
385
			$result = $append;
386
		}
387
 
388
		return $result;
1856 aurelien 389
	}
1855 delphine 390
}
391
?>