Subversion Repositories eFlore/Applications.coel

Rev

Rev 1928 | Go to most recent revision | Only display areas with differences | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 1928 Rev 1929
1
<?php
1
<?php
2
/**
2
/**
3
 * Exemple lancement:
3
 * Exemple lancement:
4
 * /opt/lampp/bin/php -d memory_limit=3500M cli.php import -n
4
 * /opt/lampp/bin/php -d memory_limit=3500M cli.php import -n
5
 */
5
 */
6
class Import extends Script {
6
class Import extends Script {
7
	private $bdd = null;
7
	private $bdd = null;
8
	private $auteurs = array();
8
	private $auteurs = array();
9
	protected $parametres_autorises = array(
9
	protected $parametres_autorises = array(
10
			'-n' => array(true, false, 'Nom du fichier à importer.'),
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'));
11
			'-u' => array(false, false, 'Infos utilisateur sous forme de JSON contenant : id, session et ip'));
12
	
12
	
13
	protected $table_publication = null;
13
	protected $table_publication = null;
14
	protected $table_auteur = null;
14
	protected $table_auteur = null;
15
	protected $table_publication_a_auteur = null;
15
	protected $table_publication_a_auteur = null;
16
	protected $table_meta = null;
16
	protected $table_meta = null;
-
 
17
	protected $table_structure = 'coel_structure'; // @TODO configurer
-
 
18
	protected $table_collection = 'coel_collection'; // @TODO configurer
-
 
19
	protected $table_collection_bota = 'coel_collection_botanique'; // @TODO configurer
17
	
20
	
18
	protected $id_table_publication = null;
21
	protected $id_table_publication = null;
19
	protected $id_table_publication_personne = null;
22
	protected $id_table_publication_personne = null;
20
	
23
	
21
	protected $id_role_auteur = null;
24
	protected $id_role_auteur = null;
22
	
25
	
23
	protected $colonnes_obligatoires = array();
26
	protected $colonnes_obligatoires = array();
24
	protected $colonnes_acceptees = array();
27
	protected $colonnes_acceptees = array();
25
	
28
	
26
	protected $cache_auteur = array();
29
	protected $cache_auteur = array();
27
	protected $auteurs_a_publis = array();
30
	protected $auteurs_a_publis = array();
28
	protected $publis_a_auteurs = array();
31
	protected $publis_a_auteurs = array();
29
	
32
	
30
	protected $id_utilisateur = 0;
33
	protected $id_utilisateur = 0;
31
	protected $id_session = 0;
34
	protected $id_session = 0;
32
	protected $ip_utilisateur = "127.0.01";
35
	protected $ip_utilisateur = "127.0.01";
33
	
36
	
34
	const ETAT_AJOUTER = 1;
37
	const ETAT_AJOUTER = 1;
35
	
38
	
36
	public function __construct($script_nom, $parametres) {
39
	public function __construct($script_nom, $parametres) {
37
		parent::__construct($script_nom, $parametres);
40
		parent::__construct($script_nom, $parametres);
38
		$this->bdd = new Bdd();
41
		$this->bdd = new Bdd();
39
	}
42
	}
40
	
43
	
41
	public function executer() {
44
	public function executer() {
42
		try {
45
		try {
43
			$this->initialiserScript();
46
			$this->initialiserScript();
44
			$cmd = $this->getParametre('a');
47
			$cmd = $this->getParametre('a');
45
			$fichier = $this->getParametre('n');
48
			$fichier = $this->getParametre('n');
46
			$utilisateur = $this->getParametre('u');
49
			$utilisateur = $this->getParametre('u');
47
			
50
			
48
			$this->traiterInfosUtilisateur($utilisateur);
51
			$this->traiterInfosUtilisateur($utilisateur);
49
			
52
			
50
			switch ($cmd) {
53
			switch ($cmd) {
51
				case "collections" :
54
				case "collections" :
52
					$resultat = $this->chargerCollections($fichier); break;
55
					$resultat = $this->chargerCollections($fichier); break;
53
				case "publi" :
56
				case "publi" :
54
					$resultat = $this->chargerPubli($fichier); break;
57
					$resultat = $this->chargerPubli($fichier); break;
55
				default :
58
				default :
56
					$this->traiterErreur('Erreur : la commande "%s" n\'existe pas!', array($cmd));
59
					$this->traiterErreur('Erreur : la commande "%s" n\'existe pas!', array($cmd));
57
			}
60
			}
58
		} catch (Exception $erreur) {
61
		} catch (Exception $erreur) {
59
			$this->traiterErreur($erreur->getMessage());
62
			$this->traiterErreur($erreur->getMessage());
60
		}
63
		}
61
		
64
		
62
		// renvoi du résultat vers la sortie php
65
		// renvoi du résultat vers la sortie php
63
		// car le script est surtout destiné à être appelé par un web service
66
		// car le script est surtout destiné à être appelé par un web service
64
		echo $resultat;
67
		echo $resultat;
65
		exit;
68
		exit;
66
	}
69
	}
67
	
70
	
68
	private function traiterInfosUtilisateur($utilisateur) {
71
	private function traiterInfosUtilisateur($utilisateur) {
69
		$utilisateur_infos = json_decode($utilisateur, true);
72
		$utilisateur_infos = json_decode($utilisateur, true);
70
		if(!empty($utilisateur_infos)) {
73
		if(!empty($utilisateur_infos)) {
71
			$this->id_utilisateur = !empty($utilisateur_infos['id']) ? $utilisateur_infos['id'] : $this->id_utilisateur;
74
			$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;
75
			$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;
76
			$this->ip_utilisateur = !empty($utilisateur_infos['ip']) ? $utilisateur_infos['ip'] : $this->ip_utilisateur;
74
		}
77
		}
75
	}
78
	}
76
	
79
	
77
	private function initialiserScript() {
80
	private function initialiserScript() {
78
		$fichierIni = $this->getScriptChemin().'import.ini';
81
		$fichierIni = $this->getScriptChemin().'import.ini';
79
		if (file_exists($fichierIni)) {
82
		if (file_exists($fichierIni)) {
80
			Config::charger($fichierIni);
83
			Config::charger($fichierIni);
81
		} else {
84
		} else {
82
			$erreur = "Veuillez configurer le projet en créant le fichier 'import.ini' ".
85
			$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'.";
86
					"dans le dossier du module de script du projet à partir du fichier 'import.defaut.ini'.";
84
			throw new Exception($erreur);
87
			throw new Exception($erreur);
85
		}
88
		}
86
		
89
		
87
		$this->colonnes_obligatoires= Config::get('champs_obligatoires');
90
		$this->colonnes_obligatoires= Config::get('champs_obligatoires');
88
		$this->colonnes_acceptees = Config::get('champs');
91
		$this->colonnes_acceptees = Config::get('champs');
89
		
92
		
90
		$tables = Config::get('tables');
93
		$tables = Config::get('tables');
91
		$this->table_publication = $tables['publication'];
94
		$this->table_publication = $tables['publication'];
92
		$this->table_auteur = $tables['auteur'];
95
		$this->table_auteur = $tables['auteur'];
93
		$this->table_publication_a_auteur = $tables['publication_a_auteur'];
96
		$this->table_publication_a_auteur = $tables['publication_a_auteur'];
94
		$this->table_meta = $tables['meta'];
97
		$this->table_meta = $tables['meta'];
95
		
98
		
96
		$this->id_table_publication = $tables['id_table_publication'];
99
		$this->id_table_publication = $tables['id_table_publication'];
97
		$this->id_table_publication_personne = $tables['id_table_publication_personne'];
100
		$this->id_table_publication_personne = $tables['id_table_publication_personne'];
98
		
101
		
99
		$this->id_role_auteur = $tables['id_role_auteur'];
102
		$this->id_role_auteur = $tables['id_role_auteur'];
100
	}
103
	}
101
	
104
 
-
 
105
	/**
-
 
106
	 * Importe des collections botaniques à partir de deux fichiers : $fichier-collections.csv et
-
 
107
	 * $fichier-collections-bota.csv
-
 
108
	 * Il faut donc fournir en paramètre seulement le début du nom de fichier. Ex :
-
 
109
	 * fichiers:
-
 
110
	 *  - rhone-alpes-collections.csv
-
 
111
	 *  - rhone-alpes-collections-bota.csv
-
 
112
	 * commande :
-
 
113
	 *  - php cli.php import -a collections -n rhone-alpes
-
 
114
	 */
102
	private function chargerCollections($fichier) {
115
	private function chargerCollections($fichier) {
-
 
116
 
-
 
117
		$separateur = "\t"; // @TODO configurer
-
 
118
		$fichierCollections = Config::get('dossiertmp').$fichier . '-collections.csv';
-
 
119
		$fichierCollectionsBota = Config::get('dossiertmp').$fichier . '-collections-bota.csv';
-
 
120
 
-
 
121
		// vérification existence fichiers
-
 
122
		if(!file_exists($fichierCollections)) {
-
 
123
			throw new Exception("Le fichier ".Config::get('dossiertmp').$fichierCollections." n'existe pas.");
-
 
124
		}
-
 
125
		if(!file_exists($fichierCollectionsBota)) {
-
 
126
			throw new Exception("Le fichier ".Config::get('dossiertmp').$fichierCollectionsBota." n'existe pas.");
-
 
127
		}
-
 
128
 
103
		//ouvrir le fichier - collection
129
		//ouvrir le fichier - collection
-
 
130
		$pointeurCollections = fopen($fichierCollections, "r");
-
 
131
		// Chargement de la première colonne (qui contient les noms de colonnes à importer)
-
 
132
		$colonnes = fgetcsv($pointeurCollections, 0, $separateur);
-
 
133
		$colonnesParNom = array_flip($colonnes);
-
 
134
		//var_dump($colonnes);
-
 
135
		//var_dump($colonnesParNom);
-
 
136
 
104
		// vérifier le nom des colonnes
137
		// vérifier le nom des colonnes
-
 
138
		// @TODO on verra plus tard
-
 
139
		/*if(count($colonnes) < 2 || !array_intersect(array_keys($this->colonnes_obligatoires), $colonnes)) {
-
 
140
		// Vérification des colonnes obligatoires et en même temps du séparateur 
-
 
141
			$erreur = "Le fichier ne contient pas les colonnes obligatoires : ".implode(',', array_keys($this->colonnes_obligatoires))."\n";
-
 
142
			$erreur .= "ou bien n'est pas séparé par le caractère ';' ";
-
 
143
			throw new Exception($erreur);
-
 
144
		}*/
-
 
145
 
-
 
146
		$idCollectionsParIdTemp = array();
-
 
147
		// parcours du fichier "-collections.csv"
-
 
148
		while($ligne = fgetcsv($pointeurCollections, 0, $separateur)) {
-
 
149
			//var_dump($ligne);
-
 
150
			$nomStructure = $ligne[$colonnesParNom['cc_ce_structure']];
-
 
151
			if (empty($nomStructure) || is_numeric($nomStructure)) {
-
 
152
				echo "- omission de la structure pour cause de nom chelou [$nomStructure]\n";
-
 
153
				continue;
-
 
154
			}
105
		// tester l'existence de la structure
155
			// tester l'existence de la structure
-
 
156
			$idStructure = $this->verifierExistenceStructureParNom($nomStructure);
106
		// si oui récupérer l'id
157
			// si oui récupérer l'id
107
		//sinon créer la structure et récupérer son id
158
			//sinon créer la structure et récupérer son id
-
 
159
			if ($idStructure === false) {
-
 
160
				$idStructure = $this->creerStructure($nomStructure);
-
 
161
			}
108
		// remplacer le nom de la structure par son id
162
			// remplacer le nom de la structure par son id
109
		// créer les collections et récupérer leur id
163
			// créer les collections et récupérer leur id
-
 
164
			// @TODO vérifier qu'elles existent pour ne pas insérer de doublons en relançant le script !!
-
 
165
			$idCollection = $this->creerCollection($idStructure, $ligne, $colonnesParNom);
-
 
166
			$idCollectionsParIdTemp[$ligne[$colonnesParNom['id']]] = $idCollection;
-
 
167
		}
-
 
168
 
110
		//ouvrir le fichier collection botanique
169
		//ouvrir le fichier collection botanique
-
 
170
		$pointeurCollectionsBota = fopen($fichierCollectionsBota, "r");
-
 
171
		// Chargement de la première colonne (qui contient les noms de colonnes à importer)
-
 
172
		$colonnesBota = fgetcsv($pointeurCollectionsBota, 0, $separateur);
-
 
173
		$colonnesBotaParNom = array_flip($colonnesBota);
-
 
174
		//var_dump($colonnesBota);
-
 
175
		//var_dump($colonnesBotaParNom);
-
 
176
 
111
		// vérifier les colonnes
177
		// vérifier les colonnes
-
 
178
		// @TODO on verra plus tard
-
 
179
 
-
 
180
		// parcours du fichier "-collections-bota.csv"
-
 
181
		while($ligne = fgetcsv($pointeurCollectionsBota, 0, $separateur)) {
112
		// remplacer les noms des collections par leur id (créé précédemment)
182
			// remplacer les noms des collections par leur id (créé précédemment)
-
 
183
			$ligne[$colonnesBotaParNom['ccb_id_collection']] = $idCollectionsParIdTemp[$ligne[$colonnesBotaParNom['ccb_id_collection']]];
113
		// créer/importer
184
			// créer/importer
-
 
185
			// @TODO vérifier qu'elles existent pour ne pas insérer de doublons en relançant le script !!
-
 
186
			$this->creerCollectionBota($ligne, $colonnesBotaParNom);
-
 
187
		}
114
		
188
		
-
 
189
	}
-
 
190
 
-
 
191
	/**
-
 
192
	 * Si une structure ayant pour nom $nomStructure existe, retourne son
-
 
193
	 * identifiant numérique, sinon retourne false
-
 
194
	 */
-
 
195
	protected function verifierExistenceStructureParNom($nomStructure) {
-
 
196
		$idStructure = false;
-
 
197
		$nsp = $this->bdd->proteger($nomStructure);
-
 
198
		$requete = "SELECT cs_id_structure FROM " . $this->table_structure
-
 
199
			. " WHERE cs_nom = $nsp";
-
 
200
 
-
 
201
		$resultat = $this->bdd->recupererTous($requete);
-
 
202
		// var_dump($resultat);
-
 
203
		if (count($resultat) > 0) {
-
 
204
			$idStructure = $resultat[0]['cs_id_structure'];
-
 
205
		}
-
 
206
		return $idStructure;
-
 
207
	}
-
 
208
 
-
 
209
	/**
-
 
210
	 * Crée une structure portant le nom $nomStructure, sans rien fournir d'autre, et
-
 
211
	 * retourne l'identifiant numérique du novueau tuple
-
 
212
	 */
-
 
213
	protected function creerStructure($nomStructure) {
-
 
214
		$nsp = $this->bdd->proteger($nomStructure);
-
 
215
		$requete = "INSERT INTO " . $this->table_structure . " (cs_nom)"
-
 
216
			. " VALUES ($nsp)";
-
 
217
		//echo "REQ INS: $requete\n";
-
 
218
		$resultat = $this->bdd->executer($requete);
-
 
219
		$idStructure = $this->bdd->recupererIdDernierAjout();
-
 
220
 
-
 
221
		return $idStructure;
-
 
222
	}
-
 
223
 
-
 
224
	/**
-
 
225
	 * Crée une collection en la rattachant à la structure d'id $idStrucutre; la remplit
-
 
226
	 * avec les données issues de $ligne en se servant de $colonnesParNom pour accéder
-
 
227
	 * aux valeurs par clés textuelles; retourne l'identifiant numérique du novueau tuple
-
 
228
	 */
-
 
229
	protected function creerCollection($idStructure, $ligne, $colonnesParNom) {
-
 
230
		//echo "Insertion ! : "; var_dump($ligne); echo "<br/>";
-
 
231
		$nom = $this->bdd->proteger($ligne[$colonnesParNom['cc_nom']]);
-
 
232
		$desc = $this->bdd->proteger($ligne[$colonnesParNom['cc_description']]);
-
 
233
		$pcd = $this->bdd->proteger($ligne[$colonnesParNom['cc_periode_constitution_debut']]);
-
 
234
		$pcf = $this->bdd->proteger($ligne[$colonnesParNom['cc_periode_constitution_fin']]);
-
 
235
		$tcl = $this->bdd->proteger($ligne[$colonnesParNom['cc_truk_couverture_lieu']]);
-
 
236
		$cst = $this->bdd->proteger($ligne[$colonnesParNom['cc_ce_specimen_type']]);
-
 
237
 
-
 
238
		$requete = "INSERT INTO " . $this->table_collection
-
 
239
			. " (cc_ce_structure, cc_nom, cc_description, cc_periode_constitution_debut, cc_periode_constitution_fin, cc_truk_couverture_lieu, cc_ce_specimen_type)"
-
 
240
			. " VALUES ($idStructure, $nom, $desc, $pcd, $pcf, $tcl, $cst)";
-
 
241
		//echo "REQ INS: $requete\n";
-
 
242
		$resultat = $this->bdd->executer($requete);
-
 
243
		$idCollection = $this->bdd->recupererIdDernierAjout();
-
 
244
		
-
 
245
		return $idCollection;
-
 
246
	}
-
 
247
 
-
 
248
	/**
-
 
249
	 * Crée une collection botanique; la remplit avec les données issues de $ligne en se
-
 
250
	 * servant de $colonnesParNom pour accéder aux valeurs par clés textuelles
-
 
251
	 */
-
 
252
	protected function creerCollectionBota($ligne, $colonnesBotaParNom) {
-
 
253
		//echo "Insertion ! : "; var_dump($ligne); echo "<br/>";
-
 
254
		$id = $this->bdd->proteger($ligne[$colonnesBotaParNom['ccb_id_collection']]);
-
 
255
		$ceg = $this->bdd->proteger($ligne[$colonnesBotaParNom['ccb_ce_etat_general']]);
-
 
256
		$ne = $this->bdd->proteger($ligne[$colonnesBotaParNom['ccb_nbre_echantillon']]);
-
 
257
		$spec = $this->bdd->proteger($ligne[$colonnesBotaParNom['ccb_specialite']]);
-
 
258
		$ac = $this->bdd->proteger($ligne[$colonnesBotaParNom['ccb_annotation_classement']]);
-
 
259
		$ct = $this->bdd->proteger($ligne[$colonnesBotaParNom['ccb_ce_traitement']]);
-
 
260
		$ci = $this->bdd->proteger($ligne[$colonnesBotaParNom['ccb_ce_inventaire']]);
-
 
261
		$ii = $this->bdd->proteger($ligne[$colonnesBotaParNom['ccb_inventaire_info']]);
-
 
262
		$aur = $this->bdd->proteger($ligne[$colonnesBotaParNom['ccb_autres_unite_rangement']]);
-
 
263
		$tcpt = $this->bdd->proteger($ligne[$colonnesBotaParNom['ccb_truk_conservation_papier_type']]);
-
 
264
 
-
 
265
		// @TODO comment gérer la colonne "Nombre de parts" ? Faut la mettre dans quoi ?
-
 
266
		$requete = "INSERT INTO " . $this->table_collection_bota
-
 
267
			. " (ccb_id_collection, ccb_ce_etat_general, ccb_nbre_echantillon, ccb_specialite, ccb_annotation_classement, ccb_ce_traitement, ccb_ce_inventaire,"
-
 
268
			. " ccb_inventaire_info, ccb_autres_unites_rangement, ccb_truk_conservation_papier_type)"
-
 
269
			. " VALUES ($id, $ceg, $ne, $spec, $ac, $ct, $ci, $ii, $aur, $tcpt)";
-
 
270
		//echo "REQ INS: $requete\n";
-
 
271
		$resultat = $this->bdd->executer($requete);
115
	}
272
	}
116
 
273
 
117
	private function chargerPubli($fichier) {
274
	private function chargerPubli($fichier) {
118
		
275
		
119
		// vérification existence fichier
276
		// vérification existence fichier
120
		if(!file_exists(Config::get('dossiertmp').$fichier)) {
277
		if(!file_exists(Config::get('dossiertmp').$fichier)) {
121
			$erreur = "Le fichier ".Config::get('dossiertmp').$fichier." n'existe pas.";
278
			$erreur = "Le fichier ".Config::get('dossiertmp').$fichier." n'existe pas.";
122
			throw new Exception($erreur);
279
			throw new Exception($erreur);
123
		}
280
		}
124
		
281
		
125
		$pointeur = fopen(Config::get('dossiertmp').$fichier, "r");
282
		$pointeur = fopen(Config::get('dossiertmp').$fichier, "r");
126
		// Chargement de la première colonne (qui contient les noms de colonnes à importer
283
		// Chargement de la première colonne (qui contient les noms de colonnes à importer
127
		$colonnes = fgetcsv($pointeur, 0, ";");
284
		$colonnes = fgetcsv($pointeur, 0, ";");
128
 
285
 
129
		// Vérification des colonnes obligatoires et en même temps du séparateur 
286
		// 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)) {
287
		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";
288
			$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 ';' ";
289
			$erreur .= "ou bien n'est pas séparé par le caractère ';' ";
133
			throw new Exception($erreur);
290
			throw new Exception($erreur);
134
		}
291
		}
135
		
292
		
136
		
293
		
137
		//TODO: vérifier si les deux index ci dessous ne font pas double emploi
294
		//TODO: vérifier si les deux index ci dessous ne font pas double emploi
138
		
295
		
139
		// Création d'un index des colonnes qui seront importées dans la fiche en les associant 
296
		// 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
297
		// au numéro de colonne dans la feuille csv
141
		$index_colonnes_importees = array_intersect(array_keys($this->colonnes_acceptees), $colonnes);
298
		$index_colonnes_importees = array_intersect(array_keys($this->colonnes_acceptees), $colonnes);
142
		$colonnes_importees = array();
299
		$colonnes_importees = array();
143
		foreach($index_colonnes_importees as $index_colonne_importee) {
300
		foreach($index_colonnes_importees as $index_colonne_importee) {
144
			$colonnes_importees[] = $this->colonnes_acceptees[$index_colonne_importee];
301
			$colonnes_importees[] = $this->colonnes_acceptees[$index_colonne_importee];
145
		}
302
		}
146
		
303
		
147
		$index_colonnes_refusees = array_keys(array_diff($colonnes, array_keys($this->colonnes_acceptees)));
304
		$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
305
		// Création d'un index associant chaque numéro de colonne importée à son rôle
149
		// pour y apporter des traitement spécifiques
306
		// pour y apporter des traitement spécifiques
150
		$index_colonnes_importees = $colonnes;
307
		$index_colonnes_importees = $colonnes;
151
		foreach($index_colonnes_refusees as $colonne_refusee) {
308
		foreach($index_colonnes_refusees as $colonne_refusee) {
152
			unset($index_colonnes_importees[$colonne_refusee]);
309
			unset($index_colonnes_importees[$colonne_refusee]);
153
		}
310
		}
154
		
311
		
155
		$roles_a_num_colonnes = array_flip($index_colonnes_importees);
312
		$roles_a_num_colonnes = array_flip($index_colonnes_importees);
156
			
313
			
157
		// Ajout de la colonne nom complet aux champs de la requête
314
		// Ajout de la colonne nom complet aux champs de la requête
158
		$colonnes_importees[] = 'cpu_fmt_nom_complet';
315
		$colonnes_importees[] = 'cpu_fmt_nom_complet';
159
 
316
 
160
		$nb_publis_inserees = 0;
317
		$nb_publis_inserees = 0;
161
		$lignes = array();
318
		$lignes = array();
162
		while($ligne = fgetcsv($pointeur, 0, ";")) {
319
		while($ligne = fgetcsv($pointeur, 0, ";")) {
163
			$ligne_inseree = array();
320
			$ligne_inseree = array();
164
			
321
			
165
			// Traitement des champs suivant leur role
322
			// Traitement des champs suivant leur role
166
			foreach($ligne as $index => &$valeur) {
323
			foreach($ligne as $index => &$valeur) {
167
				if(!in_array($index, $index_colonnes_refusees)) {
324
				if(!in_array($index, $index_colonnes_refusees)) {
168
					$ligne_inseree[] = $this->traiterChamp($valeur, $index_colonnes_importees[$index]);
325
					$ligne_inseree[] = $this->traiterChamp($valeur, $index_colonnes_importees[$index]);
169
				}
326
				}
170
			}
327
			}
171
			
328
			
172
			// Ajout du nom complet formaté de la publication
329
			// Ajout du nom complet formaté de la publication
173
			$nom_complet = $this->bdd->proteger($this->formaterNomComplet($ligne, $index_colonnes_importees));
330
			$nom_complet = $this->bdd->proteger($this->formaterNomComplet($ligne, $index_colonnes_importees));
174
			$ligne_inseree[] = $nom_complet;
331
			$ligne_inseree[] = $nom_complet;
175
			
332
			
176
			$id_publication = $this->insererPublication($colonnes_importees, $ligne_inseree);
333
			$id_publication = $this->insererPublication($colonnes_importees, $ligne_inseree);
177
			// TODO: quoi faire en cas d'échec pour une publication ?
334
			// TODO: quoi faire en cas d'échec pour une publication ?
178
			if(!empty($id_publication)) {	
335
			if(!empty($id_publication)) {	
179
				$nb_publis_inserees++;
336
				$nb_publis_inserees++;
180
				// Pour aller plus vite on pourrait éventuellement faire une grosse requete d'ajout des publications
337
				// 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)
338
				// à 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']]);
339
				$nb_auteurs_lies = $this->insererLiensPublicationAuteurs($id_publication, $ligne[$roles_a_num_colonnes['auteur']]);
183
			}
340
			}
184
 
341
 
185
		}
342
		}
186
			
343
			
187
		return $nb_publis_inserees;
344
		return $nb_publis_inserees;
188
	}
345
	}
189
	
346
	
190
	
347
	
191
	private function insererPublication(&$colonnes, &$publication) {		
348
	private function insererPublication(&$colonnes, &$publication) {		
192
		$requete = "INSERT INTO ".$this->table_publication." ".
349
		$requete = "INSERT INTO ".$this->table_publication." ".
193
				"(".implode(',', $colonnes).") ".
350
				"(".implode(',', $colonnes).") ".
194
				"VALUES (".implode(",", $publication).")";
351
				"VALUES (".implode(",", $publication).")";
195
					
352
					
196
		$insertion = $this->bdd->executer($requete);
353
		$insertion = $this->bdd->executer($requete);
197
		$id_publi = $this->bdd->recupererIdDernierAjout();
354
		$id_publi = $this->bdd->recupererIdDernierAjout();
198
 
355
 
199
		// Historisation de l'ajout
356
		// Historisation de l'ajout
200
		$histo = $this->creerXmlHisto(array_combine($colonnes, $publication));
357
		$histo = $this->creerXmlHisto(array_combine($colonnes, $publication));
201
		$id_meta = $this->historiser($this->id_table_publication, $id_publi, $histo);
358
		$id_meta = $this->historiser($this->id_table_publication, $id_publi, $histo);
202
		// Affectation des méta données concernat l'ajout à la publication
359
		// Affectation des méta données concernat l'ajout à la publication
203
		$requete_affectation_meta = "UPDATE  ".$this->table_publication." ".
360
		$requete_affectation_meta = "UPDATE  ".$this->table_publication." ".
204
				"SET cpu_ce_meta = ".$id_meta." ".
361
				"SET cpu_ce_meta = ".$id_meta." ".
205
				"WHERE cpu_id_publication = ".$id_publi;
362
				"WHERE cpu_id_publication = ".$id_publi;
206
 
363
 
207
		$this->bdd->executer($requete_affectation_meta);
364
		$this->bdd->executer($requete_affectation_meta);
208
		
365
		
209
		return $id_publi;
366
		return $id_publi;
210
	}
367
	}
211
	
368
	
212
	protected function insererLiensPublicationAuteurs($id_publication, &$auteurs) {
369
	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');
370
		$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." ".
371
		$requete = "INSERT IGNORE INTO ".$this->table_publication_a_auteur." ".
215
				"(".implode(",", $colonnes).") VALUES ";
372
				"(".implode(",", $colonnes).") VALUES ";
216
		
373
		
217
		// L'ordre des auteurs commence à 1
374
		// L'ordre des auteurs commence à 1
218
		$ordre_auteur = 1; 
375
		$ordre_auteur = 1; 
219
		
376
		
220
		// Découpage des différents auteurs
377
		// Découpage des différents auteurs
221
		$auteurs_tab = explode(',', $auteurs);
378
		$auteurs_tab = explode(',', $auteurs);
222
		$auteurs_tab = array_filter($auteurs_tab);
379
		$auteurs_tab = array_filter($auteurs_tab);
223
		
380
		
224
		// Les auteurs sont normalement cités dans l'ordre dans l'import
381
		// Les auteurs sont normalement cités dans l'ordre dans l'import
225
		foreach($auteurs_tab as $auteur) {			
382
		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
383
			// 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])) {				
384
			if(is_array($this->cache_auteur[$auteur])) {				
228
				$id_auteur = $this->cache_auteur[$auteur]['cp_id_personne'];
385
				$id_auteur = $this->cache_auteur[$auteur]['cp_id_personne'];
229
				
386
				
230
				$valeurs = array($id_publication, $id_auteur, $this->id_role_auteur, "NULL", $ordre_auteur, "0");
387
				$valeurs = array($id_publication, $id_auteur, $this->id_role_auteur, "NULL", $ordre_auteur, "0");
231
			
388
			
232
				$requete_insertion = $requete." (".implode(',', $valeurs).") ";
389
				$requete_insertion = $requete." (".implode(',', $valeurs).") ";
233
				$liaison = $this->bdd->executer($requete_insertion);
390
				$liaison = $this->bdd->executer($requete_insertion);
234
								
391
								
235
				// Historisation de l'ajout
392
				// Historisation de l'ajout
236
				$histo = $this->creerXmlHisto(array_combine($colonnes, $liaison));
393
				$histo = $this->creerXmlHisto(array_combine($colonnes, $liaison));
237
				$cle_liaison = $id_publication.'-'.$this->id_role_auteur.'-'.$id_auteur;
394
				$cle_liaison = $id_publication.'-'.$this->id_role_auteur.'-'.$id_auteur;
238
				$id_meta = $this->historiser($this->id_table_publication_personne, $cle_liaison, $histo);
395
				$id_meta = $this->historiser($this->id_table_publication_personne, $cle_liaison, $histo);
239
				
396
				
240
				// Affectation des méta données concernant l'ajout à la publication à auteur
397
				// Affectation des méta données concernant l'ajout à la publication à auteur
241
				$requete_affectation_meta = "UPDATE  ".$this->table_publication_a_auteur." ".
398
				$requete_affectation_meta = "UPDATE  ".$this->table_publication_a_auteur." ".
242
						"SET cpuap_ce_meta = ".$id_meta;
399
						"SET cpuap_ce_meta = ".$id_meta;
243
				$this->bdd->executer($requete_affectation_meta);
400
				$this->bdd->executer($requete_affectation_meta);
244
			}
401
			}
245
			// L'ordre des auteurs est conservé même pour ceux qui n'existe pas dans la bdd 
402
			// L'ordre des auteurs est conservé même pour ceux qui n'existe pas dans la bdd 
246
			$ordre_auteur++;
403
			$ordre_auteur++;
247
		}
404
		}
