Subversion Repositories eFlore/Applications.coel

Rev

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