| /branches/v5.12-baouque/services/modules/0.1/chorodep/cartes/FranceCartes.php |
|---|
| New file |
| 0,0 → 1,273 |
| <?php |
| // declare(encoding='UTF-8'); |
| /** |
| * Gère le sous-service Taxons de Cartes. |
| * |
| * @see http://www.tela-botanica.org/wikini/eflore/wakka.php?wiki=EfloreApi01Cartes |
| * |
| * @package eFlore/services |
| * @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) |
| */ |
| // TODO : Config et Outils sont des classes statiques qui doivent poser des pb pour les tests... |
| class FranceCartes { |
| private $parametres = array(); |
| private $ressources = array(); |
| protected $largeurOrig = 600; |
| protected $longeurOrig = 545; |
| protected $largeurDefaut = 600; |
| protected $largeurDemandee = 600; |
| protected $prefixe_id_zone = 'INSEE-D'; |
| protected $options_cache = array(); |
| const PRESENCE_CHOROLOGIE = '1'; |
| public function __construct(Conteneur $conteneur) { |
| $this->Bdd = $conteneur->getBdd(); |
| $this->tableOntologie = $conteneur->getParametre('bdd_table_ontologies'); |
| $this->config = $conteneur->getParametre('Cartes'); |
| $this->convertisseur = $this->config['convertisseur']; |
| $this->tableMeta = $conteneur->getParametre('bdd_table_meta'); |
| $this->cheminCartesBase = $this->config['chemin']; |
| $this->options_cache = array('mise_en_cache' => $this->config['cache_miseEnCache'], |
| 'stockage_chemin' => $this->config['cache_stockageChemin'], |
| 'duree_de_vie' => $this->config['cache_dureeDeVie']); |
| } |
| public function consulter($ressources, $parametres) { |
| $this->parametres = $parametres; |
| $this->ressources = $ressources; |
| $this->chargerMetadonnees(); |
| $this->definirVersion(); |
| $this->tableChorodep = 'chorodep_v'.str_replace('.', '_', $this->version); |
| if(isset($parametres['retour.format']) && is_numeric($parametres['retour.format'])) { |
| $this->largeurDemandee = intval($parametres['retour.format']); |
| } |
| if(count($ressources) == 0) { |
| $resultat = $this->getCarteTaxonsParZones(); |
| } else if($ressources[0] == "legende") { |
| $cache = $this->getCache('global'); |
| if($cache != null) { |
| $max = $cache['nb_taxons_max']; |
| } else { |
| $max = $this->getNbMaxTaxonsParZones(); |
| } |
| $resultat = $this->getLegendeCarteTaxonsParZones($max); |
| } |
| return $resultat; |
| } |
| private function chargerMetadonnees() { |
| $requete = 'SELECT * '. |
| "FROM {$this->tableMeta} ". |
| "ORDER BY date_creation DESC "; |
| $resultats = $this->Bdd->recupererTous($requete); |
| if (!is_array($resultats) || count($resultats) <= 0) { |
| $message = "Les méta-données n'ont pu être chargée pour la ressource demandée"; |
| $code = RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE; |
| throw new Exception($message, $code); |
| } |
| $this->metadonnees = $resultats; |
| } |
| private function definirVersion() { |
| $this->version = $this->metadonnees[0]['version']; |
| } |
| public function getLegendeCarteTaxonsParZones($nb_max) { |
| // TODO : mettre en config ou en ontologie ? |
| // mais ça fait encore un appel de plus aux ontologies |
| // qui sont déjà bien bien bien bien chargées |
| $this->couleurs_legende_globale = array("#808080", "#EFF8E1", "#F2E2C0", "#C9CC8D", "#C1E587", "#A0FF7D"); |
| $couleurs = $this->couleurs_legende_globale; |
| $legende = array( |
| "seuil0" => array( |
| "code" => "", |
| "couleur" => $couleurs[0], |
| "css" => "", |
| "nom" => "Non renseignée", |
| "description" => "Zone géographique non renseignée." |
| ) |
| ); |
| array_shift($couleurs); |
| $borne_min = 0; |
| $borne_max = 500; |
| for($i = 1; $i <= 5; $i++) { |
| $borne_max = ($i == 5) ? $nb_max : $borne_max; |
| $legende["seuil".$i] = array( |
| "code" => "", |
| "couleur" => $couleurs[$i-1], |
| "css" => "", |
| "nom" => "de ".$borne_min." à ".$borne_max." taxons", |
| "description" => "de ".$borne_min." à ".$borne_max." taxons." |
| ); |
| $borne_min = $borne_max + 1; |
| $borne_max = ($i == 5) ? $nb_max : ($i * 1200); |
| } |
| return $legende; |
| } |
| private function convertirLegendeVersCss($legende) { |
| $css = ""; |
| foreach($legende as $cle => $item) { |
| if($item['css'] != '') { |
| $css .= |
| $item['css']." {"."\n". |
| " fill:".$item['couleur'].";"."\n". |
| "}"."\n\n"; |
| } |
| } |
| return $css; |
| } |
| public function getCarteTaxonsParZones() { |
| $this->envoyerCacheSiExiste('global'); |
| $taxonsParZones = $this->compterTaxonsParZones(); |
| $legende = $this->getLegendeCarteTaxonsParZones($taxonsParZones['max']); |
| $infos_zones = array(); |
| $max = 0; |
| foreach($taxonsParZones['nb_taxons_par_zones'] as $id_zone => $nb) { |
| $infos_zones[$id_zone] = "- ".$nb." taxons présents"; |
| $legende[$this->getSeuil($nb)]['css'] .= $legende[$this->getSeuil($nb)]['css'] != "" ? ', ' : '' ; |
| $legende[$this->getSeuil($nb)]['css'] .= "#".$this->prefixe_id_zone.$id_zone; |
| $max = $max < $nb ? $nb : $max; |
| } |
| $this->style = $this->convertirLegendeVersCss($legende); |
| $svg = $this->assemblerSvg( |
| $this->calculerHauteur($this->largeurDemandee), |
| $this->largeurDemandee, |
| $this->style, |
| $infos_zones); |
| $this->sauverCache(array('style' => $this->style, 'infos_zones' => $infos_zones, 'nb_taxons_max' => $max), 'global'); |
| $this->envoyerSvg($svg); |
| } |
| // Fonction bien pourrie pour renvoyer juste un max |
| // mais son résultat est mis en cache donc elle sera appelée environ |
| // une fois par an (et encore si on appelle la légende avant la carte) |
| public function getNbMaxTaxonsParZones() { |
| $taxonsParZones = $this->compterTaxonsParZones(); |
| $max = 0; |
| foreach($taxonsParZones as $id_zone => $nb) { |
| $max = $max < $nb ? $nb : $max; |
| } |
| return $max; |
| } |
| public function getSeuil($nb_taxons) { |
| // TODO: factoriser les bornes avec la fonction qui gère la légende |
| $seuil = ""; |
| if($nb_taxons <= 1) { |
| $seuil = "1"; |
| } elseif (2 <= $nb_taxons && $nb_taxons <= 1200) { |
| $seuil = "2"; |
| } elseif (1201 <= $nb_taxons && $nb_taxons <= 2400) { |
| $seuil = "3"; |
| } elseif (2401 <= $nb_taxons && $nb_taxons <= 3600) { |
| $seuil = "4"; |
| } elseif (3601 <= $nb_taxons) { |
| $seuil = "5"; |
| } |
| return "seuil".$seuil; |
| } |
| public function compterTaxonsParZones() { |
| $req = "SELECT * FROM ".$this->tableChorodep; |
| $resultat = $this->Bdd->recupererTous($req); |
| $max = 0; |
| $nb_taxons_par_zones = array(); |
| foreach($resultat as $ligne) { |
| $i = 0; |
| for($i < 0; $i <= 100; $i++) { |
| $index = $i < 10 ? "0".$i : $i; |
| if(isset($ligne[$index]) && $ligne[$index] != "" && $ligne[$index] == self::PRESENCE_CHOROLOGIE) { |
| // seules les présences certaines sont prises en compte |
| $nb_taxons_par_zones[$index] = isset($nb_taxons_par_zones[$index]) ? $nb_taxons_par_zones[$index] : 0; |
| $nb_taxons_par_zones[$index] += 1; |
| // calcul du max qui sert à générer la légende |
| $max = $nb_taxons_par_zones[$index] > $max ? $nb_taxons_par_zones[$index] : $max; |
| } |
| } |
| } |
| return array('nb_taxons_par_zones' => $nb_taxons_par_zones, 'max' => $max); |
| } |
| public function sauverCache($a_cacher, $cache_id) { |
| $cache = new CacheSimple($this->options_cache); |
| return $cache->sauver(serialize($a_cacher), $cache_id); |
| } |
| public function getCache($id) { |
| $cache = new CacheSimple($this->options_cache); |
| if(($contenu_cache = $cache->charger($id)) !== false) { |
| $contenu_cache = unserialize($contenu_cache); |
| } |
| return $contenu_cache; |
| } |
| private function calculerHauteur($largeur) { |
| $rapport = $this->longeurOrig/$this->largeurOrig; |
| $hauteur = $rapport * $largeur; |
| return intval($hauteur); |
| } |
| private function envoyerCacheSiExiste($id) { |
| if(($cache = $this->getCache($id))) { |
| $style = $cache['style']; |
| $infos_zones = $cache['infos_zones']; |
| $cache = $this->assemblerSvg($this->calculerHauteur($this->largeurDemandee), $this->largeurDemandee, $style, $infos_zones); |
| $this->envoyerSvg($cache); |
| } |
| } |
| private function assemblerSvg($hauteur, $largeur, $style, $infos_zones) { |
| $tpl_svg = $this->cheminCartesBase.'/france_02.tpl.svg'; |
| $donnees = array( |
| 'hauteur' => $hauteur, |
| 'largeur' => $largeur, |
| 'css' => $style, |
| 'infos_zones' => $infos_zones |
| ); |
| $svg = SquelettePhp::analyser($tpl_svg, $donnees); |
| return $svg; |
| } |
| private function envoyerLegende($legende) { |
| header("Content-type: application/json"); |
| echo json_encode($legende); |
| exit; |
| } |
| private function envoyerSvg($svg) { |
| header("Content-type: image/svg+xml"); |
| echo $svg; |
| exit; |
| } |
| } |
| /branches/v5.12-baouque/services/modules/0.1/chorodep/cartes/LegendeCartes.php |
|---|
| New file |
| 0,0 → 1,112 |
| <?php |
| // declare(encoding='UTF-8'); |
| /** |
| * Gère le sous-service Legende de Cartes. |
| * |
| * @see http://www.tela-botanica.org/wikini/eflore/wakka.php?wiki=EfloreApi01Cartes |
| * |
| * @package eFlore/services |
| * @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) |
| */ |
| // TODO : Config et Outils sont des classes statiques qui doivent poser des pb pour les tests... |
| class LegendeCartes { |
| private $parametres = array(); |
| private $ressources = array(); |
| const MIME_JSON = 'application/json'; |
| const PRESENCE_CHOROLOGIE = '1'; |
| private $formatsSupportes = array(self::MIME_JSON); |
| private $tableOntologie = ''; |
| private $ontologies = ''; |
| private $legende = array(); |
| public function __construct(Conteneur $conteneur) { |
| $this->Bdd = $conteneur->getBdd(); |
| $this->tableOntologie = $conteneur->getParametre('bdd_table_ontologies'); |
| } |
| public function consulter($ressources, $parametres) { |
| //$tpsDebut = microtime(true); |
| $this->parametres = $parametres; |
| $this->ressources = $ressources; |
| $this->definirValeurParDefautDesParametres(); |
| $this->verifierParametres(); |
| $resultat = $this->obtenirResultat(); |
| return $resultat; |
| } |
| private function definirValeurParDefautDesParametres() { |
| if (isset($this->parametres['retour']) == false) { |
| $this->parametres['retour'] = self::MIME_JSON; |
| } |
| } |
| private function verifierParametres() { |
| $erreurs = array(); |
| if (isset($this->parametres['retour']) == false) { |
| $erreurs[] = "Le paramètre type de retour 'retour' est obligatoire."; |
| } |
| if ($this->verifierValeurParametreRetour() == false) { |
| $erreurs[] = "Le type de retour '{$this->parametres['retour']}' n'est pas supporté."; |
| } |
| if (count($erreurs) > 0) { |
| $message = implode('<br />', $erreurs); |
| $code = RestServeur::HTTP_CODE_MAUVAISE_REQUETE; |
| throw new Exception($message, $code); |
| } |
| } |
| private function verifierValeurParametreRetour() { |
| return in_array($this->parametres['retour'], $this->formatsSupportes); |
| } |
| private function obtenirResultat() { |
| $this->chargerOntologies(); |
| $this->chargerLegende(); |
| $resultat = new ResultatService(); |
| $resultat->corps = $this->legende; |
| $resultat->mime = $this->parametres['retour']; |
| return $resultat; |
| } |
| private function chargerOntologies() { |
| $requete = "SELECT * FROM {$this->tableOntologie} "; |
| $resultats = $this->Bdd->recupererTous($requete); |
| if (!is_array($resultats) || count($resultats) <= 0) { |
| $message = "Les données d'ontologies n'ont pu être chargées pour la ressource demandée"; |
| $code = RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE; |
| throw new Exception($message, $code); |
| } |
| foreach ($resultats as $ontologie) { |
| $this->ontologies[$ontologie['id']] = Commun::extraireComplementsOntologies($ontologie); |
| } |
| } |
| private function chargerLegende() { |
| foreach ($this->ontologies as $ontologie) { |
| if ($ontologie['classe_id'] == self::PRESENCE_CHOROLOGIE) { |
| $this->legende[] = array( |
| 'code' => $ontologie['code'], |
| 'couleur' => $ontologie['legende'], |
| 'nom' => $ontologie['nom'], |
| 'description' => $ontologie['description']); |
| } |
| } |
| } |
| } |
| ?> |
| /branches/v5.12-baouque/services/modules/0.1/chorodep/cartes/TaxonsCartes.php |
|---|
| New file |
| 0,0 → 1,468 |
| <?php |
| // declare(encoding='UTF-8'); |
| /** |
| * Gère le sous-service Taxons de Cartes. |
| * |
| * @see http://www.tela-botanica.org/wikini/eflore/wakka.php?wiki=EfloreApi01Cartes |
| * |
| * @package eFlore/services |
| * @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) |
| */ |
| // TODO : Config et Outils sont des classes statiques qui doivent poser des pb pour les tests... |
| class TaxonsCartes { |
| private $parametres = array(); |
| private $ressources = array(); |
| const CODE_REFTAX_DEFAUT = 'bdtfx'; |
| const TYPE_ID_DEFAUT = 'nn'; |
| const CARTE_DEFAUT = 'france_02'; |
| const FORMAT_DEFAUT = '587x550'; |
| const VERSION_DEFAUT = '+'; |
| const MIME_SVG = 'image/svg+xml'; |
| const MIME_PNG = 'image/png'; |
| const PRESENCE_CHOROLOGIE = '1'; |
| private $config = array(); |
| private $convertisseur = ''; |
| private $cheminCartesBase = ''; |
| private $formatsSupportes = array(self::MIME_SVG, self::MIME_PNG); |
| private $reftaxSupportes = array(self::CODE_REFTAX_DEFAUT); |
| private $UrlNavigation = null; |
| private $taxonsDemandes = array(); |
| private $imgLargeur = 0; |
| private $imgHauteur = 0; |
| private $tableMeta = ''; |
| private $tableOntologie = ''; |
| private $tableChorodep = ''; |
| private $metadonnees = ''; |
| private $ontologies = ''; |
| private $priorites = ''; |
| private $version = ''; |
| private $legende = array(); |
| private $donnees = array(); |
| public function __construct(Conteneur $conteneur) { |
| $this->Bdd = $conteneur->getBdd(); |
| $this->tableOntologie = $conteneur->getParametre('bdd_table_ontologies'); |
| $this->config = $conteneur->getParametre('Cartes'); |
| $this->convertisseur = $this->config['convertisseur']; |
| $this->tableMeta = $conteneur->getParametre('bdd_table_meta'); |
| $this->tableOntologie = $conteneur->getParametre('bdd_table_ontologies'); |
| $this->cheminCartesBase = $this->config['chemin']; |
| $cacheOptions = array('mise_en_cache' => $this->config['cache_miseEnCache'], |
| 'stockage_chemin' => $this->config['cache_stockageChemin'], |
| 'duree_de_vie' => $this->config['cache_dureeDeVie']); |
| $this->cache = $conteneur->getCacheSimple($cacheOptions); |
| } |
| public function consulter($ressources, $parametres) { |
| $this->parametres = $parametres; |
| $this->ressources = $ressources; |
| $this->definirValeurParDefautDesParametres(); |
| $this->verifierParametres(); |
| $resultat = $this->obtenirResultat(); |
| return $resultat; |
| } |
| private function definirValeurParDefautDesParametres() { |
| if (isset($this->parametres['retour']) == false) { |
| $this->parametres['retour'] = self::MIME_SVG; |
| } |
| if (isset($this->parametres['retour.format']) == false) { |
| $this->parametres['retour.format'] = self::FORMAT_DEFAUT; |
| } |
| if (isset($this->parametres['version.projet']) == false) { |
| $this->parametres['version.projet'] = self::VERSION_DEFAUT; |
| } |
| } |
| private function verifierParametres() { |
| $erreurs = array(); |
| if (isset($this->parametres['retour']) == false) { |
| $erreurs[] = "Le paramètre type de retour 'retour' est obligatoire."; |
| } |
| if ($this->verifierValeurParametreRetour() == false) { |
| $erreurs[] = "Le type de retour '{$this->parametres['retour']}' n'est pas supporté."; |
| } |
| if (isset($this->parametres['retour.format']) == false) { |
| $erreurs[] = "Le paramètre de format de retour 'retour.format' est obligatoire."; |
| } |
| if ($this->verifierValeurParametreFormat() == false) { |
| $erreurs[] = "Le type de format '{$this->parametres['retour.format']}' n'est pas supporté.". |
| "Veuillez indiquer un nombre entier correspondant à la largeur désirée pour la carte."; |
| } |
| if ($this->verifierValeurParametreVersionProjet() == false) { |
| $erreurs[] = "Le format de version.projet '{$this->parametres['version.projet']}' n'est pas supporté.". |
| "Veuillez indiquer le code '+' (=dernière version) ou une année sur 4 chiffres séparé d'un mois ". |
| "sur deux chiffres par un point. Ex. : 2012.01"; |
| } |
| if (count($erreurs) > 0) { |
| $message = implode('<br />', $erreurs); |
| $code = RestServeur::HTTP_CODE_MAUVAISE_REQUETE; |
| throw new Exception($message, $code); |
| } |
| } |
| private function verifierValeurParametreRetour() { |
| return in_array($this->parametres['retour'], $this->formatsSupportes); |
| } |
| private function verifierValeurParametreFormat() { |
| if ($ok = preg_match('/^([0-9]+)$/', $this->parametres['retour.format'], $match)) { |
| $this->imgLargeur = $match[1]; |
| } else if ($ok = preg_match('/^([0-9]+)x([0-9]+)$/', $this->parametres['retour.format'], $match)) { |
| $this->imgLargeur = $match[1]; |
| $this->imgHauteur = $match[2]; |
| } |
| return $ok; |
| } |
| private function verifierValeurParametreVersionProjet() { |
| $ok = (preg_match('/^(?:[+]|[0-9]{4}\.[0-9]{2})$/', $this->parametres['version.projet']) == 0) ? false : true; |
| return $ok; |
| } |
| private function obtenirResultat() { |
| $this->analyserIdentifiants(); |
| $this->verifierIdentifiants(); |
| $this->chargerMetadonnees(); |
| $this->definirVersion(); |
| $this->tableChorodep = 'chorodep_v'.str_replace('.', '_', $this->version); |
| $this->chargerOntologies(); |
| $this->chargerLegende(); |
| $this->chargerPrioritesLegende(); |
| $this->chargerDonnees(); |
| $svg = $this->genererSVG(); |
| $img = ($this->parametres['retour'] == self::MIME_PNG) ? $this->convertirEnPNG($svg) : $svg; |
| $resultat = new ResultatService(); |
| $resultat->corps = $img; |
| $resultat->mime = $this->parametres['retour']; |
| return $resultat; |
| } |
| private function analyserIdentifiants() { |
| $ids = $this->ressources[0]; |
| if (preg_match('/^[0-9]+$/', $ids)) { |
| $this->taxonsDemandes[self::CODE_REFTAX_DEFAUT]['nn'][] = $ids; |
| } else { |
| // ceci contient potentiellement des formes ref_tax1.nn:1,2;ref_tax2.nt:3,4 |
| $projetsListeEtNumNoms = explode(';', $ids); |
| if (count($projetsListeEtNumNoms) > 0) { |
| foreach ($projetsListeEtNumNoms as $projetEtNumNoms) { |
| $projetEtNumNoms = (strpos($projetEtNumNoms, ':')) ? $projetEtNumNoms : self::CODE_REFTAX_DEFAUT.'.nn:'.$projetEtNumNoms; |
| list($projetEtType, $numNoms) = explode(':', $projetEtNumNoms); |
| $projetEtType = (strpos($projetEtType, '.')) ? $projetEtType : self::CODE_REFTAX_DEFAUT.'.'.$projetEtType; |
| list($projet, $type) = explode('.', $projetEtType); |
| $this->taxonsDemandes[$projet][$type] = explode(',', $numNoms); |
| } |
| } |
| } |
| } |
| private function verifierIdentifiants() { |
| foreach (array_keys($this->taxonsDemandes) as $reftax) { |
| $ok = in_array($reftax, $this->reftaxSupportes); |
| if ($ok == false) { |
| $message = "Le reférentiel taxonomique '$reftax' n'est pas pris en compte par ce projet."; |
| $code = RestServeur::HTTP_CODE_MAUVAISE_REQUETE; |
| throw new Exception($message, $code); |
| } |
| } |
| } |
| private function chargerMetadonnees() { |
| $requete = 'SELECT * '. |
| "FROM {$this->tableMeta} ". |
| "ORDER BY date_creation DESC "; |
| $resultats = $this->Bdd->recupererTous($requete); |
| if (!is_array($resultats) || count($resultats) <= 0) { |
| $message = "Les méta-données n'ont pu être chargée pour la ressource demandée"; |
| $code = RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE; |
| throw new Exception($message, $code); |
| } |
| $this->metadonnees = $resultats; |
| } |
| private function definirVersion() { |
| if ($this->parametres['version.projet'] == '+') { |
| $this->version = $this->metadonnees[0]['version']; |
| } else { |
| $this->version = $this->parametres['version.projet']; |
| } |
| } |
| private function chargerOntologies() { |
| $requete = 'SELECT * '. |
| "FROM {$this->tableOntologie} "; |
| $resultats = $this->Bdd->recupererTous($requete); |
| if (!is_array($resultats) || count($resultats) <= 0) { |
| $message = "Les données de légende n'ont pu être chargées pour la ressource demandée"; |
| $code = RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE; |
| throw new Exception($message, $code); |
| } |
| foreach ($resultats as $ontologie) { |
| $this->ontologies[$ontologie['id']] = Commun::extraireComplementsOntologies($ontologie); |
| } |
| } |
| private function chargerLegende() { |
| foreach ($this->ontologies as $ontologie) { |
| if ($ontologie['classe_id'] == self::PRESENCE_CHOROLOGIE) { |
| $this->legende[$ontologie['code']] = $ontologie['legende']; |
| } |
| } |
| } |
| private function chargerPrioritesLegende() { |
| foreach ($this->ontologies as $ontologie) { |
| if ($ontologie['classe_id'] == self::PRESENCE_CHOROLOGIE && isset($ontologie['priorite'])) { |
| $this->priorites[$ontologie['code']] = $ontologie['priorite']; |
| } |
| } |
| } |
| private function chargerDonnees() { |
| $conditions = $this->getConditions(); |
| $requete = 'SELECT * '. |
| "FROM {$this->tableChorodep} ". |
| (isset($conditions) ? 'WHERE '.implode(' AND ', $conditions) : ''); |
| $resultat = $this->Bdd->recupererTous($requete); |
| $this->donnees = $resultat; |
| } |
| private function getConditions() { |
| $conditions = null; |
| if ($nnListe = $this->getListeNumNom()) { |
| $conditions[] = "num_nom IN ($nnListe) "; |
| } |
| if ($ntListe = $this->getListeNumTax()) { |
| $conditions[] = "num_tax IN ($ntListe) "; |
| } |
| return $conditions; |
| } |
| private function getListeNumNom() { |
| $nnListe = null; |
| $refTax = self::CODE_REFTAX_DEFAUT; |
| if (isset($this->taxonsDemandes[$refTax])) { |
| $nnProteges = array(); |
| if (isset($this->taxonsDemandes[$refTax]['nn'])) { |
| foreach ($this->taxonsDemandes[$refTax]['nn'] as $nn) { |
| $nnProteges[] = $this->Bdd->proteger($nn); |
| } |
| $nnListe = implode(',', $nnProteges); |
| } |
| } |
| return $nnListe; |
| } |
| private function getListeNumTax() { |
| $ntListe = null; |
| $refTax = self::CODE_REFTAX_DEFAUT; |
| if (isset($this->taxonsDemandes[$refTax])) { |
| $ntProteges = array(); |
| if (isset($this->taxonsDemandes[$refTax]['nt'])) { |
| foreach ($this->taxonsDemandes[$refTax]['nt'] as $nt) { |
| $ntProteges[] = $this->Bdd->proteger($nt); |
| } |
| $ntListe = implode(',', $ntProteges); |
| } |
| } |
| return $ntListe; |
| } |
| private function genererSVG() { |
| $fichierCarteSvg = $this->cheminCartesBase.self::CARTE_DEFAUT.'.svg'; |
| if (file_exists($fichierCarteSvg) === false) { |
| $message = "Le fichier SVG servant de base à la carte est introuvable : $fichierCarteSvg"; |
| $code = RestServeur::HTTP_CODE_ERREUR; |
| throw new Exception($message, $code); |
| } |
| $dom = new DOMDocument('1.0', 'UTF-8'); |
| $dom->validateOnParse = true; |
| $dom->load($fichierCarteSvg); |
| $racineElement = $dom->documentElement; |
| $racineElement->setAttribute('width', $this->imgLargeur); |
| if ($this->imgHauteur != 0) { |
| $racineElement->setAttribute('height', $this->imgHauteur); |
| } |
| $css = $this->creerCssCarte(); |
| $styleElement = $dom->getElementsByTagName('style')->item(0); |
| $css = $styleElement->nodeValue.$css; |
| $txtCss = $dom->createCDATASection($css); |
| $styleElement->nodeValue = ''; |
| $styleElement->appendChild($txtCss); |
| $titre = $this->creerTitre(); |
| $titreCdata = $dom->createCDATASection($titre); |
| $titreElement = $dom->getElementsByTagName('title')->item(0); |
| $titreElement->nodeValue = ''; |
| $titreElement->appendChild($titreCdata); |
| $taxonTitre = $this->creerTitreTaxon(); |
| $taxonCdata = $dom->createCDATASection($taxonTitre); |
| $xpath = new DOMXPath($dom); |
| $taxonTitreEl = $xpath->query("//*[@id='titre-taxon']")->item(0); |
| $taxonTitreEl->nodeValue = ''; |
| $taxonTitreEl->setAttribute('title', $taxonTitre); |
| $taxonTitreEl->appendChild($taxonCdata); |
| $svg = $dom->saveXML(); |
| return $svg; |
| } |
| private function creerCssCarte() { |
| $css = ''; |
| $this->getZonesPriorites(); |
| $zonesCouleurs = $this->getZonesCouleurs(); |
| foreach ($zonesCouleurs as $couleur => $zonesClasses) { |
| $classes = implode(', ', $zonesClasses); |
| $css .= "$classes{\nfill:$couleur;\n}\n"; |
| } |
| return $css; |
| } |
| private function getZonesPriorites() { |
| $this->zones = array(); |
| $zonesPrioritaires = array(); |
| foreach ($this->donnees as $donnee) { |
| foreach ($donnee as $zoneId => $codeLegende) { |
| if (preg_match('/^[0-9][0-9ab]$/i', $zoneId)) { |
| if (array_key_exists($codeLegende, $this->priorites)) { |
| $priorite = $this->priorites[$codeLegende]; |
| if (array_key_exists($zoneId, $zonesPrioritaires) == false) { |
| $zonesPrioritaires[$zoneId] = 0; |
| } |
| if ($priorite > $zonesPrioritaires[$zoneId]) { |
| $zonesPrioritaires[$zoneId] = $priorite; |
| $this->zones[$zoneId] = $codeLegende; |
| } |
| } |
| } |
| } |
| } |
| } |
| private function getZonesCouleurs() { |
| $zones = array(); |
| ksort($this->zones); |
| foreach ($this->zones as $zoneId => $codeLegende) { |
| if (array_key_exists($codeLegende, $this->legende)) { |
| $couleur = $this->legende[$codeLegende]; |
| $zones[$couleur][] = strtolower('.departement'.sprintf('%02s', $zoneId)); |
| } |
| } |
| return $zones; |
| } |
| private function creerTitre() { |
| $titre = "Carte en cours d'élaboration"; |
| if ($this->donnees != array()) { |
| $titre .= ' pour '.$this->creerTitreTaxon(); |
| } |
| return $titre; |
| } |
| private function creerTitreTaxon() { |
| $titre = ''; |
| $noms = array(); |
| foreach ($this->donnees as $donnee) { |
| $noms[] = $donnee['nom_sci']; |
| } |
| $titre = implode(', ', $noms); |
| return $titre; |
| } |
| private function convertirEnPNG($svg) { |
| $png = null; |
| if (isset($this->convertisseur)) { |
| if ($this->convertisseur == 'imagick') { |
| if (extension_loaded('imagick')) { |
| $png = $this->convertirEnPNGAvecImageMagick($svg); |
| } else { |
| $message = "Impossible de générer l'image sur le serveur. Extension ImageMagick abscente."; |
| $code = RestServeur::HTTP_CODE_ERREUR; |
| throw new Exception($message, $code); |
| } |
| } else if ($this->convertisseur == 'rsvg') { |
| $png = Commun::convertirEnPNGAvecRsvg($this->getIdFichier(), $this->config['cache_stockageChemin'], $svg); |
| } else { |
| $message = "Le convertisseur indiqué '{$this->convertisseur}' ne fait pas parti de la liste ". |
| "des convertisseurs disponibles : imagick, rsvg."; |
| $code = RestServeur::HTTP_CODE_ERREUR; |
| throw new Exception($message, $code); |
| } |
| } else { |
| $message = "Veuillez indiquer le convertisseur de svg à utiliser pour le service."; |
| $code = RestServeur::HTTP_CODE_ERREUR; |
| throw new Exception($message, $code); |
| } |
| return $png; |
| } |
| private function convertirEnPNGAvecImageMagick($svg) { |
| $convertisseur = new Imagick(); |
| $convertisseur->setBackgroundColor(new ImagickPixel('transparent')); |
| $convertisseur->readImageBlob($svg); |
| $convertisseur->setImageFormat('png32'); |
| $convertisseur->resizeImage($this->imgLargeur, $this->imgHauteur, imagick::FILTER_LANCZOS, 0, true); |
| $png = $convertisseur->getImageBlob(); |
| $convertisseur->clear(); |
| $convertisseur->destroy(); |
| return $png; |
| } |
| private function getIdFichier() { |
| $id = ''; |
| foreach ($this->taxonsDemandes as $reftax => $ids) { |
| $id[] = $reftax; |
| foreach ($ids as $type => $vals) { |
| $id[] = $type; |
| $id[] = implode('-', $vals); |
| } |
| } |
| $id = implode('-', $id); |
| return $id; |
| } |
| public function getParametreTableau($cle) { |
| $tableau = array(); |
| $parametre = $this->config[$cle]; |
| if (empty($parametre) === false) { |
| $tableauPartiel = explode(',', $parametre); |
| $tableauPartiel = array_map('trim', $tableauPartiel); |
| foreach ($tableauPartiel as $champ) { |
| if (strpos($champ, '=') === false) { |
| $tableau[] = trim($champ); |
| } else { |
| list($cle, $val) = explode('=', $champ); |
| $tableau[trim($cle)] = trim($val); |
| } |
| } |
| } |
| return $tableau; |
| } |
| } |
| ?> |
| /branches/v5.12-baouque/services/modules/0.1/chorodep/Noms.php |
|---|
| New file |
| 0,0 → 1,164 |
| <?php |
| /** |
| * Retourne la liste des noms répertoriés par le projet chorodep |
| * |
| * @package chorodep |
| * @author Mathias Chouet <mathias@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-2014 Tela Botanica (accueil@tela-botanica.org) |
| */ |
| class Noms extends Commun { |
| protected $serviceNom = 'noms'; |
| protected $table; |
| protected $masque; |
| protected $depart; |
| protected $limite; |
| protected $tri; |
| protected $tri_dir; |
| protected function init() { |
| $this->masque = array(); |
| $this->depart = 0; |
| $this->limite = 20; |
| $this->tri = 'nom_sci'; |
| $this->tri_dir = 'ASC'; |
| $this->traiterVersionProjet(); |
| $this->table = $this->table_version[0]; |
| } |
| /** |
| * Récupère les paramètres de navigation |
| * @param type $parametres |
| */ |
| protected function setDepartLimite($parametres) { |
| if(isset($parametres['navigation.depart']) && $parametres['navigation.depart'] != '') { |
| $this->depart = max(0, intval($parametres['navigation.depart'])); |
| } |
| if(isset($parametres['navigation.limite']) && $parametres['navigation.limite'] != '') { |
| $this->limite = max(0, intval($parametres['navigation.limite'])); |
| } |
| } |
| /** |
| * Récupère les paramètres de filtrage |
| * @param type $parametres |
| */ |
| protected function setMasque($parametres) { |
| if(isset($parametres['masque.nom']) && $parametres['masque.nom'] != '') { |
| $this->masque['nom'] = $parametres['masque.nom']; |
| } |
| if(isset($parametres['masque.zone-geo']) && $parametres['masque.zone-geo'] != '') { |
| $zg = $parametres['masque.zone-geo']; |
| // Tango Corse |
| if ($zg == '2A' || $zg == '2B') { |
| $zg = '20'; |
| } |
| $this->masque['zone-geo'] = $zg; |
| } |
| } |
| /** |
| * Récupère les paramètres de tri |
| * @param type $parametres |
| */ |
| protected function setTri($parametres) { |
| if(isset($parametres['retour.tri']) && $parametres['retour.tri'] != '') { |
| $this->tri = $parametres['retour.tri']; |
| } |
| if(isset($parametres['retour.ordre']) && in_array($parametres['retour.ordre'], array('ASC', 'DESC'))) { |
| $this->tri_dir = $parametres['retour.ordre']; |
| } |
| } |
| public function consulter($ressources, $parametres) { |
| $donnees = array(); |
| $this->setDepartLimite($parametres); |
| $this->setMasque($parametres); |
| $this->setTri($parametres); |
| $noms = $this->listeNoms(); |
| $total = $this->compterNoms(); |
| $url_base = Config::get('url_service'); |
| $masqueEnParams = array(); |
| foreach ($this->masque as $k => $v) { |
| $masqueEnParams[] = 'masque.' . $k . '=' . $v; |
| } |
| $masqueEnParams = implode('&', $masqueEnParams); |
| $donnees['entete'] = array( |
| 'masque' => $masqueEnParams, |
| 'total' => $total, |
| 'depart' => $this->depart, |
| 'limite' => $this->limite |
| ); |
| if ($this->depart > 0) { |
| $donnees['entete']['href.precedent'] = $url_base . '/' . $this->serviceNom . '?' |
| . 'navigation.depart=' . max(0, ($this->depart - $this->limite)) . '&navigation.limite=' . $this->limite |
| . '&retour.tri=' . $this->tri . '&retour.ordre=' . $this->tri_dir |
| . ($masqueEnParams ? '&' . $masqueEnParams : ''); |
| } |
| if (($this->depart + $this->limite) < $total ) { |
| $donnees['entete']['href.suivant'] = $url_base . '/' . $this->serviceNom . '?' |
| . 'navigation.depart=' . ($this->depart + $this->limite) . '&navigation.limite=' . $this->limite |
| . '&retour.tri=' . $this->tri . '&retour.ordre=' . $this->tri_dir |
| . ($masqueEnParams ? '&' . $masqueEnParams : ''); |
| } |
| $donnees['resultat'] = $noms; |
| return $donnees; |
| } |
| /** |
| * Renvoie la liste des noms répertoriés par chorodep; si un masque a été |
| * défini sur une zone géographique, retourne aussi la présence sur cette zone |
| */ |
| protected function listeNoms() { |
| $req = "SELECT DISTINCT num_nom, nom_sci"; |
| if (isset($this->masque['zone-geo']) && $this->masque['zone-geo'] != null) { |
| $req .= ", `" . $this->masque['zone-geo'] . "` as presence"; |
| } |
| $req .= " FROM " . $this->table; |
| $req .= $this->construireWhere(); |
| $req .= " ORDER BY ".$this->tri." ".$this->tri_dir." "; |
| $req .= " LIMIT " . $this->depart . ", " . $this->limite; |
| $resultat = $this->getBdd()->recupererTous($req); |
| return $resultat; |
| } |
| protected function compterNoms() { |
| $req = "SELECT count(DISTINCT num_nom, nom_sci) AS compte FROM " . $this->table; |
| $req .= $this->construireWhere(); |
| $resultat = $this->getBdd()->recuperer($req); |
| return $resultat['compte']; |
| } |
| protected function construireWhere() { |
| $where = ""; |
| $conditions = array(); |
| // élimination des entrées sans nn valide |
| $conditions[] = "CAST(num_nom AS decimal) != 0"; |
| // masque |
| if(!empty($this->masque)) { |
| if(isset($this->masque['nom'])) { |
| $masqueNom = $this->getBdd()->proteger($this->masque['nom']); |
| $conditions[] = "nom_sci LIKE $masqueNom"; |
| } |
| if(isset($this->masque['zone-geo'])) { |
| $masqueZg = $this->masque['zone-geo']; |
| $conditions[] = "`$masqueZg` in ('1', '1?')"; |
| } |
| } |
| $where = " WHERE " . implode(' AND ', $conditions); |
| return $where; |
| } |
| } |
| ?> |
| /branches/v5.12-baouque/services/modules/0.1/chorodep/Observations.php |
|---|
| New file |
| 0,0 → 1,722 |
| <?php |
| /** |
| * Description : |
| * Classe Observations.php permettant de fournir des informations sur les observations. |
| * Si l'url finit par /observations on retourne une liste d'observations (seulement les 100 premières par défaut) : |
| * espèce, lieu, date, observateur. |
| * L'url peut contenir des paramètres optionnels passés après le ? : /observations?param1=val1¶m2=val2&... |
| * |
| * Les paramètres de requête disponibles sont : masque, masque.type (type d'observation : chorologie), |
| * masque.date_observation (date d'observation), masque.station (département), masque.determination (nom scientifique de l'espèce) |
| * masque.observateur (prénom, nom), masque.nn (identifiant du nom), recherche, distinct, retour.format, |
| * navigation.depart et navigation.limite. |
| * |
| * Encodage en entrée : utf8 |
| * Encodage en sortie : utf8 |
| * @package framework-v3 |
| * @author Delphine Cauquil <delphine@tela-botanica.org> |
| * @author Jennifer Dhé <jennifer.dhe@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-${year} Tela Botanica (accueil@tela-botanica.org) |
| */ |
| class Observations extends Commun { |
| protected $serviceNom = 'observations'; |
| /** Stockage des paramétres */ |
| protected $table_param = array(); |
| /** Valeur du paramètre de requete recherche : |
| * - stricte : le masque est passé tel quel à l'opérateur LIKE. |
| * - etendue : ajout automatique du signe % à la place des espaces et en fin de masque avec utilisation de LIKE. |
| * - floue : recherche tolérante vis-à-vis d'approximations ou d'erreurs (fautes d'orthographe par exemple) */ |
| protected $recherche = 'stricte'; |
| /** Valeur du paramètre de requete distinct (=0|1) |
| * Indique que l'on veut les noms distincts (par défaut tous les noms, même semblable, sont renvoyés) */ |
| protected $distinct = null; |
| protected $retour_format = 'max'; |
| protected $presenceChorologie = ''; |
| /** Variables constituant les parametres de la requete SQL (champ, condition, group by, limit) remplie |
| * selon ressources et paramètres */ |
| protected $requete_champ = ' id, num_nom, nom_sci '; |
| protected $requete_condition = array(); |
| /** Une observation est défini par départ qui correspont à un num_nom et dept qui correspond à un departement */ |
| protected $limite_requete = array( |
| 'depart' => 0, |
| 'dept' => 01, |
| 'limite' => 20 |
| ); |
| /** |
| * Permet de stocker la requete formulée : |
| * - noms | noms/#id | noms/#id/#champ+#champ |
| * - noms/#id/relations | noms/#id/relations/synonymie | noms/#id/relations/homonymie | noms/#id/relations/flores |
| * - noms/stats/rangs | noms/stats/annees | noms/stats/initiales |
| * Est remplit au cours de l'analyse des ressources (traiterRessources()). |
| * Est utilisée principalement pr déterminer le format du tableau à retourner. |
| */ |
| protected $format_reponse = 'observations'; |
| // +-------------------------------------------------------------------------------------------------------------------+ |
| public function consulter($ressources, $parametres) { |
| $this->parametres = $parametres; |
| $this->traiterVersionProjet($ressources); |
| $this->traiterRessources($ressources); |
| $resultat_formate = ''; |
| if ($this->corps_http == '' && $this->entete_http == '') { |
| foreach ($this->table_version as $version) { |
| $this->table = $version; //on stocke le nom de la table correspondant à la version du projet en cours |
| $this->traiterParametres($parametres); |
| $requete = $this->assemblerLaRequete(); //print_r($requete); |
| $resultat = $this->getBdd()->recupererTous($requete); |
| $res_version = $this->testerResultat($resultat, $requete); |
| } |
| if ($this->corps_http == '' && $this->entete_http == '') { |
| if (isset($res_version)) { |
| $resultat_formate = $res_version; |
| } |
| } |
| } |
| return $resultat_formate; |
| } |
| public function testerResultat($resultat, $requete) { |
| if ($resultat == '') { //cas ou la requete comporte des erreurs |
| $s = 'La requête SQL resultat formée comporte une erreur !!'; |
| Debug::printr($requete); |
| $this->renvoyerErreur(RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE, $s); |
| } elseif ($resultat) { |
| if (count($this->table_version) > 1) { |
| $res_version[$version] = $this->retournerResultatFormate($resultat); |
| } else { |
| $res_version = $this->retournerResultatFormate($resultat); |
| } |
| } else { |
| if ($this->format_reponse == 'zone-geo/id/relations') { |
| //si aucune relations n'existe, la valeur null est retournée |
| $res_version = null; |
| } else { |
| $d = 'Données recherchées introuvables dans la base'.$requete; |
| $this->renvoyerErreur(RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE, $d); |
| Debug::printr($requete); |
| } |
| } |
| return $res_version; |
| } |
| public function assemblerLaRequete() { |
| $requete = "SELECT ".$this->formerRequeteChamp(). |
| " FROM ".$this->table.$this->formerRequeteCondition(). |
| ' LIMIT '.$this->limite_requete['depart'].', '.$this->limite_requete['limite'];//echo $requete; |
| return $requete; |
| } |
| public function formerRequeteChamp() { |
| if (!isset($this->table_ressources)) { |
| if (!isset($this->table_param['masque_station']) && !isset($this->table_param['masque_contributeur']) ) { |
| $champ = ' * '; |
| } else { |
| $champ = $this->requete_champ; |
| } |
| } else { |
| $champ = $this->requete_champ; |
| } |
| return $champ; |
| } |
| public function formerRequeteCondition() { |
| $condition = ''; |
| if ($this->requete_condition != null) { |
| $condition = ' WHERE '.implode(' AND ', $this->requete_condition); |
| } |
| return $condition; |
| } |
| // +-------------------------------------------------------------------------------------------------------------------+ |
| public function traiterRessources(&$ressources) { |
| if (isset($ressources) && !empty($ressources)) { |
| $this->table_ressources = $ressources; |
| if (isset($this->table_ressources[0]) && !empty($this->table_ressources[0])) { |
| $this->traiterRessourceId(); |
| if (isset($this->table_ressources[1]) && !empty($this->table_ressources[1])) { |
| $this->traiterRessourceChamp; |
| } |
| } |
| } |
| } |
| public function traiterRessourceId() { |
| //requete : /observations/#num_nom:#dept (ex : /observations/10:34) |
| if (preg_match('/^([0-9]*):([0-9]{2})$/', $this->table_ressources[0], $conditions)) { |
| $this->requete_condition[] = ' num_nom = '.$this->getBdd()->proteger($conditions[1]).' AND `'.$conditions[2]."` != '' "; |
| $this->requete_champ .= ' ,catminat, rang, num_tax, freq_abs, freq_rel, rare_nat, `'.$conditions[2].'`'; |
| $this->format_reponse .= '/id'; |
| //requete : /observations/nom:#dept (ex : /observations/coquelicot:30) |
| } elseif (preg_match('/^(.*):([0-9]{2})$/', $this->table_ressources[0], $conditions)) { |
| $this->requete_condition[] = ' nom_sci like '.$this->getBdd()->proteger($conditions[1].'%').' AND `'.$conditions[2]."` != '' "; |
| $this->requete_champ .= ' ,catminat, rang, num_tax, freq_abs, freq_rel, rare_nat, `'.$conditions[2].'`'; |
| $this->format_reponse .= '/id'; |
| //requete : /observations/num_nom:#num_nom (ex : /observations/num_nom:290) ?? |
| } elseif (strrpos($this->table_ressources[0], ':') !== false) { |
| } else { |
| $r = 'Erreur dans les ressources de votre requête : </br> La ressource " '.$this->table_ressources[0]. |
| ' " n\'existe pas.'; |
| $this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $r); |
| } |
| } |
| // +-------------------------------------------------------------------------------------------------------------------+ |
| public function traiterParametres($parametres) { |
| if (isset($parametres) && !empty($parametres)) { |
| $this->table_param = $parametres; |
| if (isset($parametres['recherche']) && $parametres['recherche'] != '') { |
| $this->recherche = $parametres['recherche']; |
| } |
| foreach ($parametres as $param => $valeur) { |
| switch ($param) { |
| case 'masque' : $this->ajouterLeFiltreMasque($valeur); break; |
| case 'masque.date.observation' : break; |
| case 'masque.station' : $this->limite_requete['dept'] = $valeur; |
| $this->ajouterUnFiltre('station', $valeur); break; |
| case 'masque.departement' : |
| $this->ajouterUnFiltre("`".$valeur."`", '1'); break; |
| case 'masque.determination' : $this->ajouterUnFiltre('nom_sci', $valeur); break; |
| case 'masque.determination.nn' : |
| $this->requete_condition[] = '`num_nom` = '.$this->getBdd()->proteger($valeur); break; |
| case 'masque.determination.nt' : |
| $this->requete_condition[] = '`num_tax` = '.$this->getBdd()->proteger($valeur); break; case 'masque.observateur' : $this->ajouterLeFiltreContributeur($valeur); break; |
| case 'masque.valeur' : $this->presenceChorologie = $valeur; break; |
| case 'retour.format' : $this->retour_format = $valeur; break; |
| case 'navigation.depart' : $this->ajouterLimiteDepart($valeur); break; |
| case 'navigation.limite' : if ($valeur !== '') $this->limite_requete['limite'] = $valeur; break; |
| case 'recherche' : break; |
| case 'version.projet' : break; |
| default : $p = 'Erreur dans les paramètres de recherche de votre requête : '. |
| '</br> Le paramètre " '.$param.' " n\'existe pas.'; |
| $this->renvoyerErreur(RestServeur::HTTP_CODE_MAUVAISE_REQUETE, $p); break; |
| } |
| } |
| } |
| } |
| /** fonction d'ajout dans la requete SQL des conditions (WHERE ...) en fonctions des parametres demandés |
| * @param $nom_champ |
| * @param $valeur |
| * @param $masque |
| */ |
| public function ajouterUnFiltre($nom_champ, $valeur) { |
| if ($nom_champ == 'station') { |
| if (!preg_match('/^\s*([0-9]{2})\s*$/', $valeur, $colonne)) { // si le nom est passé |
| $this->requete_condition[] = '1'; |
| } else { |
| $this->requete_condition[] = '`'.$valeur."` != '' "; |
| $this->requete_champ .= ', `'.$valeur.'` '; |
| } |
| } else { |
| // recherche floue |
| if ($this->recherche == 'floue') {//ajout_soundex |
| $this->requete_condition[] = '(SOUNDEX('.$nom_champ.') = SOUNDEX(\''.$valeur.'\')' |
| .' OR SOUNDEX(REVERSE('.$nom_champ.')) = SOUNDEX(REVERSE(\''.$valeur.'\'))) '; |
| // recherche étendue |
| } elseif ($this->recherche == 'etendue') { |
| $valeur = str_replace(' ','%', $valeur); |
| $valeur .= '%'; |
| } |
| // recherche stricte |
| $this->requete_condition[] = $nom_champ.' LIKE '.$this->getBdd()->proteger($valeur); |
| } |
| } |
| /** fonction d'ajout dans la requete SQL des conditions (WHERE ...) quand le paramètre passé est masque |
| * @param $valeur |
| */ |
| public function ajouterLeFiltreMasque($valeur) { |
| $this->ajouterUnfiltre('station', $valeur); |
| $condition = '(( '.array_pop($this->requete_condition); |
| $this->ajouterUnfiltre('num_nom', $valeur); |
| $condition .= ' ) OR ('.array_pop($this->requete_condition); |
| $condition = str_replace('( 1 ) OR', '', $condition); // si la valeur passée est une varchar supprime le filtre station |
| $this->ajouterUnfiltre('nom_sci', $valeur); |
| $this->requete_condition[] = $condition.' ) OR ('.array_pop($this->requete_condition).' )) '; |
| } |
| /** fonction d'ajout dans la requete SQL des conditions (WHERE ...) quand le paramètre passé est masque.contributeur |
| * @param $valeur |
| */ |
| public function ajouterLeFiltreContributeur($valeur) { |
| $requete_contr = $this->creerRequeteContributeur($valeur); |
| $res = $this->getBdd()->recupererTous($requete_contr); |
| if ($res == '') { //cas ou la requete comporte des erreurs |
| $c = 'La requête SQL formée comporte une erreur !!'; |
| $this->renvoyerErreur(RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE, $c); |
| Debug::printr($requete_contr); |
| } elseif ($res) { |
| unset($res[0]['id'],$res[0]['nom'],$res[0]['prenom'],$res[0]['courriel']); |
| // si il y a un masque station et que le contributeur n'a pas de données dans ce dept |
| if (isset($this->table_param['masque_station']) && isset($res[0][$this->table_param['masque_station']])) { |
| if ($res[0][$this->table_param['masque_station']] != 1) { |
| $d = "Les données recherchées sont introuvables pour l'observateur ".$valeur." dans le département " |
| .$this->table_param['masque_station']; |
| $this->renvoyerErreur(RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE, $d); |
| } |
| } else { |
| foreach ($res[0] as $dept=>$presence) { |
| if ($presence == 1) { |
| $this->ajouterUnfiltre('station', $dept); |
| $requete_condition[] = array_pop($this->requete_condition); // recupere le filtre créé précédement |
| } |
| } |
| $this->requete_condition[] = '(( '.implode(' ) OR ( ', $requete_condition).' ))'; // créé un filtre sur les dept |
| } |
| } else { |
| $i = "Les données recherchées sont introuvables pour l'observateur ".$valeur; |
| $this->renvoyerErreur(RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE, $i); |
| } |
| } |
| public function creerRequeteContributeur($valeur) { |
| $condition = ''; |
| if (preg_match('/(.*@[a-z]+\.[a-z]{2,3})/', $valeur, $match)) {// cherche sur le mail |
| $condition = 'courriel = '.$this->getBdd()->proteger($match[1]); |
| } elseif (preg_match('/^(\w+)\s+(\w+)$/', $valeur, $match)) {// cherche sur les nom prenom |
| $condition = ' ((nom = '.$this->getBdd()->proteger($match[1]).' OR prenom = '.$this->getBdd()->proteger($match[1]). |
| ' ) AND (nom = '.$this->getBdd()->proteger($match[2]).' OR prenom = '.$this->getBdd()->proteger($match[2]).'))'. |
| ' OR ( nom LIKE '.$this->getBdd()->proteger($valeur.'%').')'; |
| } else {// cherche si nom association |
| $condition = 'nom LIKE '.$this->getBdd()->proteger($valeur.'%'); |
| } |
| list($table, $version) = explode('_v',$this->table); |
| $requete_contr = "SELECT * FROM chorodep_contributeurs_v$version WHERE ".$condition; |
| } |
| /** |
| * @param type $id un offset ou une combinaison de la forme "num_nom:departement" |
| */ |
| public function ajouterLimiteDepart($id) { |
| if ($id !== '') { |
| // $id est de la forme nn:dept - wtf ? en plus ça marche pas, le lien |
| // "href.suivant" génère du caca d'oie |
| $d = explode(":", $id); |
| if (count($d) == 2) { |
| $this->limite_requete['depart'] = 0; |
| $this->limite_requete['dept'] = $d[1]; |
| if (!isset($this->parametres['masque.determination.nn'])) { |
| $requete_condition = (is_numeric($d[0])) ? '`num_nom` = '.$d[0] : '`nom_sci` like "'.urldecode($d[0]).'%"'; |
| $requete = "SELECT id FROM $this->table WHERE ".$requete_condition; |
| $res = $this->getBdd()->recuperer($requete); |
| if ($res == '') { //cas ou la requete comporte des erreurs |
| $r = 'La requête SQL formée comporte une erreur !!'; |
| $this->renvoyerErreur(RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE, $r); |
| Debug::printr($requete); |
| } elseif ($res) { |
| $this->limite_requete['depart'] = $res['id'] - 1; |
| } else { |
| $i = "Les données recherchées sont introuvables"; |
| $this->renvoyerErreur(RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE, $i); |
| } |
| } |
| } else { |
| // $id est un simple offset |
| $this->limite_requete['depart'] = $id; |
| } |
| } |
| } |
| // +-------------------------------------------------------------------------------------------------------------------+ |
| public function retournerResultatFormate($resultat) { |
| $this->table_retour = array(); // stocke les données générales d'une observation et écrase les données d'un dep |
| $this->chargerInfosGenerales(); |
| switch ($this->format_reponse) { |
| case 'observations' : $reponse = $this->formaterObservations($resultat); break; |
| case 'observations/id' : $reponse = $this->formaterObservationsId($resultat[0]); break; |
| case 'observations/id/champ': $reponse = $this->formaterObservationsIdChamp($resultat[0]); break; |
| default : break; |
| } |
| return $reponse; |
| } |
| public function formaterObservations($resultat) { |
| $num = 0; // compte le nombre d'observations pour retourner le nombre d'obs indiqué |
| $depart = false; //le depart du resultat est noté ss forme #ligne:#departement $depart indique le departement est correct |
| //on remplit la table $table_retour_json['resultat'] |
| $this->table_retour = array(); |
| foreach ($resultat as $tab) { |
| foreach ($tab as $key => $valeur) { |
| switch ($key) { |
| case 'id' : break; |
| case 'catminat' : break; |
| case 'rang' : break; |
| case 'num_tax' : break; |
| case 'freq_abs' : break; |
| case 'freq_rel' : break; |
| case 'rare_nat' : break; |
| case 'num_nom' : ($valeur == 'nc')? $num_nom = urlencode($tab['nom_sci']) : $num_nom = $valeur ; break; |
| case 'nom_sci' : $this->table_retour['determination.nom_sci'] = $valeur; break; |
| default : // pour les depts |
| if (isset($this->parametres['masque.station'])) { |
| if ($key == $this->parametres['masque.station']) { |
| $id = $num_nom.":".$key; |
| $this->completerDonnees($key, $valeur, $id); |
| $resultat_json[$id] = $this->table_retour; |
| $num++; |
| } |
| } else { |
| if ($depart == true && $valeur != '') { |
| if (($this->presenceChorologie != '' && $valeur == $this->presenceChorologie) || |
| ($this->presenceChorologie == '' && $valeur != $this->presenceChorologie)) { |
| $id = $num_nom.":".$key; |
| $this->completerDonnees($key, $valeur, $id); |
| $resultat_json[$id] = $this->table_retour; |
| $num++; |
| } |
| } |
| if ($key == $this->limite_requete['dept']) $depart = true; |
| } |
| break; |
| } |
| if ($num == $this->limite_requete['limite']) { |
| break; |
| } |
| } |
| if ($num == $this->limite_requete['limite']) { |
| break; |
| } |
| $this->table_retour = array(); |
| } |
| //on remplit la table $table_retour_json['entete'] |
| // Mode moderne rétrocompatible : les départ sont toujours de simples offsets |
| if (strpos($this->limite_requete['depart'], ':') === false) { |
| $id = $this->limite_requete['depart'] + $this->limite_requete['limite']; |
| } |
| //formuler les urls precedentes et suivantes affichées dans l'entete du resultat |
| $url = $this->formulerUrlObs($id, $num, '/observations'); |
| if ($url['precedent'] != '') { $this->table_entete['href.precedent'] = $url['precedent']; } |
| if ($url['suivant'] != '') { $this->table_entete['href.suivant'] = $url['suivant']; } |
| $this->table_entete['total'] = $num; |
| $table_retour_json['entete'] = $this->table_entete; |
| $table_retour_json['resultat'] = $resultat_json; |
| return $table_retour_json; |
| } |
| public function completerDonnees($key, $valeur, $id) { |
| if ($this->retour_format == 'max' ) { |
| $this->afficherDonneesMax($key, $valeur); |
| $this->table_retour['href'] = $this->ajouterHref('observations',$id); |
| } else { |
| $this->table_retour['station.departement.code'] = 'INSEE-D.'.$key; |
| $this->table_retour['valeur.code'] = $valeur; |
| } |
| } |
| public function formaterObservationsId($resultat) { |
| foreach ($resultat as $key => $valeur) { |
| switch ($key) { |
| case 'id' : break; |
| case 'catminat' : if ($this->retour_format == 'max') $this->table_retour['determination.catminat'] = $valeur; break; |
| case 'rang' : $this->table_retour['determination.rang'] = $valeur; break; |
| case 'num_tax' : $this->table_retour['determination.num_tax'] = $valeur; break; |
| case 'freq_abs' : break; |
| case 'freq_rel' : break; |
| case 'rare_nat' : $this->table_retour['determination.rarete_nationale.code'] = $valeur; break; |
| case 'nom_sci' : $this->table_retour['determination.nom_sci'] = $valeur; break; |
| case 'num_nom' : $this->table_retour['determination.num_nom'] = $valeur; break; |
| default : if ($this->retour_format == 'max') { |
| $this->afficherDonneesMax($key, $valeur, true); |
| } else { |
| $this->table_retour['station.departement.code'] = 'INSEE-D.'.$key; |
| $this->table_retour['valeur.code'] = $valeur; |
| } break; |
| } |
| } |
| return $this->table_retour; |
| } |
| public function afficherDonneesMax($key, $valeur, $id = false) { |
| if ($key != 20) { //à part la Corse |
| $url_dep = $this->ajouterHrefAutreProjet('zone-geo','',$key, 'insee-d'); |
| $dep = $this->consulterHref($url_dep); |
| if (isset($dep)) { |
| $this->table_retour['station.departement'] = $dep->nom; |
| $this->table_retour['station.departement.code'] = 'INSEE-D.'.$key; |
| $this->table_retour['station.departement.href'] = $url_dep; |
| } else { |
| $this->table_retour['station.departement.code'] = 'INSEE-D.'.$key; |
| } |
| } else { |
| $this->table_retour['station.departement.code'] = 'INSEE-D.'.$key; |
| } |
| //double encodage des paramétres contre validation de Apache |
| $url_val = $this->ajouterHref('ontologies', 'presenceChorologie:'.urlencode(urlencode($valeur))); |
| $val = $this->consulterHref($url_val); |
| $this->table_retour['valeur'] = $val->nom; |
| $this->table_retour['valeur.code'] = $valeur; |
| $this->table_retour['valeur.href'] = $url_val; |
| if ($this->format_reponse == 'observations/id') { // si on est |
| $contr = $this->chargerContributeurs($key); |
| if (isset($contr['general'])) { |
| $this->table_retour['contributeur'] = $contr['general']; |
| $this->table_retour['contributeur.details'] = $contr['details']; |
| } |
| $source = $this->chargerSources($key); |
| if (isset($source['general'])) $this->table_retour['sources'] = $source['general']; |
| if (isset($source['autres'])) $this->table_retour['sources.autres'] = $source['autres']; |
| } |
| } |
| public function chargerInfosGenerales() { |
| list($table, $version) = explode('_v',$this->table); |
| $version = str_replace('_', '.', $version); |
| $requete = "SELECT createurs, date_creation FROM chorodep_meta WHERE version = \"$version\";"; |
| $resultat = $this->getBdd()->recuperer($requete); //Debug::printr($resultat); |
| if ($resultat == '') { //cas ou la requete comporte des erreurs |
| $r = 'La requête SQL metadonnees formée comporte une erreur !!'; |
| $this->renvoyerErreur(RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE, $r); |
| Debug::printr($requete); |
| } elseif ($resultat) { |
| $this->table_retour['type'] = 'chorologie'; |
| $this->table_retour['date_observation'] = $resultat['date_creation']; |
| $this->table_retour['observateur.details'] = $this->traiterChampFormateDCSV($resultat['createurs']); |
| } |
| } |
| public function chargerContributeurs($dept) { |
| $contributeur = array(); |
| list($table, $version) = explode('_v',$this->table); |
| $requete = "SELECT prenom, nom, courriel FROM chorodep_contributeurs WHERE `$dept` = '1';"; |
| $resultat = $this->getBdd()->recupererTous($requete); //Debug::printr($resultat); |
| if ($resultat == '') { //cas ou la requete comporte des erreurs |
| $r = 'La requête SQL contributeurs formée comporte une erreur !!'; |
| $this->renvoyerErreur(RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE, $r); |
| Debug::printr($requete); |
| } elseif ($resultat) { |
| $contributeur['general'] = ''; |
| foreach ($resultat as $res) { |
| $contributeur['general'] .= $res['prenom'].' '.$res['nom'].', '; |
| foreach ($res as $cle => $valeur) { |
| if ($valeur == "") { |
| unset($res[$cle]); |
| } |
| } |
| $type = ($res['prenom'] == '') ? 'o' : 'p'; |
| $url = $this->ajouterHrefAutreProjet('ontologies', 'contactType:', $type, 'eflore'); |
| $val = $this->consulterHref($url); |
| $res['type'] = $val->nom; |
| $res['type.code'] = $type; |
| $res['type.href'] = $url; |
| $contributeur['details'][] = $res; |
| } |
| } |
| return $contributeur; |
| } |
| // prend en paramètre un champ comme createur, contributeur... sous forme p.prenom=ygggg,p.nom=fk;p.prenom=fdfs,p.nom=ek |
| //retourne un tableau |
| public function creerPointDetails($resultat) { |
| $organismes = explode(';', $resultat); |
| $num_org = 1; |
| $general = ''; |
| foreach ($organismes as $organisme) { |
| $infos = explode(',', $organisme); |
| $t = ''; |
| $type = '.'; |
| foreach ($infos as $info) { |
| list($key, $val) = explode('=', $info); |
| list($type, $champ) = explode('.', trim($key)); |
| if ($type == 'p' && $champ == 'prenom') $general .= $val.' '; |
| if (($type == 'p' || $type == 'o') && $champ == 'nom') $general .= $val.' '; |
| $res[$num_org][$champ] = $val; |
| $res[$num_org]['type'] = $type;// à modifier |
| } |
| $general = rtrim($general).', '; |
| $num_org ++; |
| } |
| $this->table_retour['observateur'] = rtrim($general, ', '); |
| $this->table_retour['observateur.details'] = $res; |
| } |
| /** |
| * Recupère à partir de la valeur du champ les différentes informations séparées par ';' (stocke ds un tableau) |
| * pour éditeurs, créateurs, contributeurs,... |
| * (ex : nom=Tela Botanica,guid=urn:lsid:tela-botanica.org,courriel=accueil@tela-botanica.org,... |
| */ |
| public function traiterChampFormateDCSV($val) { |
| $tab = array(); |
| $num_entite = 0; |
| $type = ''; |
| // découpe chaque participant |
| $tab_entites = explode(';', $val); |
| foreach ($tab_entites as $entite) { |
| $tab[$num_entite] = array(); |
| if ($entite != '') { |
| // découpe les informations du participant |
| $entite_detail = explode(',', $entite); |
| foreach ($entite_detail as $detail) { |
| if ($detail != '') { |
| if (preg_match('/^([^=]*)\.([^=]+)=([^=]*)$/', $detail, $match)) { |
| $tab[$num_entite][$match[2]] = $match[3]; |
| if ($match[1] != $type) $type = $match[1]; |
| } else { |
| $tab[$num_entite][] = $detail; |
| } |
| } |
| } |
| if ($type != '') { |
| if ($this->retour_format == 'max') { |
| } |
| } |
| } |
| $num_entite++; |
| } |
| return $tab; |
| } |
| public function chargerSources($dept) { |
| $contributeur = array(); |
| $requete = "SELECT biblio FROM chorodep_sources WHERE `$dept` = '1';"; |
| $resultat = $this->getBdd()->recupererTous($requete); //Debug::printr($resultat); |
| if ($resultat == '') { //cas ou la requete comporte des erreurs |
| $r = 'La requête SQL sources formée comporte une erreur !!'; |
| $this->renvoyerErreur(RestServeur::HTTP_CODE_RESSOURCE_INTROUVABLE, $r); |
| Debug::printr($requete); |
| } elseif ($resultat) { |
| foreach ($resultat as $cle=>$res) { |
| if ($cle == 0) { |
| $contributeur['general'] = $res['biblio']; |
| } else { |
| $contributeur['autres'][] = $res['biblio']; |
| } |
| } |
| } |
| return $contributeur; |
| } |
| /* public function formaterObservationsIdChamp($resultat) { |
| //on recupère tous les resultats possibles |
| $reponse = $this->formaterObservationsId($resultat); |
| $this->table_retour = array(); |
| //on recupère les résultats demandés à partir du tableau de résultat complet |
| $this->table_retour['id'] = $reponse['id']; |
| $champs = explode(' ', $this->table_ressources[1]); |
| foreach ($champs as $champ) { |
| if ($this->verifierValiditeChamp($champ, $reponse)) { |
| if (strrpos($champ, '.*') !== false) { |
| $this->afficherPointEtoile($champ, $reponse); |
| } else { |
| if (isset($reponse[$champ])) { |
| $this->table_retour[$champ] = $reponse[$champ]; |
| } else { |
| $this->table_retour[$champ] = null; |
| } |
| } |
| } |
| } |
| return $this->table_retour; |
| }*/ |
| // +-------------------------------------------------------------------------------------------------------------------+ |
| /** |
| * Description : |
| * Est appelée pour former l'url complete des resultats precedants ou suivants. |
| * @param int : Permet de connaitre le nombre de noms obtenus par la requete |
| * @return string Retourne l'url complete des resultats precedents ou suivant sous la forme d'un tableau |
| */ |
| public function formulerUrlObs($suivant, $total, $id = null) { |
| $debut_url = Config::get('url_service').$id.'?'; |
| //on recrée l'url sans les parametres de navigation qui seront rajouter ci-apres. On les enlève dc de la table des parametres |
| $table_bis = $this->table_param; |
| if (isset($table_bis['navigation.depart'] )) { |
| unset($table_bis['navigation.depart']); |
| } |
| if (isset($table_bis['navigation.limite'])) { |
| unset($table_bis['navigation.limite']); |
| } |
| $parametre_url = http_build_query($table_bis); |
| //on recupere les limites |
| $url['suivant'] = $this->recupererLesLimitesSuivantesObs($suivant, $total); |
| $url['precedent'] = $this->recupererLesLimitesPrecedentesObs($suivant); |
| //on reconstitue les deux urls avec leurs limites |
| foreach ($url as $key => $limite) { |
| if ($limite != '') { |
| if ($parametre_url == '') { |
| //si il n'y a aucun parametres, seules les limites sont à ajouter.On enleve dc le signe & du début |
| $limite = str_replace('&navigation.depart=', 'navigation.depart=', $limite); |
| if (strpos($limite, 'navigation.depart') === false) { |
| $limite = str_replace('&navigation.limite=', 'navigation.limite=', $limite); |
| } |
| } |
| $url_complete = $debut_url.$parametre_url.$limite; |
| $url[$key] = $url_complete; |
| } |
| } |
| return $url; |
| } |
| /** |
| * Description : |
| * Permet de former les limites de la requete retournant les résultats suivants. |
| * Cette url sera afficher dans l'entete de la reponse retournée en format JSON (retour.format=defaut). |
| * @param int : $nb_resultat : Permet de connaitre le nombre de résultats obtenus par la requete |
| * @return string : la fin de l'url decrivant les limites des resultats suivants. Si aucun résultats ne suient, |
| * une chaine de caractère vide est retournée |
| */ |
| public function recupererLesLimitesSuivantesObs($suivant, $total) { |
| if ($this->limite_requete['limite'] <= $total) { |
| $url_suivante = '&navigation.depart='.$suivant.'&navigation.limite='.$this->limite_requete['limite']; |
| } else { |
| $url_suivante = ''; |
| } |
| return $url_suivante; |
| } |
| /** |
| * Description : |
| * Permet de former les limites de la requete retournant les résultats precedents. |
| * Cette url sera afficher dans l'entete de la taxons/105reponse retournée en format JSON (retour.format=defaut) |
| * @return string : la fin de l'url decrivant les limites des resultats precedents. |
| * Si aucun résultats ne precedent, une chaine de caractère vide est retournée |
| */ |
| public function recupererLesLimitesPrecedentesObs($suivant) { |
| $url_precedente = ''; |
| // tentative de fonctionnement normal |
| if (strpos($this->limite_requete['depart'], ':') === false && $this->limite_requete['depart'] != 0) { |
| $departPrec = max(0, $this->limite_requete['depart'] - $this->limite_requete['limite']); |
| $url_precedente = "&navigation.depart=$departPrec&navigation.limite=" . $this->limite_requete['limite']; |
| } |
| if (isset($this->table_param['navigation_depart'])) { // si on utilise un parametre de départ |
| // si l'adresse d'appel de la page est inférieur au départ |
| $regex = '/http:\/\/.*\/service:eflore:0.1\/chorodep\/observations\?.*navigation.depart=(.*\:[0-9]*).*/'; |
| if (isset($_SERVER['HTTP_REFERER']) && preg_match($regex, $_SERVER['HTTP_REFERER'], $match)) { |
| if ($match[1] != $this->table_param['navigation_depart'] && $match[1] != $suivant) { |
| $url_precedente = '&navigation.depart='.$match[1].'&navigation.limite='.$this->limite_requete['limite']; |
| } |
| } else { |
| $url_precedente = '&navigation.limite='.$this->limite_requete['limite']; |
| } |
| } |
| return $url_precedente; |
| } |
| } |
| ?> |
| /branches/v5.12-baouque/services/modules/0.1/chorodep/NomsPlus.php |
|---|
| New file |
| 0,0 → 1,154 |
| <?php |
| /** |
| * Retourne la liste des noms de répertoriés par le projet chorodep, associés à la liste de |
| * leurs statuts de protection, la liste de leurs noms vernaculaires, et leur présence, utile |
| * surtout dans le cas où on filtre par zone géo. |
| * Merci Monsieur Plus ! |
| * Paramètres : |
| * - masque.nom : un LIKE sera effectué sur le nom |
| * - masque.zone-geo : limite les résultats aux noms des espèces présentes dans le département (nombre à 2 chiffres) spécifié |
| * - masque.proteges : si '0' retourne les protections NULL, si '1' les NOT NULL |
| * |
| * @package chorodep |
| * @author Mathias Chouet <mathias@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-2014 Tela Botanica (accueil@tela-botanica.org) |
| */ |
| class NomsPlus extends Noms { |
| protected $tableNomsVernaculaires; |
| protected $tableStatutsProtection; |
| protected function init() { |
| parent::init(); |
| $this->tableNomsVernaculaires = Config::get('table_chorologie_nv'); |
| $this->tableStatutsProtection = Config::get('table_chorologie_sp'); |
| $this->serviceNom = 'noms-plus'; |
| } |
| protected function setMasque($parametres) { |
| parent::setMasque($parametres); |
| // masque sur protection |
| if(isset($parametres['masque.proteges']) && $parametres['masque.proteges'] != '') { |
| $this->masque['proteges'] = $parametres['masque.proteges']; |
| } |
| } |
| /** |
| * Renvoie la liste des taxons, les noms vernaculaires et statuts de protacion associés; si |
| * un masque a été défini sur une zone géographique, retourne aussi la présence sur cette zone |
| */ |
| protected function listeNoms() { |
| $req = "SELECT DISTINCT c.num_nom, c.nom_sci, group_concat(DISTINCT nv.nom_vernaculaire) as noms_vernaculaires"; |
| if (isset($this->masque['zone-geo']) && $this->masque['zone-geo'] != null) { |
| $req .= ", max(`" . $this->masque['zone-geo'] . "`) as presence"; |
| } |
| $req .= ", sp.protection"; |
| $req .= " FROM " . $this->table . " c"; |
| $req .= " LEFT JOIN " . $this->tableNomsVernaculaires . " nv"; |
| $req .= " ON c.num_tax = nv.num_tax"; |
| $req .= " LEFT JOIN " . $this->tableStatutsProtection . " sp"; |
| $req .= " ON c.num_nom = sp.num_nom"; |
| $req .= $this->construireWhere(); |
| $req .= " GROUP BY c.num_nom"; |
| $req .= " ORDER BY " . $this->tri . " " . $this->tri_dir . " "; |
| $req .= " LIMIT " . $this->depart. ", " . $this->limite; |
| //echo "REQUETE: $req"; exit; |
| $resultat = $this->getBdd()->recupererTous($req); |
| // décodage des statuts de protection |
| foreach ($resultat as $k => $r) { |
| $resultat[$k]['statuts_protection'] = json_decode($r['protection']); |
| unset($resultat[$k]['protection']); |
| } |
| return $resultat; |
| } |
| protected function compterNoms() { |
| $req = "SELECT count(DISTINCT c.num_nom, c.nom_sci) AS compte" |
| . " FROM " . $this->table . " c" // alias pour compatibilité avec le where |
| . " LEFT JOIN " . $this->tableStatutsProtection . " sp" // jointure pour compatibilité avec le where |
| . " ON c.num_nom = sp.num_nom"; |
| $req .= $this->construireWhere(); |
| $resultat = $this->getBdd()->recuperer($req); |
| return $resultat['compte']; |
| } |
| protected function construireWhere() { |
| $where = ""; |
| $conditions = array(); |
| // élimination des entrées sans nn valide |
| $conditions[] = "CAST(c.num_nom AS decimal) != 0"; |
| // masque |
| if(!empty($this->masque)) { |
| $masqueZg = null; |
| if(isset($this->masque['nom'])) { |
| $masqueNom = $this->getBdd()->proteger($this->masque['nom']); |
| $conditions[] = "c.nom_sci LIKE $masqueNom"; |
| } |
| if(isset($this->masque['zone-geo'])) { |
| $masqueZg = $this->masque['zone-geo']; |
| $conditions[] = "`$masqueZg` in ('1', '1?')"; |
| } |
| if(isset($this->masque['proteges'])) { |
| $masqueProteges = ($this->masque['proteges'] === '1'); |
| if ($masqueZg) { // protection sur les zones concernées seulement |
| $sousConditions = array(); |
| $zonesProtegees = $this->zonesProtegeesParDepartement($masqueZg); |
| foreach ($zonesProtegees as $zp) { |
| // @ACHTUNG pas de $this->getBdd()->proteger() sinon ça foire les doubles quotes - danger ! |
| $zpP = "'%" . 'zone":"' . $zp . "%'"; // fouille dans le JSON à l'arrache |
| $sousConditions[] = "sp.protection " . ($masqueProteges ? "" : "NOT ") . "LIKE $zpP"; |
| } |
| // si clause négative, IS NULL OR (NOT LIKE [AND NOT LIKE]*) sinon LIKE [OR LIKE]* |
| if ($masqueProteges) { |
| $conditions[] = '(' . implode(" OR ", $sousConditions) . ')'; |
| } else { |
| $conditions[] = '( sp.protection IS NULL OR (' . implode(" AND ", $sousConditions) . '))'; |
| } |
| } else { |
| $conditions[] = "sp.protection IS " . ($masqueProteges ? "NOT " : "") . "NULL "; |
| } |
| } |
| } |
| $where = " WHERE " . implode(' AND ', $conditions); |
| return $where; |
| } |
| /** |
| * Retourne la liste des codes de zones d'application de la protection concernant un département, |
| * soit le code du département lui-même, le code de sa région, plus les codes "France" et "Europe" |
| * @TODO déplacer dans sptb ? |
| * @param string $dept une chaîne représentant le département, sur 2 chiffres |
| */ |
| protected function zonesProtegeesParDepartement($dept) { |
| $zones = array('FX', 'EU'); |
| $zones[] = "Dpt-$dept"; |
| // Appel service insee-d pour connaître la région |
| $url_tpl = Config::get('insee_d_url_tpl'); |
| $url = sprintf($url_tpl, $dept); |
| $donnees = $this->getRestClient()->consulter($url); |
| $donnees = json_decode($donnees, true); |
| if (! empty($donnees['region.code'])) { |
| $zones[] = 'Reg-' . $donnees['region.code']; |
| } |
| return $zones; |
| } |
| /** |
| * Méthode permettant de faire appel à un client REST en fonction des besoins du service. |
| */ |
| /*protected function getRestClient() { |
| if (! isset($this->RestClient)) { |
| $this->RestClient = new RestClient(); |
| } |
| return $this->RestClient; |
| }*/ |
| } |
| /branches/v5.12-baouque/services/modules/0.1/chorodep/Cartes.php |
|---|
| New file |
| 0,0 → 1,89 |
| <?php |
| // declare(encoding='UTF-8'); |
| /** |
| * Classe implémentant l'API d'eFlore Cartes pour le projet CHORODEP. |
| * |
| * @see http://www.tela-botanica.org/wikini/eflore/wakka.php?wiki=EfloreApi01Cartes |
| * |
| * @package eFlore/services |
| * @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) |
| */ |
| // TODO : Config et Outils sont des classes statiques qui doivent poser des pb pour les tests... |
| class ChorodepCartes { |
| private $parametres = array(); |
| private $ressources = array(); |
| public function consulter($ressources, $parametres) { |
| $this->parametres = $parametres; |
| $this->ressources = $ressources; |
| $this->analyserRessources(); |
| $resultat = $this->executerSousService(); |
| return $resultat; |
| } |
| private function analyserRessources() { |
| $nbreRessources = count($this->ressources); |
| if ($nbreRessources == 0) { |
| $this->sousService = 'France'; |
| } else if ($nbreRessources == 1) { |
| if ($this->etreRessourceIdentifiants(0)) { |
| $this->sousService = 'Taxons'; |
| } else if ($this->etreRessourceLegende(0)) { |
| // cas de la légende de la carte globale par taxons |
| // qui utilise le même sous service que la carte globale |
| // elle même |
| $this->sousService = 'France'; |
| } else { |
| $message = "La ressource n°1 '{$this->ressources[0]} indiquée n'est pas valable."; |
| $code = RestServeur::HTTP_CODE_MAUVAISE_REQUETE; |
| throw new Exception($message, $code); |
| } |
| } else if ($nbreRessources == 2) { |
| if ($this->etreRessourceIdentifiants(0) && $this->etreRessourceLegende(1)) { |
| $this->sousService = 'Legende'; |
| } |
| } |
| } |
| private function etreRessourceIdentifiants($position) { |
| $ok = true; |
| if (isset($this->ressources[$position])) { |
| $ids = $this->ressources[$position]; |
| $projetPattern = '(?:(?:(?:[A-Za-z0-9]+\.)?(?:nn|nt)?:)?(?:[0-9]+,)*[0-9]+)'; |
| $patternComplet = "/^$projetPattern(?:;$projetPattern)*$/i"; |
| $ok = preg_match($patternComplet, $ids) ? true : false; |
| } |
| return $ok; |
| } |
| private function etreRessourceLegende($position) { |
| $ok = true; |
| if (isset($this->ressources[$position])) { |
| $legende = $this->ressources[$position]; |
| $ok = ($legende == 'legende') ? true : false; |
| } |
| return $ok; |
| } |
| private function executerSousService() { |
| if (isset($this->sousService)) { |
| $classe = $this->sousService.'Cartes'; |
| require_once dirname(__FILE__).DS.'cartes'.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; |
| } |
| } |
| ?> |
| /branches/v5.12-baouque/services/modules/0.1/chorodep/Ontologies.php |
|---|
| New file |
| 0,0 → 1,366 |
| <?php |
| /** |
| * Description : |
| * Classe Ontologies.php fournit des informations sur ensemble structuré des termes et concepts représentant les éléments |
| * d'un domaine de connaissances . |
| * Le but étant de fournir un ensemble minimal d'information comprenant : |
| * un identifiant (numérique ou alphanumérique sous forme de ChatMot si possible), un nom, une description et |
| * éventuellement une relation hiérarchique avec un autre terme (=classe). |
| * Si l'url finit par /ontologies on retourne une liste de termes (seulement les 100 premières par défaut). |
| * L'url peut contenir des paramètres optionnels passés après le ? : /ontologies?param1=val1¶m2=val2&... |
| * |
| * Les paramètres de requête disponibles sont : masque, masque.code, masque.nom, masque.description , recherche, |
| * distinct, retour.format, navigation.depart et navigation.limite. |
| * |
| * Encodage en entrée : utf8 |
| * Encodage en sortie : utf8 |
| * @package eflore-projets |
| * @author Jennifer DHÉ <jennifer.dhe@tela-botanica.org> |
| * @author Delphine CAUQUIL <delphine@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 0.1 |
| * @copyright 1999-2011 Tela Botanica (accueil@tela-botanica.org) |
| */ |
| class ChorodepOntologies extends Commun { |
| protected $requete_condition = null; //Représente la partie de la requete SQL ajoutant une condition (WHERE ...) |
| /** 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 = 'chorodep_ontologies'; //on stocke le nom de la table correspondant à la version du projet en cours |
| $this->recupererNomChamp($this->table); //on récupère les noms des champs disponibles (Ds Commun.php) |
| $this->traiterRessources(); //dans CommunNomsTaxons.php |
| $requete = $this->assemblerLaRequete(); |
| $resultat = $this->getBdd()->recupererTous($requete); |
| $versionResultat = $this->traiterResultat($resultat, '', $requete); |
| $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 'retour.champs' : break; |
| case 'navigation.depart' : $this->limite_requete['depart'] = $valeur; break; |
| case 'navigation.limite' : $this->limite_requete['limite'] = $valeur; break; |
| case 'recherche' : break; |
| case 'version.projet' : 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 = '.$this->getBdd()->proteger($match[2]) |
| .' AND classe_id = (SELECT id FROM '.$this->table.' WHERE code = '.$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) { |
| $nom = null; |
| if ($classe_id != 0) { |
| $nom = ''; |
| $req = 'SELECT nom FROM '.$this->table.' WHERE id = '.$this->getBdd()->proteger($classe_id); |
| $res = $this->getBdd()->recuperer($req); |
| 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.12-baouque/services/modules/0.1/chorodep/InfosEspece.php |
|---|
| New file |
| 0,0 → 1,215 |
| <?php |
| /** |
| * Retourne des infos sur une espèce : noms vernaculaires français, statuts de |
| * protection, num_nom, num_tax, nom_sci, et nombre de zones dans lesquelles elle |
| * est présente. |
| * Interrogeable par nn ou nt |
| * |
| * Il faudrait appeler les services correspondants pour obtenir les infos sur les |
| * noms vernaculaires et les statuts de protection, mais c'est pas performant. |
| * Néanmoins ce serait une arcitecture plus solide en cas de changement - pas le |
| * temps d'y réfléchir mieux. |
| * |
| * @package chorodep |
| * @author Mathias Chouet <mathias@tela-botanica.org> |
| * @author Aurélien Perronnet <aurelien@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-2014 Tela Botanica (accueil@tela-botanica.org) |
| */ |
| class InfosEspece extends Commun { |
| protected $serviceNom = 'InfosEspece'; |
| protected $masque; |
| protected $navigation; |
| protected $table; |
| protected $tableNomsVernaculaires; |
| protected $urlStatutsProtection; |
| public function init() { |
| $this->masque = array(); |
| $this->traiterVersionProjet(); |
| $this->table = $this->table_version[0]; |
| $this->tableNomsVernaculaires = $this->config['table_nv']; |
| $this->urlStatutsProtection = $this->config['url_service_sptb']; |
| } |
| public function consulter($ressources, $parametres) { |
| $retour = null; |
| if(preg_match("/^(nt|nn):([0-9]+)$/", $ressources[0], $matches)) { |
| $champ_nt_ou_nn = ($matches[1] == "nn") ? "num_nom" : "num_tax"; |
| if(count($ressources) == 1) { |
| // toutes les infos |
| $infos_espece = $this->getInfosEspece($champ_nt_ou_nn, $matches[2]); |
| $retour = array_merge($infos_espece, $this->getInfosPresence($champ_nt_ou_nn, $matches[2])); |
| $statuts_protection = array( |
| 'statuts_protection' => $this->getStatutsProtection($champ_nt_ou_nn, $matches[2]) |
| ); |
| $retour = array_merge($retour, $statuts_protection); |
| $noms_vernaculaires = array( |
| 'noms_vernaculaires_fr' => $this->getNomsVernaculaires($champ_nt_ou_nn, $matches[2]) |
| ); |
| $retour = array_merge($retour, $noms_vernaculaires); |
| } else { |
| // sous action du service |
| $retour = array(); |
| switch($ressources[1]) { |
| case "noms-vernaculaires": |
| $retour = array('noms_vernaculaires_fr' => $this->getNomsVernaculaires($champ_nt_ou_nn, $matches[2])); |
| break; |
| case "statuts-protection": |
| $retour = array('statuts_protection' => $this->getStatutsProtection($champ_nt_ou_nn, $matches[2])); |
| break; |
| case "presence": |
| $retour = $this->getInfosPresence($champ_nt_ou_nn, $matches[2]); |
| break; |
| case "presence-departement": |
| $retour = $this->getInfosPresenceDepartement($champ_nt_ou_nn, $matches[2], $ressources[2]); |
| break; |
| default: |
| $retour = "Actions possibles: noms-vernaculaires, statuts-protection, presence"; |
| } |
| } |
| } else { |
| // TODO : envoyer message erreur; |
| } |
| return $retour; |
| } |
| /** |
| * Toutes les infos sauf noms vernaculaires et statuts de protection |
| */ |
| protected function getInfosEspece($champ_nt_ou_nn, $nt_ou_nn) { |
| $req = "SELECT DISTINCT num_nom, num_tax, nom_sci" |
| . " FROM " . $this->table |
| . " WHERE $champ_nt_ou_nn = " . $this->getBdd()->proteger($nt_ou_nn); |
| $resultat = $this->getBdd()->recuperer($req); |
| return $resultat; |
| } |
| /** |
| * Construit une opération d'addition entre toutes les colonnes de la table |
| * chorodep représentant un département |
| */ |
| protected function construireSommeColonnes() { |
| $colonnes = array(); |
| for ($i=1; $i <= 95; $i++) { |
| $colonnes[] = '`' . ($i > 9 ? $i : "0$i") . '`'; |
| } |
| $somme = implode('+', $colonnes); |
| return $somme; |
| } |
| protected function getInfosPresenceDepartement($champ_nt_ou_nn, $nt_ou_nn, $departement) { |
| // Dans le cas où un num nom est demandé on ajoute les synonymes à la recherche |
| if($champ_nt_ou_nn == "num_nom") { |
| $url = $this->ajouterHrefAutreProjet('noms', $nt_ou_nn, '/relations/synonymie', 'bdtfx', 'retour.format=min'); |
| $val = (array)$this->consulterHref($url); |
| if(isset($val['resultat'])) { |
| $nt_ou_nn_tab = array_keys((array)$val['resultat']); |
| //print_r($nt_ou_nn_tab);exit; |
| foreach($nt_ou_nn_tab as &$nnt) { |
| $nnt = $this->getBdd()->proteger($nnt); |
| } |
| $nt_ou_nn = implode(',', $nt_ou_nn_tab); |
| } else { |
| $nt_ou_nn = $this->getBdd()->proteger($nt_ou_nn); |
| } |
| } else { |
| $nt_ou_nn = $this->getBdd()->proteger($nt_ou_nn); |
| } |
| // Afin de s'assurer d'une valeur numérique |
| $departement = intval($departement); |
| // Afin de gérer les noms de colonnes qui commencent par 0 sans imposer de format |
| // de nombre à l'entrée du web service |
| $departement = $departement < 10 ? "0".$departement : $departement; |
| $req = "SELECT count(*) > 0 as present". |
| " FROM ".$this->table. |
| " WHERE ".$champ_nt_ou_nn." IN (".$nt_ou_nn.") AND ". |
| "`".$departement."` = 1"; |
| $resultat = $this->getBdd()->recuperer($req); |
| return $resultat; |
| } |
| protected function getInfosPresence($champ_nt_ou_nn, $nt_ou_nn) { |
| $req = "SELECT " . $this->construireSommeColonnes() . " as nb_presence_zones". |
| " FROM ".$this->table. |
| " WHERE ".$champ_nt_ou_nn." = ".$this->getBdd()->proteger($nt_ou_nn); |
| $resultat = $this->getBdd()->recuperer($req); |
| return $resultat; |
| } |
| /** |
| * Appelle le WS sptb car la table ne contient pas toutes les infos (il faut |
| * agréger les taxons supérieurs) |
| */ |
| protected function getStatutsProtection($champ_nt_ou_nn, $nt_ou_nn) { |
| $num_noms = array(); |
| if ($champ_nt_ou_nn == "num_tax") { |
| // le service sptb n'accepte pas les nt (on croit que si mais en fait |
| // non) alors on chope les nn associés à ce nt dans chorodep - c'est |
| // moisi mais c'est toujours mieux que si c'était pire |
| $numTaxP = $this->getBdd()->proteger($nt_ou_nn); |
| $req = "SELECT DISTINCT num_nom" |
| . " FROM " . $this->table |
| . " WHERE num_tax = $numTaxP"; |
| $resultat = $this->getBdd()->recupererTous($req); |
| foreach($resultat as $res) { |
| $num_noms[] = $res['num_nom']; |
| } |
| } else { |
| $num_noms[] = $nt_ou_nn; |
| } |
| $statuts = array(); |
| // récupération des statuts pour chaque num_nom |
| foreach ($num_noms as $nn) { |
| $url = sprintf($this->urlStatutsProtection, $nn); |
| $donnees = $this->getRestClient()->consulter($url); |
| $donnees = json_decode($donnees, true); |
| foreach ($donnees as $d) { |
| $statuts[] = array( |
| 'zone' => $d['code_zone_application'], |
| 'lien' => $d['hyperlien_legifrance'] |
| ); |
| } |
| } |
| return $statuts; |
| } |
| // @TODO faire un appel au WS nvjfl "for the sake of non-nodebagging" ? |
| protected function getNomsVernaculaires($champ_nt_ou_nn, $nt_ou_nn) { |
| $numP = $this->getBdd()->proteger($nt_ou_nn); |
| $req = "SELECT DISTINCT nv.nom_vernaculaire" |
| . " FROM " . $this->tableNomsVernaculaires . " nv"; |
| if ($champ_nt_ou_nn == "num_nom") { |
| $req .= " LEFT JOIN " . $this->table . " c ON nv.num_taxon = c.num_tax" |
| . " WHERE c.num_nom = $numP"; |
| } else { |
| $req .= " WHERE nv.num_taxon = $numP"; |
| } |
| $req .= " AND nv.code_langue = 'fra'"; |
| $resultat = $this->getBdd()->recupererTous($req); |
| $resultat_fmt = array(); |
| foreach($resultat as $nv) { |
| $resultat_fmt[] = $nv['nom_vernaculaire']; |
| } |
| return $resultat_fmt; |
| } |
| } |
| ?> |