248
	}
405
	}
249
	
406
	
250
	protected function creerXmlHisto($donnees) {
407
	protected function creerXmlHisto($donnees) {
251
		// Création du xml de l'enregistrement à historiser
408
		// Création du xml de l'enregistrement à historiser
252
		$info = null;
409
		$info = null;
253
		$xml_tpl = '<?xml version="1.0" encoding="UTF-8" ?>'."\n<resultset>\n<row>\n%s</row>\n</resultset>";
410
		$xml_tpl = '<?xml version="1.0" encoding="UTF-8" ?>'."\n<resultset>\n<row>\n%s</row>\n</resultset>";
254
		$xml = null;
411
		$xml = null;
255
			
412
			
256
		foreach ($donnees as $cle => $valeur) {
413
		foreach ($donnees as $cle => $valeur) {
257
			// Pour éviter un éventuel double échappement des valeurs
414
			// Pour éviter un éventuel double échappement des valeurs
258
			$valeur = stripslashes($valeur);
415
			$valeur = stripslashes($valeur);
259
			$valeur = trim($valeur, "'");
416
			$valeur = trim($valeur, "'");
260
			if (!is_null($valeur) && $valeur != '') {
417
			if (!is_null($valeur) && $valeur != '') {
261
				$xml .= "<$cle>$valeur</$cle>\n";
418
				$xml .= "<$cle>$valeur</$cle>\n";
262
			}
419
			}
263
		}
420
		}
264
		if ($xml !== null) {
421
		if ($xml !== null) {
265
			$info = sprintf($xml_tpl, $xml);
422
			$info = sprintf($xml_tpl, $xml);
266
			$info = $this->bdd->proteger($info);
423
			$info = $this->bdd->proteger($info);
267
		}
424
		}
268
	
425
	
269
		return $info;
426
		return $info;
270
	}
427
	}
