New file |
0,0 → 1,785 |
<?php |
|
abstract class CommunNomsTaxons extends Commun { |
|
protected $table_param = array(); /** Permet de stocker le tableau des parametres (= $parametres) */ |
protected $table_ressources = array(); /** Permet de stocker le tableau des ressources (= $ressources) */ |
protected $table_retour; /** Permet de stocker le tableau de résultat (non encodé en json)*/ |
protected $resultat_req; /** Permet de stocker le résultat de la requete principale. */ |
/** Permet de stocker sous forme de tableau les composant du nom à ajouter au nom scientifique (fonction du paramètre ns.structure) */ |
protected $compo_nom; |
protected $ordre_masque = array('masque', 'masque_sg', 'masque_gen', 'masque_sp', 'masque_ssp', 'masque_au', |
'masque_an', 'masque_bib', 'masque_ad', 'masque_nn', 'masque_rg' ); |
protected $tab_nom_sci = array('nom_supra_generique', 'genre', 'epithete_infra_generique', 'epithete_sp', |
'type_epithete', 'epithete_infra_sp', 'cultivar_groupe', 'cultivar', 'nom_commercial'); |
protected $retour_format = 'max'; |
protected $html = 'txt'; /** Valeur du paramètre de requete ns.format */ |
protected $table_version; /** Stocke les noms des tables de toutes les versions du projet disponibles */ |
/** Nom de la table dans laquelle on récupèrera les données (remplace Config::get('bdd_table') dans les requetes SQL */ |
protected $table; |
protected $total_resultat = null; |
/** Stocke le service appelé correspondant. Est utilisé principalement lors de l'affichage du href d'un synonyme |
(ex id=12, basionyme num 25 est un synonyme) dans le service taxon */ |
protected $service_href = null; |
|
|
//----------------------------------Fonctions d'analyse des ressources-------------------------------------------------- |
|
/** Permet de remplir la variable version_projet et de retirer cette donnée du tableau des ressources */ |
public function traiterVersionProjet(&$ressources) { |
if (isset($ressources) && !empty($ressources)) { |
if (preg_match('/(?:[0-9]+(?:_|[.])[0-9]+|[*])/', $ressources[0])) { |
$this->version_projet = array_shift($ressources); |
$this->version_projet = str_replace('_', '.', $this->version_projet); |
} else { |
if ($ressources[0] == ' ') array_shift($ressources); //si un + a été ajouté |
$this->version_projet = '+'; |
} |
} |
//si la liste des noms est demandée pr toutes les versions, on affiche seulement la dernière version pour : |
// - la liste des noms et taxons: /noms et /taxons |
// - la liste des taxons inferieurs/supérieur : /taxons/relations/inferieurs et /taxons/relations/superieurs |
// - la liste des relations : /taxons/relations ou /noms/relations |
if ($this->version_projet == '*' && ($ressources == array() |
|| (isset($ressources[1]) && $ressources[1] == 'relations' && isset($ressources[2]) && in_array($ressources[2], array('superieurs', 'inferieurs'))) |
|| (isset($ressources[1]) && $ressources[1] == 'relations' && !isset($ressources[2])) )) { |
$this->version_projet = '+'; |
} |
//on recupère les versions du projet disponible dans la table des meta-donnees (utilisation service MetaDonnees) |
$table_num_version = $this->recupererVersionDisponible(); |
//on recupere la liste des noms des tables de la bdd correspondant aux differentes versions du projet en fct de la ou les versions demandées |
$this->recupererListeNomTablePrChaqueVersion($table_num_version); |
} |
|
|
public function traiterRessources($ressources) { |
$this->table_ressources = $ressources; |
if (isset($ressources) && !empty($ressources)) { |
if ($this->estUnIdentifiant()) { //l'identifiant peut etre de type /#id ou /nt:#id |
$this->traiterRessourcesIdentifiant(); // dans le service noms ou taxons |
} elseif ($this->table_ressources[0] == 'stats') { //ressource = noms/stats |
$this->traiterRessourcesStats(); |
} else { |
$this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, |
'Erreur dans votre requete </br> Ressources disponibles : <br/> |
<li> /'.$this->service.'/#id (id : L\'identifiant du nom rechercher)</li> |
<li> /'.$this->service.'/nt:#id (id : Numero du taxon recherche)</li> |
<li> /'.$this->service.'/stats </li>' ); |
} |
} |
} |
|
|
public function traiterRessourcesStats() { |
$this->format_reponse = $this->service.'/stats'; |
if (isset($this->table_ressources[1]) && !empty($this->table_ressources[1])) { |
switch ($this->table_ressources[1]) { |
case 'annees' : |
$this->traiterRessourceStatsAnnees(); |
break; |
case 'rangs' : |
$this->traiterRessourceStatsRangs(); |
break; |
case 'initiales' : |
$this->traiterRessourceStatsInitiales(); |
break; |
default : |
$this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, |
'Erreur dans votre requete </br> Ressources disponibles : <br/> |
<li> /'.$this->service.'/stats/annees </li> |
<li> /'.$this->service.'/stats/rangs </li> |
<li> /'.$this->service.'/stats/initiales </li>' ); |
break; |
} |
} else { |
$this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, |
'Erreur dans votre requete </br> Ressources disponibles : <br/> |
<li> /'.$this->service.'/stats/annees </li> |
<li> /'.$this->service.'/stats/rangs </li> |
<li> /'.$this->service.'/stats/initiales </li>' ); |
} |
} |
|
|
/** Vérifie si la première valeur de la table de ressource est un identifiant : un numerique ou un numéro |
* taxonomique sous la forme nt:xx */ |
public function estUnIdentifiant() { |
return (is_numeric($this->table_ressources[0]) || (strrpos($this->table_ressources[0],'nt:') !== false |
&& is_numeric(str_replace('nt:','',$this->table_ressources[0])))); |
} |
|
//---------------------------------------------Fonction d'analyse des parametres---------------------------------------- |
|
/** Permet de remplir le tableau compo_nom. Il comprendra en fct du paramètre ns.structure les éléments à rajouter |
* au nom_sci (annee, auteur, biblio ou addendum).*/ |
public function remplirTableCompositionNom($valeur) { |
$structure_nom = explode(",",$valeur); |
foreach ($structure_nom as $structure) { |
switch ($structure) { |
case 'au' : $this->compo_nom['au'] = 'auteur'; break; |
case 'an' : $this->compo_nom['an'] = 'annee'; break; |
case 'bib' : $this->compo_nom['bib'] = 'biblio_origine'; break; |
case 'ad' : $this->compo_nom['ad'] = 'nom_addendum'; break; |
default : $this->renvoyerErreur( RestServeur::HTTP_CODE_MAUVAISE_REQUETE, |
'Erreur : Le parametre "'.$structure.'" n\'existe pas. <br/><br/> |
Les parametres du nom possibles sont : <li> au (auteur)</li><li> an (annee)</li> |
<li> bib (bibliographie)</li><li> ad (nom_addendum)</li>'); |
break; |
} |
} |
} |
|
|
/** Permet de recupérer le nom scientigfique au format html. Le champ nom_sci de la requete sql est remplacé par |
* le champ nom_sci_html */ |
public function mettreAuFormat() { |
if ($this->html == 'htm') { |
if (strrpos($this->requete_champ, 'nom_sci_html as nom_sci') === false) { |
$this->requete_champ = str_replace('nom_sci', 'nom_sci_html as nom_sci', $this->requete_champ); |
} |
} elseif ($this->html != 'txt') { |
$this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, |
'Erreur dans votre requete </br> ns.format = htm ou txt (par defaut)' ); |
} |
} |
|
//--------------------------------fonctions de formatage---------------------------------------------------------- |
|
/** Fonction permettant de creer la table dont le nom est passé en paramètre (champs_api, champs_bdtfx, |
* correspondance_champs...). Les données de chaque table sont présentes dans le fichier de configuration config.ini |
* @param String $table : Peut contenir plusieurs nom de table dont on souhaite récupérer les données : table,table,table. |
* Ex : recupererTableSignification('champs_api,champs_bdtfx') */ |
public function recupererTableSignification($table) { |
$tables = explode(',', $table); |
foreach ($tables as $tab) { |
if ($tab == 'champs_comp') { |
$champ_bdnff_api = array_keys($this->champs_api); //on recupère le nom des champ ds la bdd |
$this->champs_comp = array_diff($this->champs_table, $champ_bdnff_api); |
} elseif ($tab == 'champs_api') { |
foreach ($this->correspondance_champs as $key => $val) { |
preg_match('/(hybride[.]parent_0[12](?:[.]notes)?|nom_sci[.][^.]+|[^.]+)(?:[.](id|code))?/', $val, $match); |
$val = $match[1]; |
$this->champs_api[$key] = $val; |
} |
} else { |
$tableau = explode(',', Config::get($tab)); |
$tableau = array_map('trim', $tableau); |
foreach ($tableau as $champ) { |
list($code, $rang) = explode('=', $champ); |
$tab_tampon[$code] = $rang; |
} |
$this->$tab = $tab_tampon; |
$tab_tampon = array(); |
} |
} |
} |
|
|
public function formaterEnOss($resultat) { |
$res = array(); |
$table_nom = array(); |
foreach ($resultat as $version => $res_version) { |
$oss = ''; |
foreach ($res_version as $tab) { |
|
if (isset($tab['nom_sci']) ) { |
if (!in_array($tab['nom_sci'], $table_nom)) { |
$table_nom[] = $tab['nom_sci']; |
$oss [] = $tab['nom_sci'].$this->ajouterCompositionNom($tab); |
} |
} |
} |
$masque = $this->ordonnerMasque(); |
if ($masque == '') $masque = 'Pas de masque'; |
$table_retour_oss = array($masque, $oss); |
//Si les infos de plrs versions sont renvoyés, on ajoute au tableau de resultat le numéro de la version |
$res = $this->afficherVersionOuPas($version, $table_retour_oss, $res); |
} |
return $res; |
} |
|
|
/** Permet de récupérer le masque de rang superieur parmi les parametres de la requete. |
* Sera affiche dans l'entete du fichier json (clé 'masque') et oss. |
* @return string le masque de rang supérieur ou '' si aucun masque n'a été mis en parametre de |
* requete (la clé masque ne sera alors pas affichée dans l'entete).*/ |
public function ordonnerMasque() { |
$masque = ''; |
foreach ($this->ordre_masque as $key => $filtre) { |
if (isset($this->table_param[$filtre])) { |
$masque .= '&'.$filtre.'='.$this->table_param[$filtre]; |
} |
} |
$masque = ltrim($masque, '&'); //on enlève le & du début |
$masque = str_replace('masque_','',$masque); |
return $masque; |
} |
|
|
/** Affiche l'entete du résultat pour le service /noms et /noms/relations. L'entete comprend le rang (s'il est un |
* filtre), le départ, la limite, le total des résultats et les urls suivante et precedente. */ |
public function afficherEnteteRangBorneTotalUrls($resultat, $url_service) { |
if (isset($this->table_param['masque_rg'])) $this->afficherDonnees('rang', $this->table_param['masque_rg']); |
$this->table_retour['depart'] = $this->limite_requete['depart']; |
$this->table_retour['limite'] = $this->limite_requete['limite']; |
$this->table_retour['total'] = $this->total_resultat; |
//formuler les urls precedentes et suivantes |
$url = $this->formulerUrl($this->total_resultat, $url_service); |
if ($url['precedent'] != '') { $this->table_retour['href.precedent'] = $url['precedent']; } |
if ($url['suivant'] != '') { $this->table_retour['href.suivant'] = $url['suivant']; } |
} |
|
//----------------------------Fonction de formatage pour les services /#id/--------------------------------------------- |
/** Ajout du numero de la version au tableau de résultat à retourner : |
* 'bdtfx_v2_00' : {'infos' : 'toto' ...}, 'bdtfx_v3_00' : {'infos' : 'tata' ...} |
* @param string $num_version : numéro de version (sous la forme de l'intitulé du nom de la table bdd) |
* @param array $tab : tableau contenant le resultat à retourner pour une version donnée |
* @param array $res : tableau contenant le resultat à retourner pour toutes les versions disponibles */ |
public function afficherVersionOuPas($version, &$tab, &$res) { |
if (count($this->table_version) > 1) { |
$res[$version] = $tab; |
$tab = array(); |
} else { |
$res = $tab; |
} |
return $res; |
} |
|
|
public function formaterId($resultat) { |
$this->recupererTableSignification('correspondance_champs,champs_api,champs_comp'); |
$res = array(); |
foreach ($resultat as $version => $res_version) { |
$res_version = $res_version[0]; |
$this->resultat_req = $res_version; |
foreach ($res_version as $key => $valeur) { |
if ($valeur != '') { |
$this->afficherDonnees($key, $valeur); |
} |
} |
unset($this->table_retour['href']); |
//Si les infos de plrs versions sont renvoyés, on ajoute au tableau de resultat le numéro de la version |
$res = $this->afficherVersionOuPas($version, $this->table_retour, $res); |
} |
return $res; |
} |
|
|
public function formaterIdChamp($resultat) { |
$this->recupererTableSignification('correspondance_champs,champs_api,champs_comp'); |
$res = array(); |
foreach ($resultat as $version => $res_version) { |
$res_version = $res_version[0]; |
$this->resultat_req = $res_version; |
$this->table_retour['id'] = $res_version['num_nom']; |
//on récupère les champs (le + est transformé en espace par le navigateur) |
$tab_ress = explode(' ', $this->table_ressources[1]); |
foreach ($tab_ress as $nom_champ_api) { |
if ($this->verifierValiditeChamp($nom_champ_api)) { |
switch ($nom_champ_api) { |
case 'nom_sci' : $this->afficherNomSci($res_version); break; |
case 'nom_sci.*' : $this->afficherNomSciPointEpithete($res_version); break; |
case 'hybride.*' : |
$this->afficherChamps('hybride.parent_01.*', $res_version['hybride_parent_01']); |
$this->afficherChamps('hybride.parent_02.*', $res_version['hybride_parent_02']); break; |
default : |
$this->afficherChamps($nom_champ_api, |
$res_version[$this->trouverChampBddCorrespondant($nom_champ_api)]); break; |
} |
} |
} |
//Si les infos de plrs versions sont renvoyés, on ajoute au tableau de resultat le numéro de la version |
$res = $this->afficherVersionOuPas($version, $this->table_retour, $res); |
} |
return $res; |
} |
|
/** Les champs passés dans l'url lors de la requete /noms|taxons/#id/#champ+#champ son sous la forme de l'api. |
* Les noms de l'api ne st pas les meme que ceux des champs de la base de données. |
* Cette fct permet de récupérer le nom du champs de la base de données */ |
public function trouverChampBddCorrespondant($champ) { |
$radical_champ = $champ; |
if ($this->estUnPoint($champ) && strrpos($champ, '.notes') === false) { |
preg_match('/^(?:([^.]+\.parent_0[12]|[^.]+))(?:\.(.+))?$/', $champ, $match); |
$radical_champ = $match[1]; |
} |
// - Soit un champ de l'api est recherché (pour les champs du référentiel : les noms des champs ont été modifiés), |
// - Soit un champ complementaire de la bdnff (les noms de ces champs complementaire sont les memes que ds la base) |
if ($this->estChampApi($radical_champ)) { |
$champ_bdd = array_search($radical_champ, $this->champs_api); |
} elseif ($this->estDansBdnff($radical_champ)) { |
$champ_bdd = $radical_champ; |
} else { |
$this->renvoyerErreur( RestServeur::HTTP_CODE_MAUVAISE_REQUETE, |
'Fct trouverChampBddCorrespondant : Le parametre "'.$radical_champ.'" n\'existe pas. <br/><br/>'); |
} |
return $champ_bdd; |
} |
|
|
/** Permet d'afficher des informations précisées des données liées. Utilisé par le service id/champ |
* lors de l'appel d'un champ tel que : champ.id, champ.code, champ.*, champ.href. */ |
public function afficherChamps($champ, $valeur) { |
$reponse = $this->table_retour; |
$this->table_retour = array(); |
if ($valeur == '') { |
$this->table_retour[$champ] = null; |
} else { |
preg_match('/^(?:([^.]+\.parent_0[12]|[^.]+))(?:\.(.+))?$/', $champ, $match); |
//si on a un point etoile |
if (isset($match[2]) && $match[2] == '*') { |
$this->afficherPointEtoile($match[1], $valeur); |
//si le champ comprend plusieurs identifiants : pour le champ proparte (liste ou .details recherché, pas de .href) |
} elseif ($this->presentePlusieursId($match[1], $valeur)) { |
if (isset($match[2]) && $match[2] != 'id') { |
$this->afficherInfosPrecises($match[1], $match[2], $valeur); |
} else { |
$this->table_retour[str_replace('.id', '', $champ)] = $valeur; |
} |
//si on est en présence d'une donnée liée (la donnée représente un identifiant ou un code) |
} elseif ($this->correspondAUnId($match[1]) || $champ == 'id' || $this->correspondAUnCode($match[1])) { |
if (isset($match[2])) { //si un .id, un .code ou un .href est demandé : |
$this->afficherInfosPrecises($match[1], $match[2], $valeur); |
} else { |
$this->afficherInfosPrecises($match[1], 'signification', $valeur); |
} |
//sinon on affiche tel quel |
} else { |
$this->table_retour[$champ] = $valeur; |
} |
} |
$this->table_retour = array_merge($reponse, $this->table_retour); |
} |
|
|
/**Vérifie la validité d'un champ passé dans la requete /#id/#champ+#champ */ |
public function verifierValiditeChamp($champ) { |
preg_match('/^(?:([^.]+\.parent_0[12]|[^.]+))(?:\.(.+))?$/', $champ, $match); |
$radical_champ = $match[1]; |
$validite_ressource = true; |
//on verifie si le nom du champ existe bien |
if (!$this->estChampApi($radical_champ) && !$this->estDansBdnff($radical_champ)) { |
$validite_ressource = false; |
$this->renvoyerErreur( RestServeur::HTTP_CODE_MAUVAISE_REQUETE, |
'Fct verifierValiditeChamp : Le parametre "'.$radical_champ.'" n\'existe pas. <br/><br/>'); |
} elseif ($this->estUnPoint($champ)) { |
$suffixe = $match[2]; |
//On verifie les suffixes pour les identifiants |
if ($this->correspondAUnId($radical_champ) || $radical_champ == 'id') { |
$this->verificationSuffixesIdentifiant($suffixe, $radical_champ, $validite_ressource); |
//On verifie les suffixes pour les codes |
} elseif ($this->correspondAUnCode($radical_champ)) { |
$this->verficationSuffixesCodes($suffixe, $radical_champ, $validite_ressource); |
} elseif ($radical_champ == 'nom_sci' && $suffixe != '*') { |
$this->renvoyerErreur( RestServeur::HTTP_CODE_MAUVAISE_REQUETE, |
'Erreur : Le suffixe demandé n\'existe pas pour le champ "'.$radical_champ.'".<br/> |
Les suffixes possibles sont les suivants : <li> * </li>'); |
} else { |
$validite_ressource = false; |
$this->renvoyerErreur( RestServeur::HTTP_CODE_MAUVAISE_REQUETE, |
'Erreur : Le parametre "'.$radical_champ.'" ne peut pas présenter de suffixe. <br/><br/>'); |
} |
} |
return $validite_ressource; |
} |
|
|
public function verficationSuffixesCodes(&$suffixe, &$radical_champ, &$validite_ressource ) { |
if (!in_array($suffixe, array('*', 'code', 'href', 'details'))) { |
$validite_ressource = false; |
$this->renvoyerErreur( RestServeur::HTTP_CODE_MAUVAISE_REQUETE, |
'Erreur : Le suffixe demandé n\'existe pas pour le champ "'.$radical_champ.'.<br/> |
Les suffixes possibles sont les suivants : |
<li> .* </li><li> .code </li><li> .href </li><li> .details </li>'); |
} |
} |
|
|
public function verificationSuffixesIdentifiant(&$suffixe, &$radical_champ, &$validite_ressource) { |
if ((strrpos($radical_champ, 'parent') !== false && !in_array($suffixe, array('*', 'id', 'href', 'details', 'notes'))) |
|| !in_array($suffixe, array('*', 'id', 'href', 'details')) && strrpos($radical_champ, 'parent') === false) { |
$validite_ressource = false; |
$this->renvoyerErreur( RestServeur::HTTP_CODE_MAUVAISE_REQUETE, |
'Erreur : Le suffixe demandé n\'existe pas pour le champ "'.$radical_champ.'".<br/> |
Les suffixes possibles sont les suivants : |
<li> .* </li><li> .id </li><li> .href </li><li> .details </li><li> .notes (seulement pour les hybride.parent)'); |
} |
} |
|
|
//------------------------------fonction de formatage pour les services /stats/----------------------------------------- |
|
public function formaterStatsAnnee($resultat) { |
$res = array(); |
foreach ($resultat as $version => $res_version) { |
foreach ($res_version as $cle_annee) { |
foreach ($cle_annee as $key => $val) { |
switch($key) { |
case 'annee' : $annee = ($val != '') ? $val : 'N.D.'; break; |
case 'nombre': $nb = $val; break; |
default : break; |
} |
} |
$retour_stats_annee[$annee] = $nb; |
} |
//Si les infos de plrs versions sont renvoyés, on ajoute au tableau de resultat le numéro de la version |
$res = $this->afficherVersionOuPas($version, $retour_stats_annee, $res); |
} |
return $res; |
} |
|
|
public function formaterStatsRang($resultat) { |
$res = array(); |
foreach ($resultat as $version => $res_version) { |
foreach ($res_version as $rangs) { |
if ($rangs['rang'] != 0) { |
foreach ($rangs as $key => $val) { |
switch ($key) { |
case 'rang' : $rang = $val; break; |
case 'nombre' : $nombre = $val; break; |
default : break; |
} |
} |
$retour_rang[$rang] = array( |
'rang' => $this->ajouterSignificationCode('rang', $rang), |
'nombre' => $nombre |
); |
} |
} |
//Si les infos de plrs versions sont renvoyés, on ajoute au tableau de resultat le numéro de la version |
$res = $this->afficherVersionOuPas($version, $retour_rang, $res); |
} |
return $res; |
} |
|
|
public function formaterStatsInitiales($resultat) { |
$res = array(); |
$table_rang = array(); |
foreach ($resultat as $version => $res_version) { |
foreach ($res_version as $tuple) { |
if ($tuple['rang'] != 0) { |
if (!isset($table_rang[$tuple['rang']])) { |
$rang = $this->ajouterSignificationCode('rang', $tuple['rang']); |
$table_rang[$tuple['rang']] = $rang; |
} else { |
$rang = $table_rang[$tuple['rang']]; |
} |
if ($tuple['lettre'] == 'x ') { |
if (isset($this->table_retour[$rang]['hyb'])) { |
$this->table_retour[$rang]['hybride'] += floatval($tuple['nb']); |
} else { |
$this->table_retour[$rang]['hybride'] = floatval($tuple['nb']); |
} |
} elseif ($tuple['lettre'] == '+ ') { |
if (isset($this->table_retour[$rang]['chimère'])) { |
$this->table_retour[$rang]['chimère'] += floatval($tuple['nb']); |
} else { |
$this->table_retour[$rang]['chimère'] = floatval($tuple['nb']); |
} |
} else { |
$l = substr($tuple['lettre'], 0, 1); |
if (isset($this->table_retour[$rang][$l])) { |
$this->table_retour[$rang][substr($tuple['lettre'], 0, 1)] += floatval($tuple['nb']); |
} else { |
$this->table_retour[$rang][substr($tuple['lettre'], 0, 1)] = floatval($tuple['nb']); |
} |
} |
} |
} |
//Si les infos de plrs versions sont renvoyés, on ajoute au tableau de resultat le numéro de la version |
$res = $this->afficherVersionOuPas($version, $this->table_retour, $res); |
} |
return $res; |
} |
|
|
//-----------------------------Fonctions d'affichage utiliser dans les fonctions de formatage--------------------------- |
|
/** Affiche les résultats en fonction du paramètre retour_format. */ |
public function afficherDonnees($key, $valeur) { |
//on souhaite afficher le nom au format de l'api |
if ($this->retour_format == 'min') { |
if ($this->correspondAChampApi($key)) { //on affiche l'intitulé selon decrit dans l'api |
if ($key == 'nom_sci') $valeur = $valeur.$this->ajouterCompositionNom($this->resultat_req); |
$this->table_retour[$this->correspondance_champs[$key]] = $valeur; |
} else { |
$this->table_retour[$key] = $valeur; |
} |
} else { |
if ($this->correspondAChampApi($key)) { |
$nom_champ_api = $this->correspondance_champs[$key]; //on récupere le nom comme définit ds l'api |
$this->afficherToutesLesInfos($nom_champ_api, $valeur); |
} elseif ($this->estDansBdnff($key)) { |
$this->table_retour[$key] = $valeur; |
} |
} |
} |
|
|
public function afficherToutesLesInfos($nom_champ_api, $valeur) { |
if ($this->presentePlusieursId($nom_champ_api, $valeur)) { |
preg_match('/^([^.]+\.parent_0[12]|[^.]+)(?:\.id)?$/', $nom_champ_api, $match); |
$this->afficherInfosPrecises($match[1], 'details', $valeur); |
$this->table_retour[$nom_champ_api] = $valeur; |
} elseif (strrpos($nom_champ_api, 'parent') !== false && strrpos($nom_champ_api, 'notes') !== false) { |
$this->table_retour[$nom_champ_api] = $valeur; |
} elseif (($this->correspondAUnId($nom_champ_api) || $nom_champ_api == 'id') && $valeur != '0') { |
preg_match('/^([^.]+\.parent_0[12]|[^.]+)(?:\.id)?$/', $nom_champ_api, $match); |
$this->afficherInfosPrecises($match[1], 'id,signification,href', $valeur); |
} elseif ($this->correspondAUnCode($nom_champ_api)) { |
preg_match('/^([^.]+)(?:\.code)?$/', $nom_champ_api, $match); |
$this->afficherInfosPrecises($match[1], 'code,signification,href', $valeur); |
} |
} |
|
|
public function presentePlusieursId($ressource, $valeur = null) { |
if ($valeur) { |
$presente = strrpos($ressource, 'proparte') !== false && strrpos($valeur, ',') !== false; |
} else { //pour la vérification du champ, on ignore alors la valeur de la ressource |
$presente = strrpos($ressource, 'proparte') !== false; |
} |
return $presente; |
} |
|
|
public function afficherTableDetails($nom_champ_api, $valeur) { |
$tab_id = explode(',',$valeur); |
$tab_res = $this->table_retour; |
$this->table_retour = array(); |
foreach ($tab_id as $id) { |
$this->afficherInfosPrecises($nom_champ_api, 'id,signification,href', $id); |
$tab_res[$nom_champ_api.'.details'][] = $this->table_retour; |
$this->table_retour = array(); |
} |
$this->table_retour = $tab_res; |
} |
|
|
public function afficherPointEtoile($champ, $valeur) { |
if ($this->presentePlusieursId($champ, $valeur)) { |
$this->afficherInfosPrecises($champ, 'details', $valeur); |
$this->table_retour[$champ] = $valeur; |
} elseif (strrpos($champ, 'parent') !== false) { |
$this->afficherInfosPrecises($champ, 'id,href,notes', $valeur); |
} elseif ($this->correspondAUnId($champ) || $champ == 'id') { |
$this->afficherInfosPrecises($champ, 'id,href', $valeur); |
} elseif ($this->correspondAUnCode($champ)) { |
$this->afficherInfosPrecises($champ, 'code,href', $valeur); |
} |
} |
|
|
public function afficherInfosPrecises($champ, $suffixe, $valeur) { |
$suffixes = explode(',', $suffixe); |
//on initialise au service appelé. Sera potentiellement modifié dans la fonction afficherSignification() |
$this->service_href = $this->service; |
foreach ($suffixes as $suff) { |
switch ($suff) { |
case 'id' : |
$this->table_retour[str_replace('id.id', 'id', $champ.'.id')] = $valeur; |
break; |
case 'details' : |
$this->afficherTableDetails($champ, $valeur); |
break; |
case 'signification' : |
$this->afficherSignification($champ, $valeur); |
break; |
case 'href' : |
if ($this->correspondAUnId($champ) || $champ == 'id') { |
$service = $this->service_href; |
$url = $this->ajouterHref($service, $valeur); |
} else { |
$service = 'ontologies'; |
$champ_url = $champ; |
$url = $this->ajouterHrefAutreProjet($service, $val, $champ_url); |
} |
$this->table_retour[str_replace('id.href', 'href', $champ.'.href')] = $url; |
break; |
case 'code' : |
$val = ( $champ == 'rang' ) ? 'bdnt.rangTaxo:'.$valeur : 'bdnt.'.rtrim($champ, '_Ga,_Co').':'.$valeur; |
$this->table_retour[$champ.'.code'] = $val; |
break; |
case 'notes' : |
$this->table_retour[$champ.'.notes'] = $this->resultat_req[str_replace('.', '_', $champ).'_notes']; |
break; |
default : |
break; |
} |
} |
} |
|
|
public function afficherSignification($champ, $valeur) { |
if ($champ == 'id' && isset($this->resultat_req['nom_sci']) && $this->resultat_req['num_nom'] == $valeur) { |
//si le nom_sci du num_nom que l'on veut afficher est déjà dans la table de résultat : |
$this->table_retour['nom_sci'] = $this->resultat_req['nom_sci'].$this->ajouterCompositionNom($this->resultat_req); |
} elseif ($this->correspondAUnId($champ) || $champ == 'id') { |
$nom = $this->recupererNomSci($valeur); |
$champ = ($champ == 'id') ? 'nom_sci' : $champ; |
if ($nom != array()) { |
$this->table_retour[$champ] = $nom['nom_sci']; |
$this->service_href = $nom['service']; |
} |
} elseif ($this->correspondAUnCode($champ)) { |
$this->table_retour[$champ] = $this->ajouterSignificationCode($champ, $valeur); |
} |
} |
|
|
/** Permet d'afficher les élements nomenclatural du nom_sci lors de l'appel dans le service noms/id/champ du champ^nom_sci.*/ |
public function afficherNomSciPointEpithete($resultat) { |
foreach ($this->tab_nom_sci as $compo_nom) { |
if (isset($resultat[$compo_nom]) && !empty($resultat[$compo_nom])) { |
$this->table_retour['nom_sci.'.$compo_nom] = $resultat[$compo_nom]; |
} |
} |
} |
|
/** utilisé dans le formatage de /noms/id et de /noms/id/champ seulement */ |
public function afficherNomSci($resultat) { |
if ($this->html == 'htm') { |
$this->table_retour['nom_sci'] = $resultat['nom_sci_html'].$this->ajouterCompositionNom($resultat); |
} else { |
$this->table_retour['nom_sci'] = $resultat['nom_sci'].$this->ajouterCompositionNom($resultat); |
} |
} |
|
|
/** Permet d'afficher la signification d'un code pour le rang, la présence, et les differents statuts */ |
public function ajouterSignificationCode($champ, $valeur) { |
$champ = ($champ == 'rang') ? 'rangTaxo' : rtrim($champ, '_Co,_Ga'); |
if (preg_match('/^([^_-]+)(?:_|-)([^_-]+)$/', $champ, $match)) { |
$champ = $match[1].ucfirst($match[2]); |
} |
$url = Config::get('url_ontologie').$champ.':'.$valeur.'/nom'; |
$res = $this->consulterHref($url); //dans commun.php |
$nom_code = $res->nom; |
return $nom_code; |
} |
|
|
/** Recupere le nom_scientifique (formaté ou non en fonction du parametre ns.format) à partir du num_nom */ |
public function recupererNomSci($id) { |
$nom = array(); |
if ($id != 0) { |
if ($this->compo_nom == null) { |
$req = 'SELECT nom_sci, num_nom_retenu FROM '.$this->table.' WHERE num_nom = '.$id; |
} else { //on ajoute à la requete sql, les champs de ns.structure |
$req = 'SELECT nom_sci, num_nom_retenu, '.implode(', ', $this->compo_nom) |
.' FROM '.$this->table |
.' WHERE num_nom = '.$id; |
} |
if ($this->html == 'htm') { |
$req = str_replace('nom_sci', 'nom_sci_html as nom_sci', $req); |
} |
$res = $this->getBdd()->recuperer($req); |
if ($res) { |
$nom['nom_sci'] = $res['nom_sci'].$this->ajouterCompositionNom($res); |
$nom['service'] = ($res['num_nom_retenu'] == $id && $this->service == 'taxons') ? 'taxons' : 'noms'; |
} else { |
$this->renvoyerErreur(RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE, |
'Fct recupererNomSci() : Donnees introuvables dans la base pour l\'id '.$id); |
} |
} |
return $nom; |
} |
|
/** Permet de retourner une chaine de caractère composée des parametres du nom (ns.structure : annnée, auteur, |
* bibilio et addendum). A ajouter au nom scientifique */ |
public function ajouterCompositionNom($tab_res) { |
$nom_complet = ' '; |
$this->ajouterAuteur($tab_res, $nom_complet); |
$this->ajouterAnneeEtBiblio($tab_res, $nom_complet); |
$this->ajouterAnneeSansBilio($tab_res, $nom_complet); |
$this->ajouterBiblioSansAnnee($tab_res, $nom_complet); |
$this->ajouterAddendum($tab_res, $nom_complet); |
return rtrim($nom_complet); |
} |
|
|
public function ajouterAuteur($tab_res, &$nom_complet) { |
if (isset($this->compo_nom['au']) && isset($tab_res['auteur']) && $tab_res['auteur'] != '') { |
if ($this->html == 'htm') { |
$nom_complet .= '<span class="auteur">'.$tab_res['auteur'].'</span> '; |
} else { |
$nom_complet .= $tab_res['auteur'].' '; |
} |
} |
} |
|
public function ajouterAnneeEtBiblio($tab_res, &$nom_complet) { |
if (isset($this->compo_nom['an']) && isset($this->compo_nom['bib']) |
&& isset($tab_res['annee']) && ($tab_res['annee'] != '') |
&& isset($tab_res['biblio_origine']) && ($tab_res['biblio_origine'] != '')) { |
if ($this->html == 'htm') { |
$nom_complet .= '[<span class="annee">'.$tab_res['annee'].'</span>, <span class="biblio">' |
.$tab_res['biblio_origine'].'</span>]'; |
} else { |
$nom_complet .= '['.$tab_res['annee'].', '.$tab_res['biblio_origine'].']'; |
} |
} |
} |
|
public function ajouterAnneeSansBilio($tab_res, &$nom_complet) { |
if (isset($this->compo_nom['an']) && !isset($this->compo_nom['bib']) |
&& isset($tab_res['annee']) && ($tab_res['annee'] != '')) { |
if ($this->html == 'htm') { |
$nom_complet .= '[<span class="annee">'.$tab_res['annee'].'</span>]'; |
} else { |
$nom_complet .= '['.$tab_res['annee'].']'; |
} |
} |
} |
|
public function ajouterBiblioSansAnnee($tab_res, &$nom_complet) { |
if (!isset($this->compo_nom['an']) && isset($this->compo_nom['bib']) && ($tab_res['biblio_origine'] != '')) { |
if ($this->html == 'htm') { |
$nom_complet .= '[<span class="biblio">'.$tab_res['biblio_origine'].'</span>]'; |
} else { |
$nom_complet .= '['.$tab_res['biblio_origine'].']'; |
} |
} |
} |
|
public function ajouterAddendum($tab_res, &$nom_complet) { |
if (isset($this->compo_nom['ad']) && ($tab_res['nom_addendum'] != '')) { |
if ($this->html == 'htm') { |
$nom_complet .= '[<span class="adendum">'.$tab_res['nom_addendum'].'</span>]'; |
} else { |
$nom_complet .= '['.$tab_res['nom_addendum'].']'; |
} |
} |
} |
|
public function correspondAUnCode($key) { |
return (strrpos($key, '.code') !== false) || (in_array($key.'.code', $this->correspondance_champs)); |
} |
|
public function correspondAUnId($key) { |
return (strrpos($key, '.id') !== false) || (in_array($key.'.id', $this->correspondance_champs)); |
} |
|
public function estChampApi($champ) { |
return (in_array($champ, $this->champs_api) || in_array($champ, $this->correspondance_champs)); |
} |
|
public function correspondAChampApi($champ_bdd) { |
return (array_key_exists($champ_bdd, $this->champs_api) || array_key_exists($champ_bdd, $this->correspondance_champs)); |
} |
|
public function estDansBdnff($champ) { |
return (in_array($champ, $this->champs_comp)); |
} |
|
public function estUnPoint($key) { |
if (strrpos($key, 'hybride.parent') !== false) { |
$key = str_replace('hybride.parent', 'hybride_parent', $key); |
} |
return (strrpos($key, '.') !== false); |
} |
} |
|
?> |
Property changes: |
Added: svn:executable |
+* |
\ No newline at end of property |