/branches/v5.9-aulnaie/services/modules/0.1/baseveg/precisions_sur_niveaux.txt |
---|
New file |
0,0 → 1,16 |
Précisions pour les ontologies : voir le fichier log dans le script de baseveg. |
niveaux existants : |
ORD,ALL,ASS,CLA,SUBCLA,SUBORD,SUBASS,SUBCLA,SUBALL,BC,DC,GRPT |
A ce jour je ne connais pas le sens de BC et DC. |
synonymes : |
"syn" suivi de un ou plusieurs des termes suivants : |
incl,=,= ?,illeg,pp,pmaxp,pminp,compl,ambig,non,inval,nn,ined |
on rencontre parfois des textes entre [ ] comme dans : " syn incl illeg [pro race hyperatlantique] ". |
catminat : certains codes comme 01/A6.0.1.0.1/01 comportent des lettres (probablement pour bdafx (algues)). |
ces cas ont été ignorés. |
Property changes: |
Added: svn:eol-style |
+native |
\ No newline at end of property |
/branches/v5.9-aulnaie/services/modules/0.1/baseveg/syntaxons/SyntaxonsRelationsToutes.php |
---|
New file |
0,0 → 1,89 |
<?php |
/** |
* |
* syntaxons/relations -> retourne toutes les relations d'un syntaxon en fonction du numéro catminat |
* |
* * @package eflore-projets |
* @author mathilde Salthun-Lassalle |
* @license GPL v3 <http://www.gnu.org/licenses/gpl.txt> |
* @license CECILL v2 <http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt> |
* @version 1.0 |
* @copyright 1999-2012 Tela Botanica (accueil@tela-botanica.org) |
* |
*/ |
class SyntaxonsRelationsToutes extends SyntaxonsCommun { |
public function consulter($ressources, $parametres) { |
$this->ressources = $ressources; |
$this->parametres = $parametres; |
$this->traiterParametres(); |
$resultats = null; |
$resultat = $this->retournerResultatRelations(); |
// puisque notre implémentation de retournerResultatFormate() n'utilise pas NULL |
// et que le prototype de Commun::traiterResultat() doit être respecté, nous passons |
// NULL comme second paramètre. |
$versionResultat = $this->traiterResultat($resultat, NULL); |
$resultats = $versionResultat; |
return $resultats; |
} |
// si je ne réinstancie pas la classe entre les appels à la méthode consulter, çà ne marche pas ! |
private function retournerResultatRelations () { |
$resultat_relation = array(); |
$classe = new SyntaxonsRelation(new Conteneur()); |
$ressources_syn = array_merge($this->ressources, array('synonymie') ); |
$synonymie = $classe->consulter($ressources_syn,$this->parametres); |
if ($synonymie != 'Les données recherchées sont introuvables') { |
$resultat_relation['synonymie'] = $synonymie['resultat']; |
} |
$ressources_niv = array_merge($this->ressources, array('niveaux-sup') ); |
$classe = new SyntaxonsRelation(new Conteneur()); |
$niveaux = $classe->consulter($ressources_niv,$this->parametres); |
if ($niveaux != 'Les données recherchées sont introuvables') { |
$resultat_relation['niveaux_superieurs'] = $niveaux['resultat']; |
} |
return $resultat_relation; |
} |
//+-------------------------------------traitement des ressources et des paramètres----------------------------------------+// |
public function traiterParametres() { |
if (isset($this->parametres) && !empty($this->parametres) ) { |
foreach ($this->parametres as $param => $valeur) { |
if ($param != 'version.projet' || $param != 'retour.champs' ) { |
$e = 'Erreur dans les parametres de votre requête : </br> Le paramètre " ' |
.$param.' " n\'existe pas.'; |
$this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $e); |
} |
} |
} |
} |
//+--------------------------formatages de resultats -------------------------------------------+ |
public function retournerResultatFormate($resultat) { |
$resultat_json = array(); |
$resultat_json['entete']['catminat'] = str_replace('-','/',$this->ressources[0]); |
$resultat_json['resultat'] = $resultat; |
return $resultat_json; |
} |
} |
?> |
/branches/v5.9-aulnaie/services/modules/0.1/baseveg/syntaxons/SyntaxonsCode.php |
---|
New file |
0,0 → 1,107 |
<?php |
/** |
* |
* /syntaxons?masque.catminat=#catminat&masque.niveau=#niveau etc.--> retourne les syntaxons répondant à ces critères |
* /syntaxons/cle:#cle --> retourne les informations de ce syntaxon ( peut être un synonyme ) |
* |
* Remarque : le code fixe n'est pas tout à fait unique puisque certaines valeurs (ex. 1489) |
* apparaissent 2 ou 3 fois avec des codes catminat ou des syntaxons sensiblement différents. |
* C'est pourquoi il n'est pas utilisé. |
* |
* |
* @package eflore-projets |
* @author mathilde Salthun-Lassalle |
* @license GPL v3 <http://www.gnu.org/licenses/gpl.txt> |
* @license CECILL v2 <http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt> |
* @version 1.0 |
* @copyright 1999-2012 Tela Botanica (accueil@tela-botanica.org) |
* |
*/ |
class SyntaxonsCode extends SyntaxonsCommun { |
public function consulter($ressources, $parametres) { |
$this->ressources = $ressources; |
$this->parametres = $parametres; |
$this->traiterRessources(); |
$this->traiterParametres(); |
$this->definirTables(); |
$resultats = null; |
$requete = ''; |
foreach ($this->table_version as $version) { |
$this->table = $version; |
$requete = $this->assemblerLaRequete(); |
$resultat = $this->Bdd->recupererTous($requete); |
$versionResultat = $this->traiterResultat($resultat, $version); |
if (count($this->table_version) > 1) { |
$resultats[$version] = $versionResultat; |
} else { |
$resultats = $versionResultat; |
} |
} |
return $resultats; |
} |
function __construct(Conteneur $conteneur) { |
parent::__construct($conteneur); |
} |
//+-------------------------------------traitement des ressources et des paramètres----------------------------------------+// |
public function traiterRessources() { |
$catminat=''; |
if(preg_match("/catminat:(([0-9]{2}\-$)|([0-9]{2}\-[0-9]\.$)|([0-9]{2}\-(?:[0-9]\.){1,5}[0-9]$)|([0-9]{2}\-(?:[0-9]\.){4,5}[0-9]\-[0-9]+(?:bis|ter|quater){0,1}$))/",$this->ressources[0], $retour)) { |
$this->catminat = str_replace('-', '/',$retour[1]); |
$this->requete_condition[] = ' code_catminat = \''.$this->catminat.'\' ' ; |
$this->requete_condition[] = ' niveau NOT LIKE \'syn%\' '; |
} elseif (preg_match("/cle:([0-9]+)/",$this->ressources[0], $retour)) { |
$this->champs_recherches = ' * '; |
$this->requete_condition[] = ' cle = '.$retour[1].' ' ; |
}elseif ($this->ressources[0]) { |
$e = 'Erreur dans l\'url de votre requête : </br> La ressource demandée n\'existe pas.'; |
throw new Exception($e, RestServeur::HTTP_CODE_MAUVAISE_REQUETE); |
} |
return $catminat; |
} |
public function traiterParametres() { |
if (isset($this->parametres) && !empty($this->parametres) ) { |
foreach ($this->parametres as $param => $valeur) { |
switch ($param) { |
case 'version.projet' : |
$this->traiterVersion($valeur); |
break; |
default : |
$e = 'Erreur dans les parametres de votre requête : </br> Le paramètre " ' |
.$param.' " n\'existe pas.'; |
$this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $e); break; |
} |
} |
} |
} |
//+--------------------------formatages de resultats -------------------------------------------+ |
public function retournerResultatFormate($resultat) { |
$resultat_json = array(); |
foreach ($resultat as $cle => $res) { |
$resultat[$cle] = array_merge($resultat[$cle],$this->traiterOntologieNiveau($res['niveau'])); |
unset($resultat[$cle]['niveau']); |
$resultat[$cle] = $this->enleverValeursVides($resultat[$cle]); |
} |
$resultat_json['resultat'] = $resultat; |
return $resultat_json; |
} |
} |
?> |
/branches/v5.9-aulnaie/services/modules/0.1/baseveg/syntaxons/SyntaxonsTous.php |
---|
New file |
0,0 → 1,152 |
<?php |
/** |
* |
* /syntaxons --> retourne l'ensemble des tuples de la table |
* /syntaxons?masque.catminat=#catminat&masque.niveau=#niveau etc.--> retourne les syntaxons répondant à ces critères |
* |
* * @package eflore-projets |
* @author mathilde Salthun-Lassalle |
* @license GPL v3 <http://www.gnu.org/licenses/gpl.txt> |
* @license CECILL v2 <http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt> |
* @version 1.0 |
* @copyright 1999-2012 Tela Botanica (accueil@tela-botanica.org) |
* |
*/ |
class SyntaxonsTous extends SyntaxonsCommun { |
function __construct(Conteneur $conteneur) { |
parent::__construct($conteneur); |
$this->champs_recherches = 'cle, code_catminat, syntaxon, code_fixe_nom, code_natura_2000, niveau '; |
} |
public function consulter($ressources, $parametres) { |
$this->ressources = $ressources; |
$this->parametres = $parametres; |
$this->traiterParametres(); |
$this->definirTables(); |
$resultats = null; |
foreach ($this->table_version as $version) { |
$this->table = $version; |
$requete = $this->assemblerLaRequete(); |
$resultat = $this->Bdd->recupererTous($requete); |
// puisque notre implémentation de retournerResultatFormate() n'utilise pas NULL |
// et que le prototype de Commun::traiterResultat() doit être respecté, nous passons |
// NULL comme second paramètre. |
$versionResultat = $this->traiterResultat($resultat, NULL); |
if (count($this->table_version) > 1) { |
$resultats[$version] = $versionResultat; |
} else { |
$resultats = $versionResultat; |
} |
} |
return $resultats; |
} |
//+-------------------------------------traitement des ressources et des paramètres----------------------------------------+// |
public function traiterParametres() { |
if (isset($this->parametres) && !empty($this->parametres) ) { |
foreach ($this->parametres as $param => $valeur) { |
switch ($param) { |
case 'navigation.depart' : |
$this->definirNavigationDepart($valeur); |
break; |
case 'navigation.limite' : |
$this->definirNavigationLimite($valeur); |
break; |
case 'version.projet' : |
$this->traiterVersion($valeur); |
break; |
case 'masque.catminat' : |
$this->traiterCatminat($valeur); |
break; |
case 'masque.niveau' : |
$this->traiterNiveau($valeur); |
break; |
case 'masque.retenu' : |
$this->traiterRetenu($valeur); |
break; |
case 'masque.fixe' : |
$this->requete_condition[] = ' code_fixe_nom = \''.$valeur.'\' '; |
break; |
case 'retour.champs' : |
$this->champs_recherches .= ','.$valeur.' '; |
break; |
default : |
$e = 'Erreur dans les parametres de votre requête : </br> Le paramètre " ' |
.$param.' " n\'existe pas.'; |
$this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $e); break; |
} |
} |
} |
} |
public function traiterRetenu($valeur) { |
$valeur = trim($valeur); |
if( $valeur == 'true') { |
$this->requete_condition[] = ' niveau NOT LIKE \'syn%\' '; |
} elseif ( $valeur == 'false') { |
$this->requete_condition[] = ' niveau LIKE \'syn%\' '; |
} |
} |
public function traiterCatminat($valeur) { |
$valeur = trim($valeur); |
$valeur = str_replace('-', '/', $valeur); |
$this->requete_condition[] = ' code_catminat = '.$this->getBdd()->proteger($valeur).''; |
} |
public function traiterNiveau($valeur) { |
$valeur = strtoupper(trim($valeur)); |
if (in_array($valeur,$this->niv)) { |
$this->requete_condition[] = ' niveau = '.$this->getBdd()->proteger($valeur).''; |
//$this->requete_condition[] = ' code_catminat = '.$this->catminat.''; |
} else { |
$e = "Erreur : valeur inconnue pour masque.niveau." |
." valeurs possibles : ALL|ORD|CLA|SUBCLA|SUBORD|SUBALL|ASS|SUBASS|BC|DC|GRPT"; |
throw new Exception($e, RestServeur::HTTP_CODE_MAUVAISE_REQUETE); |
} |
} |
//+--------------------------formatages de resultats -------------------------------------------+ |
public function retournerResultatFormate($resultat) { |
$resultat_json = array(); |
$resultat_json['entete'] = $this->ajouterEnteteResultat(); |
foreach ($resultat as $cle => $res) { |
$resultat[$cle]['href'] = $this->ajouterHref('syntaxons','cle:'.$res['cle']); |
$resultat[$cle] = array_merge($resultat[$cle],$this->traiterOntologieNiveau($res['niveau'])); |
unset($resultat[$cle]['niveau']); |
} |
$resultat_json['resultat'] = $resultat; |
return $resultat_json; |
} |
public function ajouterEnteteResultat() { |
$entete['depart'] = $this->limite_requete['depart']; |
$entete['limite'] = $this->limite_requete['limite']; |
$entete['total'] = $this->total_resultat; |
$entete['version'] = $this->version_projet; |
$ressources = (empty($this->ressources)) ? '/syntaxons' : '/syntaxons/' ; |
$url = $this->formulerUrl($this->total_resultat, $ressources.implode('/',$this->ressources)); |
if (isset($url['precedent']) && $url['precedent'] != '') { |
$entete['href.precedent'] = $url['precedent']; |
} |
if (isset($url['suivant']) && $url['suivant'] != '') { |
$entete['href.suivant'] = $url['suivant']; |
} |
return $entete; |
} |
} |
?> |
/branches/v5.9-aulnaie/services/modules/0.1/baseveg/syntaxons/SyntaxonsRelation.php |
---|
New file |
0,0 → 1,256 |
<?php |
/** |
* |
* syntaxons/relations -> retourne toutes les relations d'un syntaxon en fonction du numéro catminat |
* |
* /syntaxons/catminat:#code_catminat/relations/niveaux_sup --> retourne les niveaux supérieurs d'un syntaxon |
* /syntaxons/catminat:#code_catminat/relations/synonymie --> retourne tous les synonymes pour un code catminat |
* |
* @package eflore-projets |
* @author mathilde Salthun-Lassalle |
* @license GPL v3 <http://www.gnu.org/licenses/gpl.txt> |
* @license CECILL v2 <http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt> |
* @version 1.0 |
* @copyright 1999-2012 Tela Botanica (accueil@tela-botanica.org) |
* |
*/ |
class SyntaxonsRelation extends SyntaxonsCommun{ |
public function consulter($ressources, $parametres) { |
$this->ressources = $ressources; |
$this->parametres = $parametres; |
$this->traiterRessources(); |
$this->traiterParametres(); |
$this->definirTables(); |
$resultats = null; |
$requete = ''; |
foreach ($this->table_version as $version) { |
$this->table = $version; |
$requete = $this->assemblerLaRequete(); |
$resultat = $this->Bdd->recupererTous($requete); |
$versionResultat = $this->traiterResultat($resultat, $this->version_projet); |
if (count($this->table_version) > 1) { |
$resultats[$version] = $versionResultat; |
} else { |
$resultats = $versionResultat; |
} |
} |
return $resultats; |
} |
function __construct(Conteneur $conteneur) { |
parent::__construct($conteneur); |
$this->champs_recherches = 'cle, code_catminat, syntaxon, code_fixe_nom, code_natura_2000, niveau '; |
} |
//surchargée car le web-service est appelé par SyntaxonsRelationsToutes. |
//ne doit pas renvoyer une erreur mais un résultat vide. |
public function traiterResultat($resultat, $version) { |
$versionResultat = null; |
if ($resultat == '') { |
$message = 'La requête SQL formée comporte une erreur!'; |
$code = RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE; |
throw new Exception($message, $code); |
} elseif ($resultat) { |
$versionResultat = $this->retournerResultatFormate($resultat); |
} else { |
$versionResultat = 'Les données recherchées sont introuvables'; |
} |
return $versionResultat; |
} |
//+-------------------------------------traitement des ressources et des paramètres----------------------------------------+// |
public function traiterRessources() { |
$catminat=''; |
if(preg_match("/catminat:(([0-9]{2}\-$)|([0-9]{2}\-[0-9]\.$)|([0-9]{2}\-(?:[0-9]\.){1,5}[0-9]$)|([0-9]{2}\-(?:[0-9]\.){4,5}[0-9]\-[0-9]+(?:bis|ter|quater){0,1}$))/",$this->ressources[0], $retour)) { |
$this->catminat = str_replace('-', '/',$retour[1]); |
$this->traiterRessourcesRelations(); |
}elseif ($this->ressources[0]) { |
$e = 'Erreur dans l\'url de votre requête : </br> La ressource demandée n\'existe pas.'; |
throw new Exception($e, RestServeur::HTTP_CODE_MAUVAISE_REQUETE); |
} |
return $catminat; |
} |
public function traiterRessourcesRelations(){ |
if($this->ressources[1] == 'relations') { |
switch($this->ressources[2]) { |
case 'niveaux-sup': |
$catminat_sup = $this->chercherCatminatSuperieurs(); |
if (!empty($catminat_sup)) { |
if (count($catminat_sup)>1) { |
$this->requete_condition[] = ' code_catminat in ('.implode(',',$catminat_sup).')'; |
} else { |
$this->requete_condition[] = ' code_catminat = '.$catminat_sup[0].' '; |
} |
} else { |
$e = 'Erreur dans l\'url de votre requête : le code catminat est trop court.'; |
throw new Exception($e, RestServeur::HTTP_CODE_MAUVAISE_REQUETE); |
} |
break; |
case 'synonymie' : |
$this->requete_condition[] = " niveau LIKE 'syn%' and code_catminat = '".$this->catminat."' " ; |
break; |
default : |
$e = 'Erreur dans l\'url de votre requête : </br> La ressource demandée n\'existe pas.'; |
throw new Exception($e, RestServeur::HTTP_CODE_MAUVAISE_REQUETE); |
} |
} else { |
$e = 'Erreur dans l\'url de votre requête : </br> La ressource demandée n\'existe pas.'; |
throw new Exception($e, RestServeur::HTTP_CODE_MAUVAISE_REQUETE); |
} |
} |
//ne renvoie que les supérieurs ( sans la valeur initiale ) |
public function chercherCatminatSuperieurs() { |
$catminat_sup = array(); |
$catminat_slash = explode('/',$this->catminat); |
$catminat_slash = $this->enleverValeursVides($catminat_slash); |
$taille_slash = count($catminat_slash); |
if ($taille_slash > 1) { |
$catminat_sup[0] = "'".array_shift($catminat_slash)."/'"; |
$niveaux = array_shift($catminat_slash); |
$unites = explode('.',trim($niveaux)); //attention explode peut renvoyer des cases vides (voir la doc php) |
$unites = $this->enleverValeursVides($unites); |
$taille = ($taille_slash == 3) ? count($unites) : count($unites)-1 ; |
for ($i=0; $i< $taille ; $i++) { |
$sup = "'".trim($catminat_sup[$i],"'"); |
if ($i == 0) { |
$sup .= $unites[$i].".'"; |
} elseif ($i == 1) { |
$sup .= $unites[$i]."'"; |
} else { |
$sup .= ".".$unites[$i]."'"; |
} |
$catminat_sup[] = $sup; |
} |
} |
return $catminat_sup; |
} |
public function traiterParametres() { |
if (isset($this->parametres) && !empty($this->parametres) ) { |
foreach ($this->parametres as $param => $valeur) { |
switch ($param) { |
case 'navigation.depart' : |
$this->definirNavigationDepart($valeur); |
break; |
case 'navigation.limite' : |
$this->definirNavigationLimite($valeur); |
break; |
case 'version.projet' : |
$this->traiterVersion($valeur); |
break; |
case 'masque.catminat' : |
$this->traiterCatminat($valeur); |
break; |
case 'masque.niveau' : |
$this->traiterNiveau($valeur); |
break; |
case 'masque.fixe': |
$this->requete_condition[] = ' code_fixe_nom = \''.$valeur.'\' '; |
break; |
case 'retour.champs' : |
$this->champs_recherches .= ','.$valeur.' '; |
break; |
case 'masque.retenu' : |
$this->traiterRetenu($valeur); |
break; |
default : |
$e = 'Erreur dans les parametres de votre requête : </br> Le paramètre " ' |
.$param.' " n\'existe pas.'; |
$this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $e); break; |
} |
} |
} |
} |
public function traiterRetenu($valeur) { |
if ($this->ressources[2] == 'niveaux-sup') { |
$valeur = trim($valeur); |
if( $valeur == 'true') { |
$this->requete_condition[] = ' niveau NOT LIKE \'syn%\' '; |
} elseif ( $valeur == 'false') { |
$this->requete_condition[] = ' niveau LIKE \'syn%\' '; |
} |
} else { |
$e = 'Erreur dans les parametres de votre requête : </br> Le paramètre " masque.retenu " n\'existe pas.'; |
$this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $e); |
} |
} |
public function traiterCatminat($valeur) { |
if ($this->ressources[2] == 'niveaux-sup') { |
$valeur = trim($valeur); |
$valeur = str_replace('-', '/', $valeur); |
$this->requete_condition[] = ' code_catminat = '.$this->getBdd()->proteger($valeur).''; |
} else { |
$e = 'Erreur dans les parametres de votre requête : </br> Le paramètre " masque.catminat " n\'existe pas.'; |
$this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $e); break; |
} |
} |
public function traiterNiveau($valeur) { |
if ($this->ressources[2] == 'niveaux-sup') { |
$valeur = strtoupper(trim($valeur)); |
if (in_array($valeur,$this->niv)) { |
$this->requete_condition[] = ' niveau = '.$this->getBdd()->proteger($valeur).''; |
} else { |
$e = "Erreur : valeur inconnue pour masque.niveau." |
." valeurs possibles : ALL|ORD|CLA|SUBCLA|SUBORD|SUBALL|ASS|SUBASS|BC|DC|GRPT"; |
throw new Exception($e, RestServeur::HTTP_CODE_MAUVAISE_REQUETE); |
} |
} else { |
$e = 'Erreur dans les parametres de votre requête : </br> Le paramètre " masque.niveau " n\'existe pas.'; |
$this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $e); |
} |
} |
//+--------------------------formatages de resultats -------------------------------------------+// |
public function retournerResultatFormate($resultat) { |
$resultat_json = array(); |
$resultat_json['entete'] = $this->ajouterEnteteResultat(); |
foreach ($resultat as $cle => $res) { |
$resultat[$cle]['href'] = $this->ajouterHref('syntaxons','cle:'.$res['cle']); |
$resultat[$cle] = array_merge($resultat[$cle],$this->traiterOntologieNiveau($res['niveau'])); |
unset($resultat[$cle]['niveau']); |
} |
$resultat_json['resultat'] = $resultat; |
return $resultat_json; |
} |
public function ajouterEnteteResultat() { |
$entete['depart'] = $this->limite_requete['depart']; |
$entete['limite'] = $this->limite_requete['limite']; |
$entete['total'] = $this->total_resultat; |
$entete['version'] = $this->version_projet; |
$ressources = (empty($this->ressources)) ? '/syntaxons' : '/syntaxons/' ; |
$url = $this->formulerUrl($this->total_resultat, $ressources.implode('/',$this->ressources)); |
if (isset($url['precedent']) && $url['precedent'] != '') { |
$entete['href.precedent'] = $url['precedent']; |
} |
if (isset($url['suivant']) && $url['suivant'] != '') { |
$entete['href.suivant'] = $url['suivant']; |
} |
return $entete; |
} |
} |
?> |
/branches/v5.9-aulnaie/services/modules/0.1/baseveg/syntaxons/SyntaxonsCommun.php |
---|
New file |
0,0 → 1,195 |
<?php |
/** |
* |
* fonctions et paramètres communs aux traitement des syntaxons |
* - traitement de l'ontologie |
* - fonction utiles pour les paramètres de configuration entre autres |
* - traitement des tables et de leur version |
* - traitement de la requête |
* |
* @package eflore-projets |
* @author mathilde Salthun-Lassalle |
* @license GPL v3 <http://www.gnu.org/licenses/gpl.txt> |
* @license CECILL v2 <http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt> |
* @version 1.0 |
* @copyright 1999-2012 Tela Botanica (accueil@tela-botanica.org) |
*/ |
require_once(dirname(__FILE__) . '/../../baseflor/Informations.php'); |
class SyntaxonsCommun extends Commun { |
protected $table = ""; |
protected $format_reponse = 'syntaxons'; |
protected $serviceNom = 'syntaxons'; |
protected $Bdd; |
protected $syn; |
protected $niv; |
protected $limite_requete = array('depart' => 0, 'limite' => 100); |
protected $requete_condition = array(); |
protected $total_resultat; |
protected $champs_recherches = ' * '; |
protected $table_version; |
protected $version_projet = '+' ; |
static $cache = array(); |
public function __construct(Conteneur $conteneur) { |
$this->Bdd = $conteneur->getBdd(); |
$this->syn = $this->getParametreTableauSpe('Paramètres.synonymes'); |
$this->niv = $this->getParametreTableauSpe('Paramètres.niveaux'); |
} |
//+---------------------------------------------------outils------------------------------------------------// |
protected function getParametreTableauSpe($cle) { |
$tableau = array(); |
$parametre = Config::get($cle); |
if (empty($parametre) === false) { |
$tableauPartiel = explode(',', $parametre); |
$tableauPartiel = array_map('trim', $tableauPartiel); |
foreach ($tableauPartiel as $champ) { |
$tableau[] = trim($champ,"'");// spécificité pour le = ? des synonymes |
} |
} |
return $tableau; |
} |
//la fonction php array_filters ne marche pas sur le serveur |
protected function enleverValeursVides($tableau) { |
$tab = array(); |
foreach ($tableau as $cle => $valeur) { |
if ($valeur != '' && is_int($cle)) { |
$tab[] = $valeur; |
} elseif ($valeur != '' && is_string($cle)) { |
$tab[$cle] = $valeur; |
} |
} |
return $tab; |
} |
//+++------------------------------traitement des versions----------------------------------------++ |
protected function traiterVersion($valeur) { |
if (preg_match('/^[0-9]+(?:[._][0-9]+)*$/', $valeur) || $valeur == '+' || $valeur == '*') { |
$this->version_projet = $valeur; |
} else { |
$e = "Erreur : La version est inconnue."; |
throw new Exception($e, RestServeur::HTTP_CODE_MAUVAISE_REQUETE); |
} |
} |
protected function definirTables() { |
$table_num_version = $this->recupererVersionDisponible(); |
$prefixe_table = config::get('bdd_table'); |
if ( in_array($this->version_projet,$table_num_version) ) { |
$this->table_version[] = $prefixe_table.'_v'.$this->version_projet; |
} elseif ($this->version_projet == '+') { |
$derniere_version = $table_num_version[count($table_num_version) - 1]; |
$this->table_version[] = $prefixe_table.'_v'.str_replace('.', '_', $derniere_version); |
} elseif ($this->version_projet == '*') { |
foreach ($table_num_version as $num_version) { |
$this->table_version[] = $prefixe_table.'_v'.str_replace('.', '_', $num_version); |
} |
} else { |
$e = "Erreur : La version est inconnue."; |
throw new Exception($e, RestServeur::HTTP_CODE_MAUVAISE_REQUETE); |
} |
} |
//+------------------------------------ontologies----------------------------------------------------+ |
protected function recupererOntologiesNiveau($valeur, $code){ |
$ontologie = array(); |
$url = Config::get('url_service_base').Config::get('nom_projet'). |
'/ontologies/'.$code.':'.urlencode(urlencode($valeur)); |
if(array_key_exists($url, self::$cache)) { |
$val = self::$cache[$url]; |
} else { |
$val = $this->consulterHref($url); |
self::$cache[$url] = $val; |
} |
$ontologie['niveau.code'] = $valeur; |
$ontologie['niveau.libelle'] = $val->nom; |
$ontologie['niveau.href'] = $url; |
return $ontologie; |
} |
protected function recupererOntologiesNiveauSyn($niveau){ |
$ontologie = array(); |
$synonymes = explode(' ',$niveau[1]); |
$libelle = array(); |
$detail = array(); |
foreach ($synonymes as $syn) { |
if ($syn == '=') { |
$syn = 'equi'; |
} elseif ($syn == '= ?') { |
$syn = 'prob'; |
} |
if ($syn != '' && $syn != '?') { |
$detail[] = $this->recupererOntologiesNiveau($syn, 'syn'); |
$dernier = end($detail); |
$libelle[] = $dernier['niveau.libelle'].' '; |
} |
} |
$ontologie['niveau.code'] = $niveau[0]; |
$ontologie['niveau.libelle'] = 'synonyme '.implode(' - ',$libelle); |
if (isset($niveau[2])) { |
$ontologie['niveau.libelle'] .= ' '.$niveau[2]; |
} |
$ontologie['niveau.detail'] = $detail; |
return $ontologie; |
} |
protected function traiterOntologieNiveau($niveau) { |
$ontologie = array(); |
if ( preg_match('/syn {0,1}(['.implode($this->syn).']*)( *\[.+\])*/',$niveau,$retour)) { |
$ontologie = $this->recupererOntologiesNiveauSyn($retour); |
} else { |
$ontologie = $this->recupererOntologiesNiveau($niveau, 'UP'); |
} |
return $ontologie; |
} |
//+--------------------------FONCTIONS D'ASSEMBLAGE DE LA REQUETE-------------------------------------------+ |
protected function assemblerLaRequete() { |
$requete = ' SELECT '.$this->champs_recherches.' FROM '.$this->table.' ' |
.Informations::retournerRequeteCondition($this->requete_condition).' '.$this->delimiterResultatsRequete(); |
return $requete; |
} |
protected function delimiterResultatsRequete() { |
$this->total_resultat = Informations::calculerTotalResultat( |
$this->getBdd(), |
$this->table, |
Array(), |
$this->requete_condition); |
$requete_limite = ''; |
if (($this->limite_requete['depart'] <= $this->total_resultat) ){ |
if (($this->limite_requete['limite'] + $this->limite_requete['depart'] ) |
< $this->total_resultat ){ |
$requete_limite = 'LIMIT '.$this->limite_requete['depart'].', ' |
.$this->limite_requete['limite']; |
} |
} else { |
$e = "Erreur : la valeur pour le paramètre navigation.départ est supérieure". |
" au nombre total de résultats."; |
throw new Exception($e, RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE); |
} |
return $requete_limite; |
} |
} |
?> |
/branches/v5.9-aulnaie/services/modules/0.1/baseveg/Ontologies.php |
---|
New file |
0,0 → 1,345 |
<?php |
/** |
Classe Ontologies.php fournit des informations sur ensemble structuré des termes et concepts représentant les éléments |
* d'un domaine de connaissances pour le projet baseveg. |
*/ |
class BasevegOntologies extends Commun { |
protected $requete_condition = null; |
/** Permet de stocker la requete formulée: /ontologies | /ontologies/#id | /ontologies/#id/champ | /ontologies/#id/relations */ |
protected $format_reponse = 'ontologies'; |
/** Permet de stocker les limite de la requete SQL (par défaut seul les 100 premiers résultats seront retournés). |
* Stocke également les valeurs des paramètres navigation.depart et navigation.limite passés dans la requete*/ |
protected $limite_requete = array( 'depart' => 0, 'limite' => 100); |
/** Stocke le nombre total de résultats de la requete principale. Est calculée lors de l'assemblage de la requete */ |
protected $total_resultat; |
protected $retour_format = 'max'; |
public function consulter($ressources, $parametres) { |
$this->ressources = $ressources; |
$this->parametres = $parametres; |
$this->service = 'ontologies'; |
$this->traiterParametres(); |
$resultats = ''; |
$this->table = 'baseveg_ontologies'; |
$this->recupererNomChamp($this->table); |
$this->traiterRessources(); |
$requete = $this->assemblerLaRequete(); |
$resultat = $this->getBdd()->recupererTous($requete); |
$versionResultat = $this->traiterResultat($resultat, ''); |
$resultats = $versionResultat; |
return $resultats; |
} |
public function traiterParametres() { |
if (isset($this->parametres) && !empty($this->parametres)) { |
foreach ($this->parametres as $param => $valeur) { |
switch ($param) { |
case 'masque' : $this->ajouterLeFiltreMasque('masque', $valeur); break; |
case 'masque.code' : $this->ajouterLeFiltreMasque('code', $valeur); break; |
case 'masque.nom' : $this->ajouterLeFiltreMasque('nom', $valeur); break; |
case 'masque.description' : $this->ajouterLeFiltreMasque('description', $valeur); break; |
case 'retour.format' : $this->retour_format = $valeur; break; |
case 'navigation.depart' : $this->limite_requete['depart'] = $valeur; break; |
case 'navigation.limite' : $this->limite_requete['limite'] = $valeur; break; |
default : |
$e = 'Erreur dans les parametres de recherche de votre requête : </br> Le paramètre " ' |
.$param.' " n\'existe pas.'; |
$this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $e); break; |
} |
} |
} |
} |
public function ajouterLeFiltreMasque($nom_champ, $valeur) { |
if ($nom_champ == 'code') { |
$this->requete_condition[] = $nom_champ.' = '.$this->getBdd()->proteger($valeur); |
} else { |
if (isset($this->parametres['recherche']) && $this->parametres['recherche'] == 'floue') { |
if ($nom_champ == 'masque') { |
$this->requete_condition[] = '( code = '.$this->getBdd()->proteger($valeur) |
.' OR ( SOUNDEX(nom) = SOUNDEX(\''.$valeur.'\')' |
.' OR SOUNDEX(REVERSE(nom)) = SOUNDEX(REVERSE(\''.$valeur.'\')) ' |
.') OR ( SOUNDEX(description) = SOUNDEX(\''.$valeur.'\')' |
.' OR SOUNDEX(REVERSE(description)) = SOUNDEX(REVERSE(\''.$valeur.'\')) ))'; |
} else { |
$this->requete_condition[] = '(SOUNDEX('.$nom_champ.') = SOUNDEX(\''.$valeur.'\')' |
.' OR SOUNDEX(REVERSE('.$nom_champ.')) = SOUNDEX(REVERSE(\''.$valeur.'\')))'; |
} |
} else { |
if (isset($this->parametres['recherche']) && $this->parametres['recherche'] == 'etendue') { |
$valeur = str_replace(' ','%', $valeur); |
$valeur .= '%'; |
} |
if ($nom_champ == 'masque') { |
$this->requete_condition[] = '(code = '.$this->getBdd()->proteger($valeur) |
.' OR nom LIKE '.$this->getBdd()->proteger($valeur) |
.' OR description LIKE '.$this->getBdd()->proteger($valeur).')'; |
} else { |
$this->requete_condition[] = $nom_champ.' LIKE '.$this->getBdd()->proteger($valeur); |
} |
} |
} |
} |
public function traiterRessources() { |
if (isset($this->ressources) && !empty($this->ressources)) { |
if (isset($this->ressources[0]) && !empty($this->ressources[0])) { |
//requete = /ontologies/#id |
$this->traiterRessourceId(); |
if (isset($this->ressources[1]) && !empty($this->ressources[1])) { |
//requete = /ontologies/#id/relations |
$this->traiterRessourceRelations(); |
} |
} |
} |
} |
public function traiterRessourceId() { |
$this->requete_condition = array(); |
//requete : /ontologies/#id (ex : /ontologies/7) |
if (is_numeric($this->ressources[0])) { |
$this->requete_condition[] = ' id = '.$this->getBdd()->proteger($this->ressources[0]); |
$this->format_reponse .= '/id'; |
//requete : /ontologies/#classe:#code (ex : /ontologies/rangTaxo:290) |
} elseif (strrpos($this->ressources[0], ':') !== false) { |
$this->format_reponse .= '/id'; |
preg_match('/^([^:]+):([^:]+)$/', $this->ressources[0], $match); |
$this->requete_condition[] = |
' id = (SELECT id FROM '.$this->table.' WHERE code = BINARY '.$this->getBdd()->proteger($match[2]) |
.' AND classe_id = (SELECT id FROM '.$this->table.' WHERE code = BINARY '.$this->getBdd()->proteger($match[1]).'))'; |
} else { |
$e = 'Erreur dans les paramètres de recherche de votre requête : </br> Le paramètre " ' |
.$this->ressources[0].' " n\'existe pas.'; |
$this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $e); |
} |
} |
public function traiterRessourceRelations() { |
//requete = /ontologies/#id/relations : |
if ($this->ressources[1] == 'relations') { |
$this->format_reponse .= '/relations'; |
$this->requete_condition = array('classe_id = (SELECT classe_id FROM '.$this->table.' WHERE ' |
.implode(' AND ', $this->requete_condition).')'); |
} |
} |
//+--------------------------FONCTION ASSEMBLAGE DE LA REQUETE-------------------------------------------+ |
public function assemblerLaRequete() { |
$requete = ' SELECT '.$this->formerRequeteChamp(). |
' FROM '.$this->table |
.$this->retournerRequeteCondition() |
.$this->formerRequeteLimite(); //print_r($requete); |
return $requete; |
} |
public function formerRequeteChamp() { |
$champ[] = 'id'; |
if ($this->format_reponse == 'ontologies') { |
$champ[] = 'nom, code '; |
} |
if (isset($this->parametres['retour_champs']) || $this->format_reponse == 'ontologies/id/champs') { |
$champs_recherches = explode(',', $this->parametres['retour_champs']); |
$champs_possibles = $this->rechercherChampsPossibles(); |
foreach ($champs_recherches as $champ_recherche) { |
if ($this->verifierValiditeChamp($champ_recherche)) { |
$champ[] = (preg_match('/classe/', $champ_recherche)) ? 'classe_id' : $champ_recherche; |
} |
} |
} |
if (count($champ) == 1) { |
$champ = array(' * '); |
} |
return implode(', ', $champ); |
} |
public function rechercherChampsPossibles() { |
$this->recupererNomChamp($this->table); |
$champs_possibles = $this->champs_table; |
$champs_possibles[] = 'classe.id'; |
$champs_possibles[] = 'classe'; |
$champs_possibles[] = 'classe.href'; |
return $champs_possibles; |
} |
public function verifierValiditeChamp($champ, $champs_possibles) { |
$validite = false; |
preg_match('/^([^.]+)(:?\.([^.]+))?$/', $champ, $match); |
if (in_array($match[1], $champs_possibles)) { |
$validite = true; |
} else { |
$champs = implode('</li><li>', $champs_possibles); |
$e = 'Erreur dans votre requête : </br> Le champ "'.$champ |
.'" n\'existe pas. Les champs disponibles sont : <li>'.$champs.'</li>'; |
$this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $e); |
} |
return $validite; |
} |
public function retournerRequeteCondition() { |
$condition = ''; |
if ($this->requete_condition !== null) { |
$condition = ' WHERE '.implode(' AND ', $this->requete_condition); |
} |
return $condition; |
} |
public function formerRequeteLimite() { |
$this->total_resultat = $this->recupererTotalResultat(); |
if (in_array($this->format_reponse , array('textes/id', 'textes/id/relations'))) { |
$this->requete_limite = ''; |
} elseif (($depart = $this->limite_requete['depart']) > ($this->total_resultat)) { |
$this->limite_requete['depart'] = |
(($this->total_resultat - $this->limite_requete['limite']) < 0) ? 0 : ($this->total_resultat - $this->limite_requete['limite']); |
$this->requete_limite = ' LIMIT '.$this->limite_requete['depart'].', '.$this->limite_requete['limite']; |
} else { |
$this->requete_limite = ' LIMIT '.$this->limite_requete['depart'].', '.$this->limite_requete['limite']; |
} |
return $this->requete_limite; |
} |
public function recupererTotalResultat() { |
//on récupère le nombre total de résultats de la requete (ex : le nombre d'id contenu dans la liste /ontologies) |
$requete = 'SELECT count(*) as nombre FROM '.$this->table.' ' |
.$this->retournerRequeteCondition(); |
$res = $this->getBdd()->recuperer($requete); |
if ($res) { |
$total = $res['nombre']; |
} else { |
$e = 'Données introuvables dans la base'; |
$this->renvoyerErreur(RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE, $e); |
Debug::printr($requete); |
} |
return $total; |
} |
//+------------------------------------------------------------------------------------------------------+ |
public function retournerResultatFormate($resultat) { |
// determine en fct du service appelé (/ontologies | /ontologies/#id | /ontologies/#id/champ | |
// /ontologies/#id/relations) le format du tableau à retourner. Encode en json |
switch ($this->format_reponse) { |
case 'ontologies' : $reponse = $this->formaterOntologies($resultat); break; |
case 'ontologies/id' : $reponse = $this->formaterOntologiesId($resultat[0]); break; |
case 'ontologies/id/relations' : $reponse = $this->formaterOntologiesIdRelations($resultat); break; |
default : break; |
} |
return $reponse; |
} |
public function formaterOntologies($resultat) { |
$this->ajouterEnteteResultat($resultat); |
$table_retour_json['entete'] = $this->ajouterEnteteResultat($resultat); |
if (isset($this->parametres['masque_code']) || isset($this->parametres['masque'])) { |
$resultat = $this->trierRechercheFloue($this->parametres['masque_code'], $resultat, 'code'); |
} elseif (isset($this->parametres['masque_nom'])) { |
$resultat = $this->trierRechercheFloue($this->parametres['masque_nom'], $resultat, 'nom'); |
} elseif (isset($this->parametres['masque_description'])) { |
$resultat = $this->trierRechercheFloue($this->parametres['masque_description'], $resultat, 'description'); |
} |
//on remplit la table $table_retour_json['resultat'] |
foreach ($resultat as $tab) { |
$num = $tab['id']; |
unset($tab['id']); |
foreach ($tab as $param => $valeur) { |
$resultat_json[$num][$param] = $valeur; |
} |
if ($this->retour_format == 'max') $resultat_json[$num]['href'] = $this->ajouterHref('ontologies', $num); |
} |
$table_retour_json['resultat'] = $resultat_json; |
return $table_retour_json; |
} |
public function ajouterEnteteResultat($resultat) { |
//on remplit la table $table_retour_json['entete'] |
$entete['depart'] = $this->limite_requete['depart']; |
$entete['limite'] = $this->limite_requete['limite']; |
$entete['total'] = $this->total_resultat; |
//formuler les urls |
$url = $this->formulerUrl($this->total_resultat, '/ontologies'); |
if (isset($url['precedent']) && $url['precedent'] != '') { $entete['href.precedent'] = $url['precedent']; } |
if (isset($url['suivant']) && $url['suivant'] != '') { $entete['href.suivant'] = $url['suivant']; } |
return $entete; |
} |
public function formaterOntologiesId($resultat) { |
$table_retour = array(); |
foreach ($resultat as $key => $valeur) { |
if ($valeur != '') { |
$table_retour = array_merge($table_retour, $this->afficherDonnees($key, $valeur)); |
} |
} |
return $table_retour; |
} |
public function afficherDonnees($champ, $valeur) { |
$retour[$champ] = $valeur; |
if ($this->retour_format == 'max') { |
if ($champ == 'classe_id') { |
unset($retour[$champ]); // remplacer par classe.id |
if ($valeur != "0") { // pas de parent |
if (isset($this->parametres['retour_champs'])) { |
switch ($this->parametres['retour_champs']) { |
case 'classe' : $retour['classe'] = $this->ajouterClasseCorrespondante($valeur); break; |
case 'classe.id' : $retour['classe.id'] = $valeur; break; |
case 'classe.href' : $retour['classe.href'] = $this->ajouterHref('ontologies', $valeur); break; |
case 'classe.*' : $retour['classe.id'] = $valeur; $retour['classe.href'] = $this->ajouterHref('ontologies', $valeur); break; |
} |
} else { |
$nom_classe = $this->ajouterClasseCorrespondante($valeur); |
if (isset($nom_classe)) $retour['classe'] = $nom_classe; |
$retour['classe.id'] = $valeur; |
$retour['classe.href'] = $this->ajouterHref('ontologies', $valeur); |
} |
} |
} |
} |
return $retour; |
} |
/** Recherche par interrogation de la base, le nom de la classe à partir de son identifiant (classe.id) */ |
public function ajouterClasseCorrespondante($classe_id) { |
if ($classe_id == 0) return NULL; |
$nom = ''; |
$req = 'SELECT nom FROM '.$this->table.' WHERE id = '.$this->getBdd()->proteger($classe_id); |
$res = $this->getBdd()->recuperer($req . ' -- ' . __FILE__ . ':' . __LINE__); |
if ($res) { |
$nom = $res['nom']; |
} else { |
$e = "Données introuvables dans la table $this->table"; |
$this->renvoyerErreur(RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE, $e); |
Debug::printr($req); |
} |
return $nom; |
} |
public function formaterOntologiesIdRelations($resultat) { |
$retour = null; |
if ($resultat != '') { |
$retour['entete'] = $this->ajouterEnteteResultat($resultat); |
//on remplit la table $table_retour_json['resultat'] |
foreach ($resultat as $tab) { |
$num = $tab['id']; |
$retour['resultat'][$num]['nom'] = $tab['nom']; |
if ($this->retour_format == 'max') { |
$retour['resultat'][$num]['href'] = $this->ajouterHref('ontologies', $num); |
} |
} |
} |
return $retour; |
} |
} |
?> |
/branches/v5.9-aulnaie/services/modules/0.1/baseveg/Syntaxons.php |
---|
New file |
0,0 → 1,85 |
<?php |
/** |
* Classe Syntaxons.php permet de faire des requetes de baseveg autour du code CATMINAT ou des niveaux de syntaxons |
* Un syntaxon est une unité de végétation ( groupement ) |
* Cette classe analyse les ressources pour rediriger vers la classe du web service correpondant |
* |
* @see http://www.tela-botanica.org/wikini/eflore/wakka.php?wiki=EfloreApi01Syntaxons |
* |
* Encodage en entrée : utf8 |
* Encodage en sortie : utf8 |
* @package eflore-projets |
* @author Mathilde SALTHUN-LASSALLE <mathilde@tela-botanica.org> |
* @author Jean-Pascal MILCENT <jpm@tela-botanica.org> |
* @license GPL v3 <http://www.gnu.org/licenses/gpl.txt> |
* @license CECILL v2 <http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt> |
* @version 1.0 |
* @copyright 1999-2012 Tela Botanica (accueil@tela-botanica.org) |
*/ |
class Syntaxons extends Commun {// héritage de commun à cause du cache ! |
private $sousService; |
public function consulter($ressources, $parametres) { |
spl_autoload_register(array($this, 'chargerSyntaxons')); |
$this->parametres = $parametres; |
$this->ressources = $ressources; |
$this->analyserRessources(); |
$resultat = $this->executerSousService(); |
return $resultat; |
} |
private function analyserRessources() { |
$nb_ressources = count($this->ressources); |
switch ($nb_ressources) { |
case 0 : // syntaxons/ |
$this->sousService = 'SyntaxonsTous'; |
break; |
case 1 : // syntaxons/#type_code:#code |
$this->sousService = 'SyntaxonsCode'; |
break; |
case 2 : // syntaxons/code catminat/relations |
$this->sousService = 'SyntaxonsRelationsToutes'; |
break; |
case 3 : // syntaxons/code catminat/relations /#type_relation |
$this->sousService = 'SyntaxonsRelation'; |
break; |
default: |
$message = 'Erreur dans l\'url de votre requête : </br> La ressource demandée n\'existe pas.'; |
$code = RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE; |
throw new Exception($message, $code); |
break; |
} |
} |
private function executerSousService() { |
if (isset($this->sousService)) { |
$classe = $this->sousService; |
//require_once dirname(__FILE__).DS.'syntaxons'.DS.$classe.'.php'; |
$sousService = new $classe(new Conteneur()); |
$resultat = $sousService->consulter($this->ressources, $this->parametres); |
} else { |
$message = "L'analyse des ressources n'a pu aboutir à déterminer le sous service à executer."; |
$code = RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE; |
throw new Exception($message, $code); |
} |
return $resultat; |
} |
private function chargerSyntaxons($classe) { |
$base = dirname(__FILE__).DS; |
$chemin = $base.DS.'syntaxons'.DS; |
$fichierATester = $chemin.$classe.'.php'; |
if (file_exists($fichierATester)) { |
include_once $fichierATester; |
return null; |
} |
} |
} |
?> |