271
	
428
	
272
	protected function historiser($table_id, $ligne_cle, $info) {
429
	protected function historiser($table_id, $ligne_cle, $info) {
273
		date_default_timezone_set('Europe/Paris');
430
		date_default_timezone_set('Europe/Paris');
274
		// Pré-traitement des variables
431
		// Pré-traitement des variables
275
		$info = (is_null($info)) ? 'NULL' : $info;
432
		$info = (is_null($info)) ? 'NULL' : $info;
276
	
433
	
277
		// Historisation (Ajout des méta-données)
434
		// Historisation (Ajout des méta-données)
278
		$requete = 	'INSERT INTO coel_meta_historique_ligne '.
435
		$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) '.
436
				'	(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 ('.
437
				'VALUES ('.
281
				"		$table_id, ".
438
				"		$table_id, ".
282
				'		"'.$ligne_cle.'", '.
439
				'		"'.$ligne_cle.'", '.
283
				"		$info, ".
440
				"		$info, ".
284
				'		"'.date('Y-m-d H:i:s', time()).'", '.
441
				'		"'.date('Y-m-d H:i:s', time()).'", '.
285
				"		$this->id_utilisateur, ".
442
				"		$this->id_utilisateur, ".
286
				"		".self::ETAT_AJOUTER.", ".
443
				"		".self::ETAT_AJOUTER.", ".
287
				'		"'.$this->ip_utilisateur.'", '.
444
				'		"'.$this->ip_utilisateur.'", '.
288
				'		"'.$this->id_session.'") ';
445
				'		"'.$this->id_session.'") ';
289
		$resultat = $this->bdd->executer($requete);
446
		$resultat = $this->bdd->executer($requete);
290
		return $this->bdd->recupererIdDernierAjout();
447
		return $this->bdd->recupererIdDernierAjout();
291
	}
