Subversion Repositories eFlore/Projets.eflore-projets

Rev

Rev 439 | Rev 522 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
370 mathilde 1
<?php
2
/** Exemple lancement:
3
 * /opt/lampp/bin/php -d memory_limit=3500M ~/web/eflore-projets/scripts/cli.php baseflor -a chargerTous
4
*/
5
class Baseflor extends EfloreScript {
433 jpm 6
 
370 mathilde 7
	private $table = null;
433 jpm 8
	private $fichierDonnees = '';
9
	private $log = '';
10
	private $nb_erreurs;
370 mathilde 11
	private $erreurs_ligne;
12
	private $ligne_num;
13
	private $colonne_valeur;
14
	private $colonne_num;
433 jpm 15
	private $type_bio = array();
16
	private $ss_type_bio = array();
17
	private $signes_seuls = array();// basés sur valeurs trouvées (--> pas de légende !)
18
	private $signes_nn_seuls = array();// basés sur valeurs trouvées (--> pas de légende !)
19
	private $intervalles = array();
20
	private $motifs = array();
370 mathilde 21
 
22
	public function executer() {
23
		try {
24
			$this->initialiserProjet('baseflor');
25
			$cmd = $this->getParametre('a');
433 jpm 26
			switch ($cmd) {
27
				case 'chargerStructureSql' :
28
					$this->chargerStructureSql();
370 mathilde 29
					break;
433 jpm 30
				case 'chargerMetadonnees':
31
					$this->chargerMetadonnees();
370 mathilde 32
					break;
433 jpm 33
				case 'chargerOntologies' :
34
					$this->chargerOntologies();
35
					break;
36
				case 'verifierDonnees' :
37
					$this->verifFichier();
38
					break;
39
				case 'chargerDonnees' :
40
					$this->chargerDonnees();
41
					break;
370 mathilde 42
				case 'genererChamps' :
433 jpm 43
					 $this->genererChamps();
370 mathilde 44
					 break;
433 jpm 45
				case 'chargerTous':
46
					$this->chargerStructureSql();
416 mathilde 47
					$this->chargerMetadonnees();
433 jpm 48
					$this->chargerOntologies();
49
					$this->chargerDonnees();
456 mathilde 50
					$this->genererChamps();
51
					$this->insererDonneesBaseflorRangSupEcolo();
416 mathilde 52
					break;
439 mathilde 53
				case 'insererDonneesRangSup' :
54
					$this->insererDonneesBaseflorRangSupEcolo();
55
					break;
433 jpm 56
				case 'supprimerTous' :
57
					$this->supprimerTous();
58
					break;
439 mathilde 59
				case 'voirRangSup' :
60
					$this->voirRangSup();
61
					break;
62
				case 'voirRangSupEcologie' :
63
					$this->voirRangSupEcologie();
64
					break;
370 mathilde 65
				default :
66
					throw new Exception("Erreur : la commande '$cmd' n'existe pas!");
67
			}
68
		} catch (Exception $e) {
69
			$this->traiterErreur($e->getMessage());
70
		}
433 jpm 71
	}
370 mathilde 72
 
439 mathilde 73
	//-- traitement de la table baseflorRangSupInsertion --//
74
 
75
	private function  getClasseBaseflorRangSupInsertion() {
76
		$conteneur = new Conteneur();
77
		require_once dirname(__FILE__)."/BaseflorRangSupInsertion.php";
78
		$rangSupInsert = new BaseflorRangSupInsertion($conteneur);///?
79
		return $rangSupInsert;
80
	}
81
 
82
 
83
	private function insererDonneesBaseflorRangSupEcolo(){
84
		$rangSupInsert = $this->getClasseBaseflorRangSupInsertion();
85
		$rangSupInsert->insererDonnees();
86
	}
87
 
88
	private function voirRangSup(){
89
		$rangSupInsert = $this->getClasseBaseflorRangSupInsertion();
90
		$rangSupInsert->testAscendantsDeBaseflor();
91
	}
92
 
93
	private function voirRangSupEcologie(){
94
		$rangSupInsert = $this->getClasseBaseflorRangSupInsertion();
95
		$rangSupInsert->testEcologieAscendantsDeBaseflor();
96
	}
97
 
98
 
99
	//-- traitement de la table generer champs --//
433 jpm 100
	private function genererChamps(){
101
		$this->initialiserGenerationChamps();
102
		$this->ajouterChamps();
103
		$this->analyserChampsExistant();
104
	}
370 mathilde 105
 
433 jpm 106
	private function initialiserGenerationChamps() {
107
		$this->table = Config::get('tables.donnees');
108
	}
370 mathilde 109
 
433 jpm 110
	private function ajouterChamps() {
111
		$this->preparerTablePrChpsBDNT();
112
		$this->preparerTablePrChpsNumTaxon();
113
		$this->preparerTablePrChpsNumNomen();
114
	}
115
 
116
	private function preparerTablePrChpsBDNT() {
117
		$requete = "SHOW COLUMNS FROM {$this->table} LIKE 'BDNT' ";
118
		$resultat = $this->getBdd()->recuperer($requete);
119
		if ($resultat === false) {
120
			$requete = 	"ALTER TABLE {$this->table} ".
121
					'ADD BDNT VARCHAR( 6 ) '.
122
					'CHARACTER SET utf8 COLLATE utf8_general_ci '.
123
					'NOT NULL AFTER catminat_code ';
124
			$this->getBdd()->requeter($requete);
125
		}
126
	}
127
 
128
	private function preparerTablePrChpsNumTaxon() {
129
		$requete = "SHOW COLUMNS FROM {$this->table} LIKE 'num_taxon' ";
130
		$resultat = $this->getBdd()->recuperer($requete);
131
		if ($resultat === false) {
132
			$requete = "ALTER TABLE {$this->table} ".
133
					'ADD num_taxon INT( 10 ) NOT NULL '.
134
					'AFTER catminat_code';
135
			$this->getBdd()->requeter($requete);
136
		}
137
	}
138
 
139
	private function preparerTablePrChpsNumNomen() {
140
		$requete = "SHOW COLUMNS FROM {$this->table} LIKE 'num_nomen' ";
141
		$resultat = $this->getBdd()->recuperer($requete);
142
		if ($resultat === false) {
143
			$requete = "ALTER TABLE {$this->table} ".
144
					'ADD num_nomen INT( 10 ) NOT NULL '.
145
					'AFTER catminat_code';
146
			$this->getBdd()->requeter($requete);
147
		}
148
	}
370 mathilde 149
 
433 jpm 150
	private function analyserChampsExistant() {
151
		$resultats = $this->recupererTuplesNumsOriginels();
152
		foreach ($resultats as $chps) {
153
			$cle = $chps['cle'];
154
			$nno = $chps['num_nomen_originel'];
155
			$nto = $chps['num_taxon_originel'];
370 mathilde 156
 
433 jpm 157
			$valeurs = array();
158
			$valeurs["BDNT"] = $this->genererChpsBDNT($nno, $nto);
159
			$valeurs["num_taxon"] = $this->genererChpsNumTaxon($nto);
160
			$valeurs["num_nomen"] = $this->genererChpsNumNomen($nno);
370 mathilde 161
 
433 jpm 162
			$this->remplirChamps($cle, $valeurs);
370 mathilde 163
 
433 jpm 164
			$this->afficherAvancement("Insertion des valeurs dans la base en cours");
165
		}
166
		echo "\n";
167
	}
168
 
169
	private function recupererTuplesNumsOriginels(){
170
		$requete = "SELECT cle, num_taxon_originel, num_nomen_originel FROM {$this->table} ";
171
		$resultat = $this->getBdd()->recupererTous($requete);
172
		return $resultat;
173
	}
174
 
175
	private function genererChpsBDNT($nno, $nto) {
176
		$bdnt = '';
177
		if (preg_match("/^([AB])[0-9]+$/", $nno, $retour) || preg_match("/^([AB])[0-9]+$/", $nto, $retour)){
178
			if ($retour[1]=='A') {
179
				$bdnt = "BDAFX";
180
			} else {
181
				$bdnt = "BDBFX";
182
			}
183
		} elseif (($nno == 'nc') && ($nto == 'nc')) {
184
			$bdnt = "nc";
185
		} else {
186
			$bdnt = "BDTFX";
187
		}
188
		return $bdnt;
189
	}
190
 
191
	private function genererChpsNumTaxon($nto){
192
		$num_taxon = '';
193
		if (preg_match("/^[AB]([0-9]+)$/", $nto, $retour)) {
194
			$num_taxon = intval($retour[1]);
195
		} elseif($nto == 'nc') {
196
			$num_taxon = 0;
197
		} else {
198
			$num_taxon = intval($nto);
199
		}
200
		return $num_taxon;
201
	}
202
 
203
	private function genererChpsNumNomen($nno) {
204
		$num_nomen = '';
205
		if (preg_match("/^[AB]([0-9]+)$/", $nno, $retour)) {
206
			$num_nomen = intval($retour[1]);
207
		} elseif ($nno == 'nc') {
208
			$num_nomen = 0;
209
		} else {
210
			$num_nomen = intval($nno);
211
		}
212
		return $num_nomen;
213
	}
214
 
215
	 private function remplirChamps($cle, $valeurs) {
216
		foreach ($valeurs as $nomChamp => $valeurChamp) {
217
			$valeurChamp = $this->getBdd()->proteger($valeurChamp);
218
			$requete = "UPDATE {$this->table} SET $nomChamp = $valeurChamp WHERE cle = $cle ";
219
			$resultat = $this->getBdd()->requeter($requete);
220
			if ($resultat === false) {
221
				throw new Exception("Erreur d'insertion pour le tuple clé = $cle");
222
			}
223
		}
224
	}
225
 
226
	//+------------------------------------------------------------------------------------------------------+
227
	// chargements, suppression, exécution
228
 
229
	protected function chargerMetadonnees() {
230
		$contenuSql = $this->recupererContenu(Config::get('chemins.metadonnees'));
231
		$this->executerScripSql($contenuSql);
232
	}
233
 
234
	private function chargerOntologies() {
235
		$chemin = Config::get('chemins.ontologies');
236
		$table = Config::get('tables.ontologies');
237
		$requete = "LOAD DATA INFILE '$chemin' ".
238
			"REPLACE INTO TABLE $table ".
239
			'CHARACTER SET utf8 '.
240
			'FIELDS '.
241
			"	TERMINATED BY '\t' ".
242
			"	ENCLOSED BY '' ".
243
			"	ESCAPED BY '\\\' "
244
			;
245
		$this->getBdd()->requeter($requete);
246
	}
247
 
248
	protected function chargerStructureSql() {
249
		$contenuSql = $this->recupererContenu(Config::get('chemins.structureSql'));
250
		$this->executerScripSql($contenuSql);
251
	}
252
 
253
	protected function executerScripSql($sql) {
254
		$requetes = Outils::extraireRequetes($sql);
255
		foreach ($requetes as $requete) {
256
			$this->getBdd()->requeter($requete);
257
		}
258
	}
259
 
260
	private function chargerDonnees() {
261
		$this->verifFichier();
262
		if ($this->nb_erreurs > 0) {
263
			$e = "Je ne peux pas charger les données car le fichier comporte des erreurs.".
264
					"Voir le fichier baseflor_verif.txt\n";
265
			throw new Exception($e);
266
		}
267
 
268
		$table = Config::get('tables.donnees');
269
		$requete = "LOAD DATA INFILE '".Config::get('chemins.donnees')."' ".
270
			"REPLACE INTO TABLE $table ".
271
			'CHARACTER SET utf8 '.
272
			'FIELDS '.
273
			"	TERMINATED BY '\t' ".
274
			"	ENCLOSED BY '' ".
275
			"	ESCAPED BY '\\\'";
276
		$this->getBdd()->requeter($requete);
277
	}
278
 
279
	private function supprimerTous() {
280
		$requete = "DROP TABLE IF EXISTS baseflor_meta, baseflor_ontologies, baseflor_v2012_03_19";
281
		$this->getBdd()->requeter($requete);
282
	}
283
 
284
	//+------------------------------------------------------------------------------------------------------+
285
	// vérifications de données
286
 
287
	//verifie la cohérence des valeurs des colonnes
288
	private function verifFichier(){
289
		$this->initialiserParametresVerif();
290
 
291
		$lignes = file($this->fichierDonnees, FILE_IGNORE_NEW_LINES);
292
		if ($lignes != false) {
293
			$this->ajouterAuLog("!!! REGARDEZ LES COLONNES DANS NUMERO_COLONNES_IMPORTANT.TXT.");
294
			foreach ($lignes as $this->ligne_num => $ligne) {
295
				$this->verifierErreursLigne($ligne);
296
				$this->afficherAvancement("Vérification des lignes");
297
			}
298
			echo "\n";
299
		} else {
300
			$this->traiterErreur("Le fichier {$this->fichierDonnees} ne peut pas être ouvert.");
301
		}
302
 
303
		if ($this->nb_erreurs == 0) {
304
			$this->ajouterAuLog("Il n'y a pas d'erreurs.");
305
		}
306
		$this->traiterInfo($this->nb_erreurs." erreurs");
307
 
308
		$this->ecrireFichierLog();
309
	}
310
 
311
	//vérifie par colonnes les erreurs d'une ligne
312
	private function verifierErreursLigne($ligne){
313
		$this->erreurs_ligne = array();
314
		$colonnes = explode("\t", $ligne);
315
		if (isset($colonnes)) {
316
			foreach ($colonnes as $this->colonne_num => $this->colonne_valeur) {
317
				if (( $this->colonne_num > 0 && $this->colonne_num < 15 )
318
						|| $this->colonne_num == 16
319
						|| ($this->colonne_num > 18 && $this->colonne_num < 23)
320
						|| $this->colonne_num > 39) {
321
					$this->verifierColonne();
322
				} elseif ($this->colonne_num == 15) {
323
					$this->verifierTypeBio();
324
				} elseif ($this->colonne_num >= 23 && $this->colonne_num <= 32) {
325
					$this->verifierIntervalles($this->colonne_valeur);
326
				} elseif ($this->colonne_num >= 33 && $this->colonne_num < 41) {
327
					$this->verifierValeursIndic();
328
				}
329
			}
330
		} else {
331
			$message = "Ligne {$this->ligne_num} : pas de tabulation";
332
			$this->ajouterAuLog($message);
333
		}
334
 
335
		$this->controlerErreursLigne();
336
	}
337
 
338
	private function verifierColonne(){
339
		$motif = $this->motifs[$this->colonne_num];
340
		if (preg_match($motif, $this->colonne_valeur) == 0 && $this->verifierSiVide() == false){
341
			$this->erreurs_ligne[$this->colonne_num] = $this->colonne_valeur;
342
		}
343
	}
344
 
345
	private function verifierSiVide(){
346
		$vide = ($this->colonne_valeur  == '') ? true : false;
347
		return $vide;
348
	}
349
 
350
	private function verifierTypeBio(){
351
		if (preg_match("/(.+)\((.+)\)$/", $this->colonne_valeur, $retour) == 1) {
352
			$this->verifierTypeEtSsType($retour[1]);
353
			$this->verifierTypeEtSsType($retour[2]);
354
		} else {
355
			$this->verifierTypeEtSsType($this->colonne_valeur);
356
		}
357
	}
358
 
359
	private function verifierTypeEtSsType($chaine_a_verif){
360
		if (preg_match("/^([a-zA-Zé]+)\-(.+)$|^([a-zA-Zé]+[^\-])$/", $chaine_a_verif, $retour) == 1) {
361
			$type = (isset($retour[3])) ? $retour[3] : $retour[1];
362
			$this->verifierType($type);
363
 
364
			$sousType = $retour[2];
365
			$this->verifierSousType($sousType);
366
		}
367
	}
368
 
369
	private function verifierType($type) {
370
		if (in_array($type, $this->type_bio) == false) {
371
			$this->erreurs_ligne[$this->colonne_num] = $this->colonne_valeur;
372
		}
373
	}
374
 
375
	private function verifierSousType($sousType) {
376
		if ($sousType != ''){
377
			$ss_type = explode('-', $sousType);
378
			foreach ($ss_type as $sst) {
379
				if (in_array($sst, $this->ss_type_bio) == false) {
380
					$this->erreurs_ligne[$this->colonne_num] = $this->colonne_valeur;
381
				}
382
			}
383
		}
384
	}
385
 
386
	private function verifierIntervalles($valeur){
387
		if ($valeur != '') {
388
			list($min, $max) = explode('-', $this->intervalles[$this->colonne_num]);
389
			if ($valeur < $min || $valeur > $max){
390
				$this->erreurs_ligne[$this->colonne_num] = $this->colonne_valeur;
391
			}
392
		}
393
	}
394
 
395
	private function verifierValeursIndic(){
396
		if (preg_match("/^([^0-9])*([0-9]+)([^0-9])*$/", $this->colonne_valeur, $retour) == 1){
397
			$this->verifierIntervalles($retour[2]);
398
			if (isset($retour[3]) && in_array($retour[3], $this->signes_nn_seuls) == false){
399
				$this->erreurs_ligne[$this->colonne_num] = $this->colonne_valeur;
400
			}
401
			if ($retour[1] != '-' && $retour[1] != ''){
402
				$this->erreurs_ligne[$this->colonne_num] = $this->colonne_valeur;
403
			}
404
		} elseif (in_array( $this->colonne_valeur, $this->signes_seuls) == false && $this->verifierSiVide() == false) {
405
			$this->erreurs_ligne[$this->colonne_num] = $this->colonne_valeur;
406
		}
407
	}
408
 
409
	private function controlerErreursLigne() {
410
		$nbreErreursLigne = count($this->erreurs_ligne);
411
		$this->nb_erreurs += $nbreErreursLigne;
412
		if ($nbreErreursLigne != 0) {
413
			$this->ajouterAuLog("Erreurs sur la ligne {$this->ligne_num}");
414
			$ligneLog = '';
415
			foreach ($this->erreurs_ligne as $cle => $v){
416
				$ligneLog .= "colonne $cle : $v - ";
417
			}
418
			$this->ajouterAuLog($ligneLog);
419
		}
420
	}
421
 
422
	//+------------------------------------------------------------------------------------------------------+
423
	// Chargement Paramètres
424
 
425
	private function initialiserParametresVerif() {
426
		$this->nb_erreurs = 0;
427
		$this->fichierDonnees = Config::get('chemins.donnees');
428
		$this->type_bio = $this->getParametreTableau('Parametres.typesBio');
429
		$this->ss_type_bio = $this->getParametreTableau('Parametres.sousTypesBio');
430
		$this->signes_seuls = $this->getParametreTableau('Parametres.signesSeuls');
431
		$this->signes_nn_seuls = $this->getParametreTableau('Parametres.signesNonSeuls');
432
		$this->intervalles = $this->inverserTableau($this->getParametreTableau('Parametres.intervalles'));
433
		$this->motifs = $this->inverserTableau($this->getParametreTableau('Parametres.motifs'));
439 mathilde 434
 
433 jpm 435
	}
436
 
437
	private function getParametreTableau($cle) {
438
		$tableau = array();
439
		$parametre = Config::get($cle);
440
		if (empty($parametre) === false) {
441
			$tableauPartiel = explode(',', $parametre);
442
			$tableauPartiel = array_map('trim', $tableauPartiel);
443
			foreach ($tableauPartiel as $champ) {
444
				if (strpos($champ, '=') !== false && strlen($champ) >= 3) {
445
					list($cle, $val) = explode('=', $champ);
446
					$tableau[trim($cle)] = trim($val);
447
				} else {
448
					$tableau[] = trim($champ);
449
				}
450
			}
451
		}
452
		return $tableau;
453
	}
454
 
455
	private function inverserTableau($tableau) {
456
		$inverse = array();
457
		foreach ($tableau as $cle => $valeurs) {
458
			$valeurs = explode(';', $valeurs);
459
			foreach ($valeurs as $valeur) {
460
				$inverse[$valeur] = $cle;
461
			}
462
		}
463
		return $inverse;
464
	}
465
 
466
	//+------------------------------------------------------------------------------------------------------+
467
	// Gestion du Log
468
 
469
	private function ajouterAuLog($txt) {
470
		$this->log .= "$txt\n";
471
	}
472
 
473
	private function ecrireFichierLog() {
474
		$fichierLog = dirname(__FILE__).'/log/verification.log';
475
		file_put_contents($fichierLog, $this->log);
476
	}
370 mathilde 477
}
478
?>