Subversion Repositories eFlore/Projets.eflore-projets

Compare Revisions

Ignore whitespace Rev 602 → Rev 603

/trunk/scripts/modules/baseflor/Baseflor.php
5,20 → 5,8
class Baseflor extends EfloreScript {
 
private $table = null;
private $fichierDonnees = '';
private $log = '';
private $nb_erreurs;
private $erreurs_ligne;
private $ligne_num;
private $colonne_valeur;
private $colonne_num;
private $type_bio = array();
private $ss_type_bio = array();
private $signes_seuls = array();// basés sur valeurs trouvées (--> pas de légende !)
private $signes_nn_seuls = array();// basés sur valeurs trouvées (--> pas de légende !)
private $intervalles = array();
private $motifs = array();
 
public function executer() {
try {
$this->initialiserProjet('baseflor');
33,8 → 21,8
case 'chargerOntologies' :
$this->chargerOntologies();
break;
case 'verifierDonnees' :
$this->verifFichier();
case 'verifierFichier' :
$this->verifierFichier();
break;
case 'chargerDonnees' :
$this->chargerDonnees();
248,7 → 236,7
 
protected function chargerMetadonnees() {
$contenuSql = $this->recupererContenu(Config::get('chemins.metadonnees'));
$this->executerScripSql($contenuSql);
$this->executerScriptSql($contenuSql);
}
 
private function chargerOntologies() {
267,10 → 255,10
 
protected function chargerStructureSql() {
$contenuSql = $this->recupererContenu(Config::get('chemins.structureSql'));
$this->executerScripSql($contenuSql);
$this->executerScriptSql($contenuSql);
}
 
protected function executerScripSql($sql) {
protected function executerScriptSql($sql) {
$requetes = Outils::extraireRequetes($sql);
foreach ($requetes as $requete) {
$this->getBdd()->requeter($requete);
278,8 → 266,8
}
 
private function chargerDonnees() {
$this->verifFichier();
if ($this->nb_erreurs > 0) {
$nb_err = $this->verifierFichier();
if ($nb_err > 0) {
$e = "Je ne peux pas charger les données car le fichier comporte des erreurs.".
"Voir le fichier baseflor_verif.txt\n";
throw new Exception($e);
297,202 → 285,25
}
 
private function supprimerTous() {
$requete = "DROP TABLE IF EXISTS baseflor_meta, baseflor_ontologies, baseflor_v2012_03_19,".
" baseflor_rang_sup_ecologie_v2012_03_19, baseflor_index_v2012_03_19 ";
$requete = "DROP TABLE IF EXISTS baseflor_meta, baseflor_ontologies, baseflor_v2012_05_08,".
" baseflor_rang_sup_ecologie_v2012_05_08, baseflor_index_v2012_05_08 ";
$this->getBdd()->requeter($requete);
}
 
//+------------------------------------------------------------------------------------------------------+
// vérifications de données
//++------------------------------------verifierFichier------------------------------------------++//
 
//verifie la cohérence des valeurs des colonnes
private function verifFichier(){
$this->initialiserParametresVerif();
$lignes = file($this->fichierDonnees, FILE_IGNORE_NEW_LINES);
if ($lignes != false) {
$this->ajouterAuLog("!!! REGARDEZ LES COLONNES DANS NUMERO_COLONNES_IMPORTANT.TXT.");
foreach ($lignes as $this->ligne_num => $ligne) {
$this->verifierErreursLigne($ligne);
$this->afficherAvancement("Vérification des lignes");
}
echo "\n";
} else {
$this->traiterErreur("Le fichier {$this->fichierDonnees} ne peut pas être ouvert.");
}
 
if ($this->nb_erreurs == 0) {
$this->ajouterAuLog("Il n'y a pas d'erreurs.");
}
$this->traiterInfo($this->nb_erreurs." erreurs");
 
$this->ecrireFichierLog();
private function getClasseBaseflorVerif() {
$conteneur = new Conteneur();
require_once dirname(__FILE__)."/BaseflorVerif.php";
$verif = new BaseflorVerif($conteneur,'baseflor');
return $verif;
}
 
//vérifie par colonnes les erreurs d'une ligne
private function verifierErreursLigne($ligne){
$this->erreurs_ligne = array();
$colonnes = explode("\t", $ligne);
if (isset($colonnes)) {
foreach ($colonnes as $this->colonne_num => $this->colonne_valeur) {
if (( $this->colonne_num > 0 && $this->colonne_num < 15 )
|| $this->colonne_num == 16
|| ($this->colonne_num > 18 && $this->colonne_num < 23)
|| $this->colonne_num > 39) {
$this->verifierColonne();
} elseif ($this->colonne_num == 15) {
$this->verifierTypeBio();
} elseif ($this->colonne_num >= 23 && $this->colonne_num <= 32) {
$this->verifierIntervalles($this->colonne_valeur);
} elseif ($this->colonne_num >= 33 && $this->colonne_num < 41) {
$this->verifierValeursIndic();
}
}
} else {
$message = "Ligne {$this->ligne_num} : pas de tabulation";
$this->ajouterAuLog($message);
}
 
$this->controlerErreursLigne();
private function verifierFichier() {
$verif = $this->getClasseBaseflorVerif();
$nb_erreurs = $verif->verifierFichier(Config::get('chemins.donnees'));
return $nb_erreurs;
}
 
private function verifierColonne(){
$motif = $this->motifs[$this->colonne_num];
if (preg_match($motif, $this->colonne_valeur) == 0 && $this->verifierSiVide() == false){
$this->erreurs_ligne[$this->colonne_num] = $this->colonne_valeur;
}
}
 
private function verifierSiVide(){
$vide = ($this->colonne_valeur == '') ? true : false;
return $vide;
}
 
private function verifierTypeBio(){
if (preg_match("/(.+)\((.+)\)$/", $this->colonne_valeur, $retour) == 1) {
$this->verifierTypeEtSsType($retour[1]);
$this->verifierTypeEtSsType($retour[2]);
} else {
$this->verifierTypeEtSsType($this->colonne_valeur);
}
}
 
private function verifierTypeEtSsType($chaine_a_verif){
if (preg_match("/^([a-zA-Zé]+)\-(.+)$|^([a-zA-Zé]+[^\-])$/", $chaine_a_verif, $retour) == 1) {
$type = (isset($retour[3])) ? $retour[3] : $retour[1];
$this->verifierType($type);
 
$sousType = $retour[2];
$this->verifierSousType($sousType);
}
}
 
private function verifierType($type) {
if (in_array($type, $this->type_bio) == false) {
$this->erreurs_ligne[$this->colonne_num] = $this->colonne_valeur;
}
}
 
private function verifierSousType($sousType) {
if ($sousType != ''){
$ss_type = explode('-', $sousType);
foreach ($ss_type as $sst) {
if (in_array($sst, $this->ss_type_bio) == false) {
$this->erreurs_ligne[$this->colonne_num] = $this->colonne_valeur;
}
}
}
}
 
private function verifierIntervalles($valeur){
if ($valeur != '') {
list($min, $max) = explode('-', $this->intervalles[$this->colonne_num]);
if ($valeur < $min || $valeur > $max){
$this->erreurs_ligne[$this->colonne_num] = $this->colonne_valeur;
}
}
}
 
private function verifierValeursIndic(){
if (preg_match("/^([^0-9])*([0-9]+)([^0-9])*$/", $this->colonne_valeur, $retour) == 1){
$this->verifierIntervalles($retour[2]);
if (isset($retour[3]) && in_array($retour[3], $this->signes_nn_seuls) == false){
$this->erreurs_ligne[$this->colonne_num] = $this->colonne_valeur;
}
if ($retour[1] != '-' && $retour[1] != ''){
$this->erreurs_ligne[$this->colonne_num] = $this->colonne_valeur;
}
} elseif (in_array( $this->colonne_valeur, $this->signes_seuls) == false && $this->verifierSiVide() == false) {
$this->erreurs_ligne[$this->colonne_num] = $this->colonne_valeur;
}
}
 
private function controlerErreursLigne() {
$nbreErreursLigne = count($this->erreurs_ligne);
$this->nb_erreurs += $nbreErreursLigne;
if ($nbreErreursLigne != 0) {
$this->ajouterAuLog("Erreurs sur la ligne {$this->ligne_num}");
$ligneLog = '';
foreach ($this->erreurs_ligne as $cle => $v){
$ligneLog .= "colonne $cle : $v - ";
}
$this->ajouterAuLog($ligneLog);
}
}
 
//+------------------------------------------------------------------------------------------------------+
// Chargement Paramètres
 
private function initialiserParametresVerif() {
$this->nb_erreurs = 0;
$this->fichierDonnees = Config::get('chemins.donnees');
$this->type_bio = $this->getParametreTableau('Parametres.typesBio');
$this->ss_type_bio = $this->getParametreTableau('Parametres.sousTypesBio');
$this->signes_seuls = $this->getParametreTableau('Parametres.signesSeuls');
$this->signes_nn_seuls = $this->getParametreTableau('Parametres.signesNonSeuls');
$this->intervalles = $this->inverserTableau($this->getParametreTableau('Parametres.intervalles'));
$this->motifs = $this->inverserTableau($this->getParametreTableau('Parametres.motifs'));
}
 
private function getParametreTableau($cle) {
$tableau = array();
$parametre = Config::get($cle);
if (empty($parametre) === false) {
$tableauPartiel = explode(',', $parametre);
$tableauPartiel = array_map('trim', $tableauPartiel);
foreach ($tableauPartiel as $champ) {
if (strpos($champ, '=') !== false && strlen($champ) >= 3) {
list($cle, $val) = explode('=', $champ);
$tableau[trim($cle)] = trim($val);
} else {
$tableau[] = trim($champ);
}
}
}
return $tableau;
}
 
private function inverserTableau($tableau) {
$inverse = array();
foreach ($tableau as $cle => $valeurs) {
$valeurs = explode(';', $valeurs);
foreach ($valeurs as $valeur) {
$inverse[$valeur] = $cle;
}
}
return $inverse;
}
 
//+------------------------------------------------------------------------------------------------------+
// Gestion du Log
 
private function ajouterAuLog($txt) {
$this->log .= "$txt\n";
}
 
private function ecrireFichierLog() {
$fichierLog = dirname(__FILE__).'/log/verification.log';
file_put_contents($fichierLog, $this->log);
}
}
?>