448
	}
292
	
449
	
293
	protected function formaterNomComplet($ligne, $roles) {
450
	protected function formaterNomComplet($ligne, $roles) {
294
		
451
		
295
		$roles = array_flip($roles);
452
		$roles = array_flip($roles);
296
		
453
		
297
		// Intitulé de la publication complet : fmt_auteur, date_parution(année). titre. Editeur (nom), collection, fascicule, indication_nvt. pages.
454
		// Intitulé de la publication complet : fmt_auteur, date_parution(année). titre. Editeur (nom), collection, fascicule, indication_nvt. pages.
298
		// indication_nvt = serie_tome 
455
		// indication_nvt = serie_tome 
299
		$champs_nom_complet = array('auteur', 'annee', 'titre', 'editeur', 'intitule_revue', 'fascicule', 'serie_tome', 'pages');
456
		$champs_nom_complet = array('auteur', 'annee', 'titre', 'editeur', 'intitule_revue', 'fascicule', 'serie_tome', 'pages');
300
		$champs_fmt = array();
457
		$champs_fmt = array();
301
		
458
		
302
		$fmt_nom_complet = "";
459
		$fmt_nom_complet = "";
303
		
460
		
304
		foreach($champs_nom_complet as $champ) {
461
		foreach($champs_nom_complet as $champ) {
305
			$index = $roles[$champ];
462
			$index = $roles[$champ];
306
			if(!isset($ligne[$index])) {				
463
			if(!isset($ligne[$index])) {				
307
				$champs_fmt[$champ] = "";
464
				$champs_fmt[$champ] = "";
308
			} else {
465
			} else {
309
				$champs_fmt[$champ] = $ligne[$index];
466
				$champs_fmt[$champ] = $ligne[$index];
310
			}
467
			}
311
		}
468
		}
312
		
469
		
313
		$indication_nvt_pages = array($champs_fmt['serie_tome'], $champs_fmt['pages']);
470
		$indication_nvt_pages = array($champs_fmt['serie_tome'], $champs_fmt['pages']);
314
		$indication_nvt_pages = array_filter($indication_nvt_pages, 'strlen');
471
		$indication_nvt_pages = array_filter($indication_nvt_pages, 'strlen');
315
		$indication_nvt_pages = trim(implode(". ", $indication_nvt_pages));
472
		$indication_nvt_pages = trim(implode(". ", $indication_nvt_pages));
316
		$indication_nvt_pages .= !empty($indication_nvt_pages) ? "." : "";
473
		$indication_nvt_pages .= !empty($indication_nvt_pages) ? "." : "";
317
		
474
		
318
		$annee_titre_editeur = array($champs_fmt['annee'], $champs_fmt['titre'], $champs_fmt['editeur']);
475
		$annee_titre_editeur = array($champs_fmt['annee'], $champs_fmt['titre'], $champs_fmt['editeur']);
319
		$annee_titre_editeur = array_filter($annee_titre_editeur, 'strlen');
476
		$annee_titre_editeur = array_filter($annee_titre_editeur, 'strlen');
320
		$annee_titre_editeur = trim(implode(". ", $annee_titre_editeur));
477
		$annee_titre_editeur = trim(implode(". ", $annee_titre_editeur));
321
		
478
		
322
		$fmt_nom_complet =  array($champs_fmt['auteur'], 
479
		$fmt_nom_complet =  array($champs_fmt['auteur'], 
323
							$annee_titre_editeur, 
480
							$annee_titre_editeur, 
324
							$champs_fmt['intitule_revue'],
481
							$champs_fmt['intitule_revue'],
325
							$champs_fmt['fascicule'],
482
							$champs_fmt['fascicule'],
326
							$indication_nvt_pages);
483
							$indication_nvt_pages);
327
		
484
		
328
		$fmt_nom_complet = array_filter($fmt_nom_complet, 'strlen');
485
		$fmt_nom_complet = array_filter($fmt_nom_complet, 'strlen');
329
		$fmt_nom_complet = implode(", ", $fmt_nom_complet);
486
		$fmt_nom_complet = implode(", ", $fmt_nom_complet);
330
		
487
		
331
		return $fmt_nom_complet;
488
		return $fmt_nom_complet;
332
	}
489
	}
333
	
490
	
334
	private function traiterChamp($valeur, $role) {
491
	private function traiterChamp($valeur, $role) {
335
		switch($role) {
492
		switch($role) {
336
			case 'auteur':
493
			case 'auteur':
337
				$valeur = $this->traiterChampAuteur($valeur);
494
				$valeur = $this->traiterChampAuteur($valeur);
338
			break;
495
			break;
339
			case 'editeur':
496
			case 'editeur':
340
				$valeur = 'AUTRE##'.$valeur;
497
				$valeur = 'AUTRE##'.$valeur;
341
			break;
498
			break;
342
		}
499
		}
343
		
500
		
344
		return $this->bdd->proteger($valeur);
501
		return $this->bdd->proteger($valeur);
345
	}
502
	}
346
	
503
	
347
	private function traiterChampAuteur($auteur_intitule) {
504
	private function traiterChampAuteur($auteur_intitule) {
348
		$auteurs_fmt = array();
505
		$auteurs_fmt = array();
349
		$auteurs_tab = explode(',', $auteur_intitule);
506
		$auteurs_tab = explode(',', $auteur_intitule);
350
		foreach($auteurs_tab as $auteur) {
507
		foreach($auteurs_tab as $auteur) {
351
			if(!empty(trim($auteur))) {
508
			if(!empty(trim($auteur))) {
352
				$auteurs_fmt[] = $this->obtenirInfosAuteur($auteur);
509
				$auteurs_fmt[] = $this->obtenirInfosAuteur($auteur);
353
			}
510
			}
354
		}
511
		}
355
		
512
		
356
		return implode(', ', $auteurs_fmt);
513
		return implode(', ', $auteurs_fmt);
357
	}
514
	}
358
	
515
	
359
	private function obtenirInfosAuteur($auteur_intitule) {
516
	private function obtenirInfosAuteur($auteur_intitule) {
360
		$retour = $auteur_intitule;
517
		$retour = $auteur_intitule;
361
		// Si on déjà recherché et trouvé (ou non l'auteur)
518
		// Si on déjà recherché et trouvé (ou non l'auteur)
362
		if(isset($this->cache_auteur[$auteur_intitule])) {
519
		if(isset($this->cache_auteur[$auteur_intitule])) {
363
			// On renvoie son nom complet formaté s'il existe en bdd ou sinon
520
			// On renvoie son nom complet formaté s'il existe en bdd ou sinon
364
			// le nom qui a été donné dans la feuille csv
521
			// le nom qui a été donné dans la feuille csv
365
			$retour = !empty($this->cache_auteur[$auteur_intitule]['cp_fmt_nom_complet']) ?
522
			$retour = !empty($this->cache_auteur[$auteur_intitule]['cp_fmt_nom_complet']) ?
366
				$this->cache_auteur[$auteur_intitule]['cp_fmt_nom_complet'] :
523
				$this->cache_auteur[$auteur_intitule]['cp_fmt_nom_complet'] :
367
				$auteur_intitule;
524
				$auteur_intitule;
368
		} else {
525
		} else {
369
			// Recherche de l'auteur sur un maximum du combinaisons possible des variations
526
			// Recherche de l'auteur sur un maximum du combinaisons possible des variations
370
			// de son nom et prénom
527
			// de son nom et prénom
371
			$auteur = $this->fabriquerCombinaisonsAuteur($auteur_intitule);
528
			$auteur = $this->fabriquerCombinaisonsAuteur($auteur_intitule);
372
			$auteur_req = "(".implode(', ', $auteur).")";
529
			$auteur_req = "(".implode(', ', $auteur).")";
373
			
530
			
374
			$requete = "SELECT cp_id_personne, cp_fmt_nom_complet FROM ".$this->table_auteur." WHERE cp_fmt_nom_complet IN ".$auteur_req;
531
			$requete = "SELECT cp_id_personne, cp_fmt_nom_complet FROM ".$this->table_auteur." WHERE cp_fmt_nom_complet IN ".$auteur_req;
375
			$infos_auteur = $this->bdd->recupererTous($requete);
532
			$infos_auteur = $this->bdd->recupererTous($requete);
376
						
533
						
377
			// Stockage en cache de la ligne de bdd si trouvé,
534
			// Stockage en cache de la ligne de bdd si trouvé,
378
			// de la valeur brute sinon
535
			// de la valeur brute sinon
379
			if(!empty($infos_auteur)) {
536
			if(!empty($infos_auteur)) {
380
				$retour = $infos_auteur[0]['cp_fmt_nom_complet'];
537
				$retour = $infos_auteur[0]['cp_fmt_nom_complet'];
381
				$this->cache_auteur[$auteur_intitule] = $infos_auteur[0];
538
				$this->cache_auteur[$auteur_intitule] = $infos_auteur[0];
382
				// Stocker le nom d'auteur sous les deux formes (fmt nom complet et tel que saisi), facilite la recherche
539
				// 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
540
				// plus tard lors de la liaison des publications aux auteurs
384
				$this->cache_auteur[$infos_auteur[0]['cp_fmt_nom_complet']] = $infos_auteur[0];
541
				$this->cache_auteur[$infos_auteur[0]['cp_fmt_nom_complet']] = $infos_auteur[0];
385
			} else {
542
			} else {
386
				$retour = $auteur_intitule;
543
				$retour = $auteur_intitule;
387
				$this->cache_auteur[$auteur_intitule] = $auteur_intitule;
544
				$this->cache_auteur[$auteur_intitule] = $auteur_intitule;
388
			}
545
			}
389
		}
546
		}
390
		
547
		
391
		return $retour;
548
		return $retour;
392
	}
549
	}
393
			
550
			
394
	private function fabriquerCombinaisonsAuteur($auteur) {
551
	private function fabriquerCombinaisonsAuteur($auteur) {
395
		
552
		
396
		$auteur = trim($auteur);
553
		$auteur = trim($auteur);
397
		$auteurs_formates = array($this->bdd->proteger($auteur));
554
		$auteurs_formates = array($this->bdd->proteger($auteur));
398
		
555
		
399
		// Séparation des élements de l'auteur des espaces pour obtenir
556
		// Séparation des élements de l'auteur des espaces pour obtenir
400
		// les noms et prénoms (Ex. "Carl Von Linné" => "Carl", "Von", "Linné")
557
		// les noms et prénoms (Ex. "Carl Von Linné" => "Carl", "Von", "Linné")
401
		$auteur_tab = explode(' ', $auteur);
558
		$auteur_tab = explode(' ', $auteur);
402
		$auteur_tab = array_filter($auteur_tab);
559
		$auteur_tab = array_filter($auteur_tab);
403
		
560
		
404
		$combinaisons = array();
561
		$combinaisons = array();
405
		foreach($auteur_tab as &$element_auteur) {
562
		foreach($auteur_tab as &$element_auteur) {
406
			$combinaisons[] = array(
563
			$combinaisons[] = array(
407
								// élement tel quel (Ex: "Linné")
564
								// élement tel quel (Ex: "Linné")
408
								$element_auteur,
565
								$element_auteur,
409
								// possibilité de l'initiale seule (Ex: "L")
566
								// possibilité de l'initiale seule (Ex: "L")
410
								substr($element_auteur, 0, 1),
567
								substr($element_auteur, 0, 1),
411
								// possibilité de l'initiale avec un point du genre (Ex: "L.")
568
								// possibilité de l'initiale avec un point du genre (Ex: "L.")
412
								substr($element_auteur, 0, 1)."."
569
								substr($element_auteur, 0, 1)."."
413
							);
570
							);
414
		}
571
		}
415
		
572
		
416
		// Fabrication de toutes les combinaisons possibles des parties de noms ci-dessus 
573
		// Fabrication de toutes les combinaisons possibles des parties de noms ci-dessus 
417
		// pour deux et trois élements en faisant plusieurs produits cartésiens
574
		// 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
575
		// 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...)
576
		// (Ex. : "Carl Von Linné" VS "C. Von Linné" ou "C. V. Linné" ou encore "Von Linné C." etc...)
420
		
577
		
421
		// C'est moche et pas très élégant mais bon ça marche dans 90% des cas
578
		// 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
579
		// 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
580
		// TODO: faire mieux et factoriser les appels ci dessous
424
		if(count($auteur_tab) > 2) {
581
		if(count($auteur_tab) > 2) {
425
			// Cas du nom à trois parties (genre "Carl Von Linné")
582
			// Cas du nom à trois parties (genre "Carl Von Linné")
426
			$possibilites_auteurs = $this->cartesian(array($combinaisons[0], $combinaisons[1], $combinaisons[2]));
583
			$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])));
584
			$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])));
585
			$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])));
586
			$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])));
587
			$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])));
588
			$possibilites_auteurs = array_merge($possibilites_auteurs, $this->cartesian(array($combinaisons[2], $combinaisons[0], $combinaisons[1])));
432
		} else {
589
		} else {
433
			// Cas du nom à trois parties (genre "Carl Linné")
590
			// Cas du nom à trois parties (genre "Carl Linné")
434
			$possibilites_auteurs = $this->cartesian(array($combinaisons[0], $combinaisons[1]));
591
			$possibilites_auteurs = $this->cartesian(array($combinaisons[0], $combinaisons[1]));
435
			$possibilites_auteurs = array_merge($possibilites_auteurs, $this->cartesian(array($combinaisons[1], $combinaisons[0])));
592
			$possibilites_auteurs = array_merge($possibilites_auteurs, $this->cartesian(array($combinaisons[1], $combinaisons[0])));
436
		}
593
		}
437
		
594
		
438
		$auteurs_formates = array();
595
		$auteurs_formates = array();
439
		foreach($possibilites_auteurs as &$possibilite) {
596
		foreach($possibilites_auteurs as &$possibilite) {
440
			$initiales = true;
597
			$initiales = true;
441
			// Suppression des possibilités ne contenant que des initiales avec ou sans point
598
			// Suppression des possibilités ne contenant que des initiales avec ou sans point
442
			foreach($possibilite as &$chars) {
599
			foreach($possibilite as &$chars) {
443
				$initiales = $initiales && mb_strlen($chars) <= 2;
600
				$initiales = $initiales && mb_strlen($chars) <= 2;
444
			}
601
			}
445
 
602
 
446
			if(!$initiales) {
603
			if(!$initiales) {
447
				$auteurs_formates[] = $this->bdd->proteger(implode(" ", $possibilite));
604
				$auteurs_formates[] = $this->bdd->proteger(implode(" ", $possibilite));
448
			}
605
			}
449
		}
606
		}
450
 
607
 
451
		return $auteurs_formates;
608
		return $auteurs_formates;
452
	}
609
	}
453
 
610
 
454
	// http://stackoverflow.com/questions/6311779/finding-cartesian-product-with-php-associative-arrays
611
	// http://stackoverflow.com/questions/6311779/finding-cartesian-product-with-php-associative-arrays
455
	function cartesian($input) {
612
	function cartesian($input) {
456
		// filter out empty values
613
		// filter out empty values
457
		$input = array_filter($input);
614
		$input = array_filter($input);
458
	
615
	
459
		$result = array(array());
616
		$result = array(array());
460
	
617
	
461
		foreach ($input as $key => $values) {
618
		foreach ($input as $key => $values) {
462
			$append = array();
619
			$append = array();
463
	
620
	
464
			foreach($result as $product) {
621
			foreach($result as $product) {
465
				foreach($values as $item) {
622
				foreach($values as $item) {
466
					$product[$key] = $item;
623
					$product[$key] = $item;
467
					$append[] = $product;
624
					$append[] = $product;
468
				}
625
				}
469
			}
626
			}
470
	
627
	
471
			$result = $append;
628
			$result = $append;
472
		}
629
		}
473
	
630
	
474
		return $result;
631
		return $result;
475
	}
632
	}
476
}
633
}
477
?>
634
?>