| /tags/v1.13-la-grande-rue/controleurs/Carte.php |
|---|
| New file |
| 0,0 → 1,37 |
| <?php |
| // declare(encoding='UTF-8'); |
| /** |
| * classe Controleur du module Carte. |
| * |
| * @package Collection |
| * @category Php5 |
| * @author Jean-Pascal MILCENT <jpm@tela-botanica.org> |
| * @copyright 2010 Tela-Botanica |
| * @license http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt Licence CECILL |
| * @license http://www.gnu.org/licenses/gpl.html Licence GNU-GPL |
| * @version SVN: $Id$ |
| */ |
| class Carte extends aControleur { |
| //+----------------------------------------------------------------------------------------------------------------+ |
| // Méthodes |
| /** |
| * Fonction d'affichage par défaut, elle appelle la liste des administrateurs |
| */ |
| public function executerActionParDefaut() { |
| return $this->cartographier(); |
| } |
| /** |
| * Cartographier les collections. |
| * @return string la vue correspondante |
| */ |
| public function cartographier() { |
| $resultat = $this->getVue('carte', array()); |
| $this->setSortie(self::RENDU_CORPS, $resultat); |
| $this->chargerPiedDePage(); |
| } |
| } |
| ?> |
| /tags/v1.13-la-grande-rue/controleurs/Fiche.php |
|---|
| New file |
| 0,0 → 1,69 |
| <?php |
| // declare(encoding='UTF-8'); |
| /** |
| * Classe mère des Controleurs des modules présentant des Fiches. |
| * |
| * @package Collection |
| * @category Php 5.2 |
| * @author Jean-Pascal MILCENT <jpm@tela-botanica.org> |
| * @copyright 2010 Tela-Botanica |
| * @license http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt Licence CECILL |
| * @license http://www.gnu.org/licenses/gpl.html Licence GNU-GPL |
| * @version SVN: $Id$ |
| */ |
| abstract class Fiche extends aControleur { |
| protected $structureDao = null; |
| protected $collectionDao = null; |
| protected $personneDao = null; |
| public function __construct() { |
| parent::__construct(); |
| $this->structureDao = new StructureDao(); |
| $this->collectionDao = new CollectionDao(); |
| $this->personneDao = new PersonneDao(); |
| } |
| // +---------------------------------------------------------------------------------------------------------------+ |
| // MÉTHODES GÉNÉRIQUES |
| protected function obtenirNomCompletPersonne($personne_id) { |
| $personne_nom = $this->personneDao->getPersonneNomComplet($personne_id); |
| return $personne_nom; |
| } |
| protected function obtenirCourrielsPersonne($personne_id) { |
| $courriels = $this->personneDao->getPersonneCourriels($personne_id); |
| $courriels = $this->traiterTxtTruck($courriels); |
| $courriels = $this->formaterCourriels($courriels); |
| return $courriels; |
| } |
| protected function traiterDonneesElementAPublication(&$publications) { |
| foreach ($publications as &$publication) { |
| $publication['_editeur_'] = $this->construireTxtTruck($publication['cpu_ce_truk_editeur']); |
| $publication['_date_parution_'] = rtrim($publication['cpu_date_parution'],'-00-00'); |
| if(isset($publication['ccapu_source'])) { |
| $publication['ccapu_source'] = $publication['ccapu_source'] == "1" ? "oui" : "non"; |
| } |
| } |
| } |
| protected function traiterMetaDonnees(&$donnees) { |
| $meta = array(); |
| $meta['_guid_'] = $donnees['_guid_']; |
| $meta['_guid_url_'] = $this->obtenirPermalienGuid($donnees['_guid_']); |
| $meta['_notes_'] = $donnees['cmhl_notes']; |
| $meta['_source_'] = $donnees['cmhl_source']; |
| // les deux champs suivants sont spécifique à la collection |
| // TODO: si d'autres champs spécifiques s'ajoutent, faire un système |
| // générique pour les champs de meta données supplémentaires |
| $meta['_expert_'] = isset($donnees['expert']) ? $donnees['expert'] : null; |
| $meta['_contributeur_'] = isset($donnees['contributeur']) ? $donnees['contributeur'] : null; |
| $meta['_date_modification_'] = $donnees['cmhl_date_modification']; |
| $meta['_modifier_par_'] = $this->obtenirNomCompletPersonne($donnees['cmhl_ce_modifier_par']); |
| $meta['_modifier_par_courriel_'] = $this->obtenirCourrielsPersonne($donnees['cmhl_ce_modifier_par']); |
| $meta['_etat_'] = $this->construireTxtListeOntologie($donnees['cmhl_ce_etat']); |
| return $this->getVue('metadonnees', $meta); |
| } |
| } |
| Property changes: |
| Added: svn:keywords |
| +Id Author Date Revision HeadURL |
| \ No newline at end of property |
| /tags/v1.13-la-grande-rue/controleurs/FicheStructure.php |
|---|
| New file |
| 0,0 → 1,241 |
| <?php |
| // declare(encoding='UTF-8'); |
| /** |
| * Classe Controleur du module Fiche Structure. |
| * |
| * @category Php 5.2 |
| * @package Collection |
| * @author Jean-Pascal MILCENT <jpm@tela-botanica.org> |
| * @copyright 2010 Tela-Botanica |
| * @license http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt Licence CECILL |
| * @license http://www.gnu.org/licenses/gpl.html Licence GNU-GPL |
| * @version SVN: $Id: Fiche.php 96 2010-06-21 16:46:31Z jpm $ |
| */ |
| class FicheStructure extends Fiche { |
| private $donnees = array(); |
| //+----------------------------------------------------------------------------------------------------------------+ |
| // Méthodes |
| /** |
| * Fonction d'affichage par défaut |
| */ |
| public function executerActionParDefaut() { |
| return $this->afficherStructure(); |
| } |
| // +---------------------------------------------------------------------------------------------------------------+ |
| // FICHE STRUCTURE |
| public function afficherStructure() { |
| // Gestion des actions par défaut |
| $this->executerAction('Recherche', 'chargerMoteurRecherche'); |
| // Gestion des données de la requête |
| if (!isset($_GET['id'])) { |
| } else { |
| // Gestion des données |
| $this->donnees['id'] = $_GET['id']; |
| $this->donnees['info'] = $this->structureDao->getStructure($this->donnees['id']); |
| $this->traiterDonneesStructure($this->donnees['info']); |
| $this->creerPaginationPersonnel($this->donnees['id']); |
| $this->traiterDonneesStructureConservation($this->donnees['info']); |
| $this->traiterDonneesStructureValorisation($this->donnees['info']); |
| $this->creerPaginationCollections($this->donnees['id']); |
| $this->postraiterDonnees($this->donnees); |
| $this->donnees['metadonnees'] = $this->traiterMetaDonnees($this->donnees['info']); |
| // Création des méta-données de la page |
| $titre = $this->donnees['info']['cs_nom']; |
| $description = $this->donnees['info']['cs_description']; |
| $tags = "Structure, id:{$this->donnees['id']}, {$this->donnees['info']['_guid_']}"; |
| // Envoie à la sortie |
| //Debug::printr($donnees); |
| $this->setSortie(self::META_TITRE, $titre); |
| $this->setSortie(self::META_DESCRIPTION, $description); |
| $this->setSortie(self::META_TAGS, $tags); |
| $this->setSortie(self::RENDU_CORPS, $this->getVue('fiche_structure', $this->donnees)); |
| $this->chargerPiedDePage(); |
| } |
| } |
| private function traiterDonneesStructure(&$donnees) { |
| // liste 01 : Liste des états des enregistrements de la base de données |
| Ontologie::chargerListe(1001); |
| // liste 12 : Liste des types de structure privé |
| Ontologie::chargerListe(1015); |
| // liste 13 : Liste des types de structure public |
| Ontologie::chargerListe(1016); |
| // liste 71 : Liste des pays du standard ISO-3166-1 |
| Ontologie::chargerListe(1074); |
| $guid_id_valeur = Config::get('guid_id_structure').$donnees['cs_id_structure']; |
| $donnees['_guid_'] = sprintf(Config::get('guid'), $guid_id_valeur); |
| $donnees['_date_fondation_'] = $this->formaterDate($donnees['cs_date_fondation'], aControleur::FMT_DATE); |
| $donnees['_nbre_personne_'] = (empty($donnees['cs_nbre_personne'])) ? '' : $donnees['cs_nbre_personne']; |
| $donnees['_acronyme_'] = $this->construireTxtTruck($donnees['cs_truk_identifiant_alternatif']); |
| $donnees['_telephone_fax_'] = $this->construireTxtTruck($donnees['cs_truk_telephone']); |
| $donnees['_type_prive_'] = $this->construireTxtListeOntologie($donnees['cs_ce_truk_type_prive']); |
| $donnees['_type_public_'] = $this->construireTxtListeOntologie($donnees['cs_ce_truk_type_public']); |
| $donnees['_pays_'] = $this->construireTxtListeOntologie($donnees['cs_ce_truk_pays']); |
| $donnees['_web_'] = $this->construireTxtTruckSansMajuscule($donnees['cs_truk_url']); |
| $donnees['_courriel_'] = $this->formaterCourriels($donnees['cs_courriel']); |
| $latitude = $donnees['cs_latitude']; |
| $longitude = $donnees['cs_longitude']; |
| $donnees['_latitude_longitude_'] = ($longitude != '' && $latitude != '') ? "$latitude / $longitude" : ''; |
| $donnees['_latitude_dcm_en_'] = ($latitude != '') ? str_replace(',', '.', $latitude) : ''; |
| $donnees['_longitude_dcm_en_'] = ($longitude != '') ? str_replace(',', '.', $longitude) : ''; |
| $donnees['_lien_carte_'] = sprintf(Config::get('lien_vers_carte'), $donnees['_latitude_dcm_en_'], $donnees['_longitude_dcm_en_']); |
| $donnees['_url_img_carte_'] = sprintf(Config::get('url_img'), Config::get('img_carte')); |
| } |
| private function traiterDonneesStructureConservation(&$donnees) { |
| // liste 15 : Liste des types de local de stockage de collections |
| Ontologie::chargerListe(1018); |
| // liste 16 : Liste des types de mobilier de stockage de collections |
| Ontologie::chargerListe(1019); |
| // liste 17 : Liste des paramètres de contrôle environnemental d'un local |
| Ontologie::chargerListe(1020); |
| // liste 18 : Liste des types de collection non botanique |
| Ontologie::chargerListe(1021); |
| // liste 19 : Liste des types d'opération de restauration pour les collections botaniques |
| Ontologie::chargerListe(1022); |
| // liste 20 : Liste oui/non/en partie |
| Ontologie::chargerListe(1023); |
| // liste 21 : Liste du matériel dit de nom conservation des parts d'herbier |
| Ontologie::chargerListe(1024); |
| $donnees['_formation_'] = $this->formaterOuiNon($donnees['csc_mark_formation']); |
| $donnees['_formation_info_'] = $this->formaterParenthese($donnees['csc_formation']); |
| $donnees['_formation_info_'] = $this->formaterSautDeLigne($donnees['_formation_info_']); |
| $donnees['_formation_interet_'] = $this->formaterOuiNon($donnees['csc_mark_formation_interet']); |
| $donnees['_stockage_local_'] = $this->construireTxtListeOntologie($donnees['csc_truk_stockage_local']); |
| $donnees['_stockage_meuble_'] = $this->construireTxtListeOntologie($donnees['csc_truk_stockage_meuble']); |
| $donnees['_stockage_parametre_'] = $this->construireTxtListeOntologie($donnees['csc_truk_stockage_parametre']); |
| $donnees['_collection_commune_'] = $this->formaterOuiNon($donnees['csc_mark_collection_commune']); |
| $donnees['_collection_commune_autre_'] = $this->construireTxtListeOntologie($donnees['csc_truk_collection_autre']); |
| $donnees['_collection_commune_autre_'] = $this->formaterParenthese($donnees['_collection_commune_autre_']); |
| $donnees['_acces_controle_'] = $this->formaterOuiNon($donnees['csc_mark_acces_controle']); |
| $donnees['_restauration_'] = $this->formaterOuiNon($donnees['csc_mark_restauration']); |
| $donnees['_restauration_operation_'] = $this->construireTxtListeOntologie($donnees['csc_truk_restauration_operation']); |
| $donnees['_restauration_operation_'] = $this->formaterParenthese($donnees['_restauration_operation_']); |
| $donnees['_materiel_conservation_'] = $this->construireTxtListeOntologie($donnees['csc_ce_materiel_conservation']); |
| $donnees['_materiel_autre_'] = $this->construireTxtListeOntologie($donnees['csc_truk_materiel_autre']); |
| $donnees['_materiel_autre_'] = $this->formaterParenthese($donnees['_materiel_autre_']); |
| $donnees['_traitement_'] = $this->formaterOuiNon($donnees['csc_mark_traitement']); |
| $donnees['_traitement_liste_'] = $this->construireTxtListeOntologie($donnees['csc_truk_traitement']); |
| $donnees['_traitement_liste_'] = $this->formaterParenthese($donnees['_traitement_liste_']); |
| $donnees['_acquisition_collection_'] = $this->formaterOuiNon($donnees['csc_mark_acquisition_collection']); |
| $donnees['_acquisition_echantillon_'] = $this->formaterOuiNon($donnees['csc_mark_acquisition_echantillon']); |
| if ($donnees['csc_mark_acquisition_echantillon'] == '1') { |
| $donnees['_acquisition_traitement_'] = $this->formaterOuiNon($donnees['csc_mark_acquisition_traitement']); |
| if ($donnees['csc_mark_acquisition_traitement'] == '1') { |
| $donnees['_acquisition_traitement_poison_'] = $this->construireTxtListeOntologie($donnees['csc_truk_acquisition_traitement_poison']); |
| $donnees['_acquisition_traitement_insecte_'] = $this->construireTxtListeOntologie($donnees['csc_truk_acquisition_traitement_insecte']); |
| } |
| } |
| } |
| private function traiterDonneesStructureValorisation(&$donnees) { |
| // liste 24 : Liste des actions de valorisation des collections |
| Ontologie::chargerListe(1027); |
| // liste 25 : Liste des continents habités incluant aussi le pays France |
| Ontologie::chargerListe(1028); |
| // liste 26 : Liste des types de recherche nécessitant la consultation de collection botanique |
| Ontologie::chargerListe(1029); |
| $donnees['_action_'] = $this->formaterOuiNon($donnees['csv_mark_action']); |
| $donnees['_action_info_'] = $this->construireTxtListeOntologie($donnees['csv_truk_action']); |
| $donnees['_action_info_'] = $this->formaterParenthese($donnees['_action_info_']); |
| $donnees['_collection_autre_'] = $this->construireTxtListeOntologie($donnees['csv_collection_autre']); |
| $donnees['_action_future_'] = $this->formaterOuiNon($donnees['csv_mark_action_future']); |
| $donnees['_action_future_info_'] = $this->formaterParenthese($donnees['csv_action_future']); |
| $donnees['_recherche_'] = $this->formaterOuiNon($donnees['csv_mark_recherche']); |
| if ($donnees['csv_mark_recherche'] == '1') { |
| $donnees['_recherche_provenance_'] = $this->construireTxtListeOntologie($donnees['csv_truk_recherche_provenance']); |
| $donnees['_recherche_type_'] = $this->construireTxtListeOntologie($donnees['csv_truk_recherche_type']); |
| } |
| $donnees['_acces_ss_motif_'] = $this->formaterOuiNon($donnees['csv_mark_acces_ss_motif']); |
| $donnees['_acces_ss_motif_info_'] = $this->formaterParenthese($donnees['csv_acces_ss_motif']); |
| $donnees['_visite_avec_motif_'] = $this->formaterOuiNon($donnees['csv_mark_visite_avec_motif']); |
| $donnees['_visite_avec_motif_info_'] = $this->formaterParenthese($donnees['csv_visite_avec_motif']); |
| } |
| private function creerPaginationCollections($id_structure) { |
| // Gestion du nombre de résultats |
| $donnees_total = $this->collectionDao->getNbreParIdStructure($id_structure); |
| // Gestion du fragmenteur |
| $urlFiche = $this->obtenirObjetUrlFicheStructure($id_structure); |
| $options = array( |
| 'url' => $urlFiche, |
| 'url_var' => Config::get('parametre_url_page'), |
| 'donnees_total' => $donnees_total, |
| 'donnees_par_page' => Config::get('resultat_par_page_defaut'), |
| 'donnees_par_page_choix' => Config::get('resultat_par_page_choix'), |
| ); |
| $fragmenteur = Composant::fabrique('fragmenteur', $options); |
| $this->donnees['collectionsFrag'] = $fragmenteur->executer(); |
| list($de, $a) = $fragmenteur->getDeplacementParPageId(); |
| $this->url->unsetVariablesRequete(array('page')); |
| // Gestion de l'accès aux données |
| $this->collectionDao->setLimitation(($de - 1), $fragmenteur->getDonneesParPage()); |
| $this->collectionDao->setDistinction(1); |
| $this->donnees['collections'] = $this->collectionDao->getParIdStructure($id_structure); |
| $this->traiterDonneesStructureCollections($this->donnees['collections']); |
| } |
| private function traiterDonneesStructureCollections(&$collections) { |
| foreach ($collections as &$collection) { |
| $collection['_url_'] = $this->obtenirUrlFicheCollection($collection['cc_id_collection']); |
| } |
| } |
| private function creerPaginationPersonnel($id_structure) { |
| // Gestion du nombre de résultats |
| $donnees_total = $this->structureDao->getNbrePersonnel($id_structure); |
| // Gestion du fragmenteur |
| $urlFiche = $this->obtenirObjetUrlFicheStructure($id_structure); |
| $options = array( |
| 'url' => $urlFiche, |
| 'url_var' => Config::get('parametre_url_page'), |
| 'donnees_total' => $donnees_total, |
| 'donnees_par_page' => Config::get('resultat_par_page_defaut'), |
| 'donnees_par_page_choix' => Config::get('resultat_par_page_choix'), |
| ); |
| $fragmenteur = Composant::fabrique('fragmenteur', $options); |
| $this->donnees['personnelFrag'] = $fragmenteur->executer(); |
| list($de, $a) = $fragmenteur->getDeplacementParPageId(); |
| $this->url->unsetVariablesRequete(array('page')); |
| // Gestion de l'accès aux données |
| $this->structureDao->setLimitation(($de - 1), $fragmenteur->getDonneesParPage()); |
| $this->structureDao->setDistinction(1); |
| $this->donnees['personnel'] = $this->structureDao->getPersonnel($id_structure); |
| $this->traiterPersonnel($this->donnees['personnel']); |
| } |
| private function traiterPersonnel(&$donnees) { |
| // liste 09 : Liste des fonctions d'une personne au sein d'une structure |
| Ontologie::chargerListe(1012); |
| // liste 10 : Liste des statuts d'une personne au sein d'une structure |
| Ontologie::chargerListe(1013); |
| foreach ($donnees as &$personnel) { |
| $personnel['_fonction_'] = $this->construireTxtListeOntologie($personnel['csap_ce_truk_fonction']); |
| $personnel['_statut_'] = $this->construireTxtListeOntologie($personnel['csap_ce_truk_statut']); |
| $personnel['_tel_fax_'] = $this->construireTxtListeOntologie($personnel['cp_truk_telephone']); |
| $personnel['_courriel_'] = $this->traiterTxtTruck($personnel['cp_truk_courriel']); |
| $personnel['_courriel_'] = $this->formaterCourriels($personnel['_courriel_']); |
| $personnel['_contact_'] = $this->formaterOuiNon($personnel['csap_mark_contact']); |
| $personnel['_specialite_'] = $this->construireTxtListeOntologie($personnel['cp_ce_truk_specialite']); |
| $personnel['_url_'] = $this->obtenirUrlFichePersonne($personnel['csap_id_personne']); |
| } |
| } |
| } |
| /tags/v1.13-la-grande-rue/controleurs/Syndication.php |
|---|
| New file |
| 0,0 → 1,46 |
| <?php |
| // declare(encoding='UTF-8'); |
| /** |
| * classe Controleur du module Syndication. |
| * |
| * @package Collection |
| * @category Php5 |
| * @author Jean-Pascal MILCENT <jpm@tela-botanica.org> |
| * @copyright 2010 Tela-Botanica |
| * @license http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt Licence CECILL |
| * @license http://www.gnu.org/licenses/gpl.html Licence GNU-GPL |
| * @version SVN: $Id$ |
| */ |
| class Syndication extends aControleur { |
| //+----------------------------------------------------------------------------------------------------------------+ |
| // Méthodes |
| /** |
| * Fonction d'affichage par défaut |
| */ |
| public function executerActionParDefaut() { |
| return $this->afficher(); |
| } |
| /** |
| * Cartographier les collections. |
| * @return string la vue correspondante |
| */ |
| public function afficher() { |
| // Initialisation de variable |
| $donnees = array(); |
| // Récupération des infos sur les flux disponibles |
| $syndicationDao = new SyndicationDao(); |
| $donnees['syndications'] = $syndicationDao->getListeDesFlux(); |
| // Limitation des entrées des flux |
| $donnees['limite'] = Config::get('flux_limite'); |
| // Traitement du squelette et retour |
| $resultat = $this->getVue('syndication', $donnees); |
| $this->setSortie(self::RENDU_CORPS, $resultat); |
| $this->chargerPiedDePage(); |
| } |
| } |
| ?> |
| /tags/v1.13-la-grande-rue/controleurs/RecherchePublications.php |
|---|
| New file |
| 0,0 → 1,118 |
| <?php |
| /** |
| * classe Controleur du module RecherchePublications |
| * |
| * @package Collection |
| * @category Php5 |
| * @author Satanas et Diabolo <wtf@tela-botanica.org> |
| * @copyright 2010 Tela-Botanica |
| * @license http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt Licence CECILL |
| * @license http://www.gnu.org/licenses/gpl.html Licence GNU-GPL |
| */ |
| class RecherchePublications extends Recherche { |
| protected $masque = null; |
| protected static $url_exemple = null; |
| /** |
| * Charge le moteur de recherche et l'envoie à la vue. |
| */ |
| public function chargerMoteurRecherche() { |
| $donnees = array(); |
| // masque multi-critères |
| $donnees['masque'] = $this->obtenirMasqueRecherche(); |
| // Gestion des urls |
| $donnees['url_form'] = $this->obtenirUrlRecherche(); |
| $donnees['url_module'] = 'RecherchePublications'; |
| $donnees['url_action'] = 'rechercher'; |
| $donnees['url_contexte'] = $this->registre->get('contexte'); |
| self::$url_exemple = $this->obtenirUrlRecherche('%s'); |
| // remplissage de cases de tableaux vides pour éviter des warnings |
| $donnees['masque'] = $this->initialiserMasquesVides($donnees['masque']); |
| //echo '<pre>'.print_r($donnees['masque'],true).'</pre>';exit; |
| // Gestion du squelette et de la sortie |
| $this->setSortie(self::RENDU_TETE, $this->getVue('moteur_publications', $donnees)); |
| } |
| // recherche des publications |
| public function rechercher() { |
| $masque = $this->obtenirMasqueRecherche(); |
| $masque['cible'] = "publications"; |
| $donnees = array(); |
| $donnees['masque'] = $masque; |
| $rechercheDao = new RechercheDao(); |
| // Récupération des paramètres depuis le masque |
| $parametres = $masque; |
| $this->remplacerAbreviationParId($parametres); |
| //echo "PARAM 2: <pre>" . print_r($parametres, true) . "</pre><br/>"; |
| // Gestion du nombre de résultats |
| $donnees_total = $rechercheDao->chercherPublicationsNbre($parametres); |
| // Gestion du fragmenteur |
| $options = array( |
| 'url' => $this->url, |
| 'url_var' => Config::get('parametre_url_page'), |
| 'donnees_total' => $donnees_total, |
| 'donnees_par_page' => Config::get('resultat_par_page_defaut'), |
| 'donnees_par_page_choix' => Config::get('resultat_par_page_choix'), |
| ); |
| $fragmenteur = Composant::fabrique('fragmenteur', $options); |
| $donnees['fragmenteur'] = $fragmenteur->executer(); |
| list($de, $a) = $fragmenteur->getDeplacementParPageId(); |
| $this->url->unsetVariablesRequete(array('recherche', 'page')); |
| // Gestion de l'accès aux données |
| $rechercheDao->setLimitation(($de - 1), $fragmenteur->getDonneesParPage()); |
| $rechercheDao->setDistinction(1); |
| // Récupération des résultats |
| $resultats = $rechercheDao->chercherPublications($parametres); |
| // Affichage de la liste de résultats |
| foreach ($resultats as $resultat) { |
| if (!empty($resultat['cpu_id_publication'])) { |
| $editeur = $resultat['cpu_ce_truk_editeur']; |
| $pdd = strpos($editeur, "##"); |
| if ($pdd !== false) { |
| $editeur = substr($editeur, $pdd + 2); |
| } |
| $publication = array( |
| 'nomcomplet' => $resultat['cpu_fmt_nom_complet'], |
| 'date' => $resultat['cpu_date_parution'], |
| 'titre' => $resultat['cpu_titre'], |
| 'auteur' => $resultat['cpu_fmt_auteur'], |
| 'editeur' => $editeur, |
| 'nb_pages' => $resultat['cpu_truk_pages'], |
| //'url' => $this->obtenirUrlFichePersonne($resultat['cp_id_personne']) |
| ); |
| $donnees['infos']['publications'][] = $publication; |
| } |
| } |
| // Post-traitement des résultats pour l'affichage |
| $this->postraiterDonnees($donnees['infos']); |
| // Gestion des squelettes |
| $this->chargerMoteurRecherche(); |
| $resultat = $this->getVue('resultat', $donnees); |
| $this->setSortie(self::RENDU_CORPS, $resultat); |
| $this->chargerPiedDePage(); |
| } |
| protected function initialiserMasquesVides($masque) { |
| $masques_possibles = array('titre', 'auteur', 'date', 'ouvrage', 'libre'); |
| foreach($masques_possibles as $masque_possible) { |
| if(!isset($masque[$masque_possible])) { |
| $masque[$masque_possible] = ''; |
| } |
| } |
| return $masque; |
| } |
| } |
| /tags/v1.13-la-grande-rue/controleurs/FichePersonne.php |
|---|
| New file |
| 0,0 → 1,216 |
| <?php |
| // declare(encoding='UTF-8'); |
| /** |
| * Classe Controleur du module Fiche Personne. |
| * |
| * @category Php 5.2 |
| * @package Collection |
| * @author Jean-Pascal MILCENT <jpm@tela-botanica.org> |
| * @copyright 2010 Tela-Botanica |
| * @license http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt Licence CECILL |
| * @license http://www.gnu.org/licenses/gpl.html Licence GNU-GPL |
| * @version SVN: $Id: Fiche.php 96 2010-06-21 16:46:31Z jpm $ |
| */ |
| class FichePersonne extends Fiche { |
| private $donnees = array(); |
| //+----------------------------------------------------------------------------------------------------------------+ |
| // Méthodes |
| /** |
| * Fonction d'affichage par défaut |
| */ |
| public function executerActionParDefaut() { |
| return $this->afficherPersonne(); |
| } |
| // +---------------------------------------------------------------------------------------------------------------+ |
| // FICHE PERSONNE |
| public function afficherPersonne() { |
| // Gestion des actions par défaut |
| $this->executerAction('Recherche', 'chargerMoteurRecherche'); |
| // Gestion des données de la requête |
| if (!isset($_GET['id'])) { |
| } else { |
| // Récupération des données |
| $this->donnees['id'] = $_GET['id']; |
| $this->donnees['info'] = $this->personneDao->getPersonne($this->donnees['id']); |
| // Création des paginations |
| $this->creerPaginationPublications($this->donnees['id']); |
| $this->creerPaginationCollections($this->donnees['id']); |
| $this->creerPaginationStructures($this->donnees['id']); |
| // Traitement des données |
| $this->traiterDonneesPersonne($this->donnees['info']); |
| $this->traiterDonneesPersonneAPublication($this->donnees['publications']); |
| $this->traiterDonneesPersonneACollection($this->donnees['collections']); |
| $this->traiterDonneesPersonneAStructure($this->donnees['structures']); |
| $this->postraiterDonnees($this->donnees); |
| $this->donnees['metadonnees'] = $this->traiterMetaDonnees($this->donnees['info']); |
| // Création des méta-données de la page |
| $this->definirMetadonneesPageWeb(); |
| // Envoie à la sortie |
| //Debug::printr($donnees); |
| $this->setSortie(self::RENDU_CORPS, $this->getVue('fiche_personne', $this->donnees)); |
| $this->chargerPiedDePage(); |
| } |
| } |
| private function creerPaginationPublications($id_personne) { |
| // Gestion du nombre de résultats |
| $donnees_total = $this->personneDao->getNbrePublicationsLiees($id_personne); |
| // Gestion du fragmenteur |
| $urlFiche = $this->obtenirObjetUrlFichePersonne($id_personne); |
| $options = array( |
| 'url' => $urlFiche, |
| 'url_var' => Config::get('parametre_url_page'), |
| 'donnees_total' => $donnees_total, |
| 'donnees_par_page' => Config::get('resultat_par_page_defaut'), |
| 'donnees_par_page_choix' => Config::get('resultat_par_page_choix'), |
| ); |
| $fragmenteur = Composant::fabrique('fragmenteur', $options); |
| $this->donnees['publicationsFrag'] = $fragmenteur->executer(); |
| list($de, $a) = $fragmenteur->getDeplacementParPageId(); |
| $this->url->unsetVariablesRequete(array('page')); |
| // Gestion de l'accès aux données |
| $this->personneDao->setLimitation(($de - 1), $fragmenteur->getDonneesParPage()); |
| $this->personneDao->setDistinction(1); |
| $this->donnees['publications'] = $this->personneDao->getPublicationsLiees($id_personne); |
| } |
| private function creerPaginationCollections($id_personne) { |
| // Gestion du nombre de résultats |
| $donnees_total = $this->personneDao->getNbreCollectionsLiees($id_personne); |
| // Gestion du fragmenteur |
| $urlFiche = $this->obtenirObjetUrlFichePersonne($id_personne); |
| $options = array( |
| 'url' => $urlFiche, |
| 'url_var' => Config::get('parametre_url_page'), |
| 'donnees_total' => $donnees_total, |
| 'donnees_par_page' => Config::get('resultat_par_page_defaut'), |
| 'donnees_par_page_choix' => Config::get('resultat_par_page_choix'), |
| ); |
| $fragmenteur = Composant::fabrique('fragmenteur', $options); |
| $this->donnees['collectionsFrag'] = $fragmenteur->executer(); |
| list($de, $a) = $fragmenteur->getDeplacementParPageId(); |
| $this->url->unsetVariablesRequete(array('page')); |
| // Gestion de l'accès aux données |
| $this->personneDao->setLimitation(($de - 1), $fragmenteur->getDonneesParPage()); |
| $this->personneDao->setDistinction(1); |
| $this->donnees['collections'] = $this->personneDao->getCollectionsLiees($id_personne); |
| } |
| private function creerPaginationStructures($id_personne) { |
| // Gestion du nombre de résultats |
| $donnees_total = $this->personneDao->getNbreStructuresLiees($id_personne); |
| // Gestion du fragmenteur |
| $urlFiche = $this->obtenirObjetUrlFichePersonne($id_personne); |
| $options = array( |
| 'url' => $urlFiche, |
| 'url_var' => Config::get('parametre_url_page'), |
| 'donnees_total' => $donnees_total, |
| 'donnees_par_page' => Config::get('resultat_par_page_defaut'), |
| 'donnees_par_page_choix' => Config::get('resultat_par_page_choix'), |
| ); |
| $fragmenteur = Composant::fabrique('fragmenteur', $options); |
| $this->donnees['structuresFrag'] = $fragmenteur->executer(); |
| list($de, $a) = $fragmenteur->getDeplacementParPageId(); |
| $this->url->unsetVariablesRequete(array('page')); |
| // Gestion de l'accès aux données |
| $this->personneDao->setLimitation(($de - 1), $fragmenteur->getDonneesParPage()); |
| $this->personneDao->setDistinction(1); |
| $this->donnees['structures'] = $this->personneDao->getStructuresLiees($id_personne); |
| } |
| private function traiterDonneesPersonne(&$donnees) { |
| // Liste des préfixes |
| Ontologie::chargerListe(1004); |
| // Liste des suffixes |
| Ontologie::chargerListe(1005); |
| // Liste tel: |
| Ontologie::chargerListe(1007); |
| // Liste sexe: |
| Ontologie::chargerListe(1067); |
| // liste 77 : Liste indéterminé/oui/non |
| Ontologie::chargerListe(1080); |
| // Liste des types de publication vis à vis d'une personne |
| //relationPersonnePublication:1065, |
| $guid_id_valeur = Config::get('guid_id_personne').$donnees['cp_id_personne']; |
| $donnees['_guid_'] = sprintf(Config::get('guid'), $guid_id_valeur); |
| $donnees['_sexe_'] = $this->construireTxtListeOntologie($donnees['cp_ce_sexe']); |
| $donnees['_prefixe_'] = $this->construireTxtListeOntologie($donnees['cp_ce_truk_prefix']); |
| $donnees['_suffixe_'] = $this->construireTxtListeOntologie($donnees['cp_ce_truk_suffix']); |
| $donnees['_autre_noms_'] = $this->construireTxtTruck($donnees['cp_truk_nom_autre']); |
| $donnees['_autre_abreviations_'] = $this->construireTxtTruck($donnees['cp_truk_abreviation_autre']); |
| $donnees['_deces_'] = $this->construireTxtListeOntologie($donnees['cp_ce_deces']); |
| $donnees['_naissance_date_'] = $this->formaterDate($donnees['cp_naissance_date'], aControleur::FMT_DATE); |
| $donnees['_deces_date_'] = $this->formaterDate($donnees['cp_deces_date'], aControleur::FMT_DATE, ''); |
| $donnees['_telephones_'] = $this->construireTxtListeOntologie($donnees['cp_truk_telephone']); |
| $donnees['_courriels_'] = $this->traiterTxtTruck($donnees['cp_truk_courriel']); |
| $donnees['_courriels_'] = $this->formaterCourriels($donnees['_courriels_']); |
| $donnees['_sites_web_'] = $this->getTableauTruck($donnees['cp_truk_url']); |
| $donnees['_image_principale_url_'] = $this->getTxtTruckParPosition($donnees['cp_truk_logo'], 1); |
| $donnees['_pays_'] = $this->construireTxtListeOntologie($donnees['cp_ce_truk_pays']); |
| $donnees['_specialites_'] = $this->construireTxtListeOntologie($donnees['cp_ce_truk_specialite']); |
| $donnees['_recoltes_'] = $this->construireTxtListeOntologie($donnees['cp_truk_recolte']); |
| $donnees['_logos_'] = $this->getTableauTruck($donnees['cp_truk_logo']); |
| } |
| private function traiterDonneesPersonneAPublication(&$publications) { |
| $this->traiterDonneesElementAPublication($publications); |
| // liste 62 : Liste des types de publication vis à vis d'une personne |
| Ontologie::chargerListe(1065); |
| foreach ($publications as &$publication) { |
| $publication['_role_'] = $this->construireTxtListeOntologie($publication['cpuap_id_role']); |
| } |
| } |
| private function traiterDonneesPersonneACollection(&$collections) { |
| // liste 27 : Liste des relations entre une collection et une personne |
| Ontologie::chargerListe(1030); |
| foreach ($collections as &$collection) { |
| $collection['_role_'] = $this->construireTxtListeOntologie($collection['ccap_id_role']); |
| $collection['_url_'] = $this->obtenirUrlFicheCollection($collection['ccap_id_collection']); |
| } |
| } |
| private function traiterDonneesPersonneAStructure(&$structures) { |
| // liste 09 : Liste des fonctions d'une personne au sein d'une structure |
| Ontologie::chargerListe(1012); |
| // liste 10 : Liste des statuts d'une personne au sein d'une structure |
| Ontologie::chargerListe(1013); |
| foreach ($structures as &$structure) { |
| $structure['_fonction_'] = $this->construireTxtListeOntologie($structure['csap_ce_truk_fonction']); |
| $structure['_statut_'] = $this->construireTxtListeOntologie($structure['csap_ce_truk_statut']); |
| $structure['_url_'] = $this->obtenirUrlFicheStructure($structure['csap_id_structure']); |
| } |
| } |
| private function definirMetadonneesPageWeb() { |
| $titre = $this->donnees['info']['cp_fmt_nom_complet']; |
| $description = $this->donnees['info']['cp_description']; |
| $tags = "Botaniste, naturaliste, personne, id:{$this->donnees['id']}, {$this->donnees['info']['_guid_']}"; |
| // Envoie à la sortie |
| $this->setSortie(self::META_TITRE, $titre); |
| $this->setSortie(self::META_DESCRIPTION, $description); |
| $this->setSortie(self::META_TAGS, $tags); |
| } |
| } |
| /tags/v1.13-la-grande-rue/controleurs/Recherche.php |
|---|
| New file |
| 0,0 → 1,238 |
| <?php |
| // declare(encoding='UTF-8'); |
| /** |
| * classe Controleur du module Recherche. |
| * |
| * @package Collection |
| * @category Php5 |
| * @author Jean-Pascal MILCENT <jpm@tela-botanica.org> |
| * @copyright 2010 Tela-Botanica |
| * @license http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt Licence CECILL |
| * @license http://www.gnu.org/licenses/gpl.html Licence GNU-GPL |
| * @version SVN: $Id$ |
| */ |
| class Recherche extends aControleur { |
| //protected $chaine_recherche = null; |
| protected $masque = null; |
| protected static $url_exemple = null; |
| //+----------------------------------------------------------------------------------------------------------------+ |
| // Méthodes |
| /** |
| * Fonction d'affichage par défaut, elle appelle la liste des administrateurs |
| */ |
| public function executerActionParDefaut() { |
| return $this->rechercher(); |
| } |
| /** |
| * Charge le moteur de recherche et l'envoie à la vue. |
| */ |
| public function chargerMoteurRecherche() { |
| $donnees = array(); |
| // Gestion des données de la requête |
| //$donnees['recherche'] = htmlspecialchars($this->obtenirChaineRecherche()); |
| // masque multi-critères |
| $donnees['masque'] = $this->obtenirMasqueRecherche(); |
| // Gestion des urls |
| $donnees['url_form'] = $this->obtenirUrlRecherche(); |
| $donnees['url_module'] = 'Recherche'; |
| $donnees['url_action'] = 'rechercher'; |
| $donnees['url_contexte'] = $this->registre->get('contexte'); |
| self::$url_exemple = $this->obtenirUrlRecherche('%s'); |
| // remplissage de case de tableaux vides pour éviter des warnings |
| $donnees['masque'] = $this->initialiserMasquesVides($donnees['masque']); |
| //echo '<pre>'.print_r($donnees['masque'],true).'</pre>';exit; |
| // Gestion du squelette et de la sortie |
| $this->setSortie(self::RENDU_TETE, $this->getVue('moteur', $donnees)); |
| } |
| protected function obtenirMasqueRecherche() { |
| $masque = array(); |
| if (!is_null($this->masque)) { |
| $masque = $this->masque; |
| } else if (isset($_GET['masque'])) { |
| $masque = $_GET['masque']; |
| $_SESSION['col']['masque'] = $masque; |
| } else if (isset($_SESSION['col']['masque'])) { |
| $masque = $_SESSION['col']['masque']; |
| } |
| $this->masque = $masque; |
| return $masque; |
| } |
| public static function getUrlExemple($chaine) { |
| $url = ''; |
| if (!is_null(self::$url_exemple)) { |
| // L'utilisation d'urlencode nécessiate de pré-encodé la chaine dans le format de sortie si nécessaire |
| if (Config::get('sortie_encodage') != Config::get('appli_encodage')) { |
| $chaine = mb_convert_encoding($chaine, Config::get('sortie_encodage'), Config::get('appli_encodage')); |
| } |
| $chaine = urlencode($chaine); |
| $url = sprintf(self::$url_exemple, $chaine); |
| } |
| return $url; |
| } |
| // recherche des collections ou des personnes, dépendemment de la cible |
| public function rechercher() { |
| // un seul pour les collections ou les personnes, on ne cherche pas 2 choses à la fois ! |
| $masque = $this->obtenirMasqueRecherche(); |
| $donnees = array(); |
| $donnees['masque'] = $masque; |
| $rechercheDao = new RechercheDao(); |
| $parametres = array('mots' => '*'); |
| // Récupération des paramètres depuis le masque |
| $parametres = $masque; |
| $this->remplacerAbreviationParId($parametres); |
| //echo "PARAM 2: <pre>" . print_r($parametres, true) . "</pre><br/>"; |
| // Gestion du nombre de résultats |
| $donnees_total = null; |
| if (isset($masque['cible'])) { |
| switch ($masque['cible']) { |
| case 'collections': |
| $donnees_total = $rechercheDao->chercherCollectionsNbre($parametres); |
| break; |
| case 'personnes': |
| $donnees_total = $rechercheDao->chercherPersonnesNbre($parametres); |
| break; |
| default: |
| // @TODO qu'est-ce qui se passe ? |
| } |
| } |
| // Gestion du fragmenteur |
| $options = array( |
| 'url' => $this->url, |
| 'url_var' => Config::get('parametre_url_page'), |
| 'donnees_total' => $donnees_total, |
| 'donnees_par_page' => Config::get('resultat_par_page_defaut'), |
| 'donnees_par_page_choix' => Config::get('resultat_par_page_choix'), |
| ); |
| $fragmenteur = Composant::fabrique('fragmenteur', $options); |
| $donnees['fragmenteur'] = $fragmenteur->executer(); |
| list($de, $a) = $fragmenteur->getDeplacementParPageId(); |
| $this->url->unsetVariablesRequete(array('recherche', 'page')); |
| // Gestion de l'accès aux données |
| $rechercheDao->setLimitation(($de - 1), $fragmenteur->getDonneesParPage()); |
| $rechercheDao->setDistinction(1); |
| // Récupération des résultats |
| if (isset($masque['cible'])) { |
| switch ($masque['cible']) { |
| case 'collections': |
| $resultats = $rechercheDao->chercherCollections($parametres); |
| break; |
| case 'personnes': |
| $resultats = $rechercheDao->chercherPersonnes($parametres); |
| break; |
| default: |
| } |
| } |
| // Affichage de la liste de résultats |
| if (isset($masque['cible'])) { |
| switch ($masque['cible']) { |
| case 'collections': |
| if (! empty($resultats)) { |
| foreach ($resultats as $resultat) { |
| // Ajout des données concernant la structure si ce n'est pas déjà fait |
| $structure_id = $resultat['cs_id_structure']; |
| if (!isset($donnees['infos'][$structure_id])) { |
| $structure = array( |
| 'nom' => $resultat['cs_nom'], |
| 'ville' => $resultat['cs_ville'], |
| 'url' => $this->obtenirUrlFicheStructure($resultat['cs_id_structure']) |
| ); |
| $donnees['infos'][$structure_id]['structure'] = $structure; |
| } |
| // Si la structure possède des collections |
| if (!empty($resultat['cc_id_collection'])) { |
| $collection = array( |
| 'nom' => $resultat['cc_nom'], |
| 'url' => $this->obtenirUrlFicheCollection($resultat['cc_id_collection']) |
| ); |
| $donnees['infos'][$structure_id]['collections'][] = $collection; |
| } |
| } |
| } |
| break; |
| case 'personnes': |
| if (! empty($resultats)) { |
| foreach ($resultats as $resultat) { |
| //echo "<pre>".print_r($resultat,true)."</pre>"; |
| if (!empty($resultat['cp_id_personne'])) { |
| $personne = array( |
| 'nomcomplet' => $resultat['cp_fmt_nom_complet'], |
| 'nom' => $resultat['cp_nom'], |
| 'prenom' => $resultat['cp_prenom'], |
| 'url' => $this->obtenirUrlFichePersonne($resultat['cp_id_personne']) |
| ); |
| $donnees['infos']['personnes'][] = $personne; |
| } |
| } |
| } |
| break; |
| default: |
| } |
| } |
| // Post-traitement des résultats pour l'affichage |
| $this->postraiterDonnees($donnees['infos']); |
| // Gestion des squelettes |
| $this->chargerMoteurRecherche(); |
| $resultat = $this->getVue('resultat', $donnees); |
| $this->setSortie(self::RENDU_CORPS, $resultat); |
| $this->chargerPiedDePage(); |
| } |
| protected function initialiserMasquesVides($masque) { |
| $masques_possibles = array('lieu-stockage', |
| 'veg','zg','bot','p','pr','nom-famille','date-vivant','date-deces','adresse'); |
| foreach($masques_possibles as $masque_possible) { |
| if(!isset($masque[$masque_possible])) { |
| $masque[$masque_possible] = ''; |
| } |
| } |
| return $masque; |
| } |
| protected function remplacerAbreviationParId(&$parametres) { |
| // liste 27 : Liste des relations entre une collection et une personne (id:1030) |
| // liste 80 : Liste des types de collection botanique (id:1083) |
| $params_a_remplacer = array('veg' => 1043, 'bot' => 1083, 'pr' => 1030); |
| foreach ($params_a_remplacer as $param => $id_liste) { |
| if (isset($parametres[$param])) { |
| // Si plusieurs valeurs séparées par des virgules |
| $valeurs = explode(',', $parametres[$param]); |
| $valeurs_nbre = count($valeurs); |
| $liste = Ontologie::getListeTrieeParAbreviation($id_liste); |
| foreach ($valeurs as $valeur) { |
| $cle = strtoupper($valeur); |
| if (isset($liste[$cle])) { |
| if ($valeurs_nbre == 1) { |
| $parametres[$param] = $liste[$cle]['id']; |
| } else if ($valeurs_nbre > 1) { |
| $valeur = preg_quote($valeur, '/'); |
| $parametres[$param] = preg_replace("/$valeur/", $liste[$cle]['id'], $parametres[$param]); |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| Property changes: |
| Added: svn:keywords |
| +Id Author Date Revision HeadURL |
| \ No newline at end of property |
| /tags/v1.13-la-grande-rue/controleurs/FicheCollection.php |
|---|
| New file |
| 0,0 → 1,475 |
| <?php |
| // declare(encoding='UTF-8'); |
| /** |
| * Classe Controleur du module Fiche Collection. |
| * |
| * @category Php 5.2 |
| * @package Collection |
| * @author Jean-Pascal MILCENT <jpm@tela-botanica.org> |
| * @copyright 2010 Tela-Botanica |
| * @license http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt Licence CECILL |
| * @license http://www.gnu.org/licenses/gpl.html Licence GNU-GPL |
| * @version SVN: $Id: Fiche.php 96 2010-06-21 16:46:31Z jpm $ |
| */ |
| class FicheCollection extends Fiche { |
| private $donnees = array(); |
| protected $collectionDao = null; |
| //+----------------------------------------------------------------------------------------------------------------+ |
| // Méthodes |
| /** |
| * Fonction d'affichage par défaut |
| */ |
| public function executerActionParDefaut() { |
| return $this->afficherCollection(); |
| } |
| // +---------------------------------------------------------------------------------------------------------------+ |
| // FICHE COLLECTION |
| public function afficherCollection() { |
| // Gestion des actions par défaut |
| $this->executerAction('Recherche', 'chargerMoteurRecherche'); |
| // Gestion des données de la requête |
| if (!isset($_GET['id'])) { |
| } else { |
| // Récupération des données |
| $this->donnees['id'] = $_GET['id']; |
| $this->donnees['info'] = $this->collectionDao->getCollection($this->donnees['id']); |
| $this->creerPaginationPersonnes($this->donnees['id']); |
| $this->creerPaginationPublications($this->donnees['id']); |
| $this->creerPaginationCommentaires($this->donnees['id']); |
| // Traitements des données |
| $this->traiterDonneesCollection($this->donnees['info']); |
| $this->traiterDonneesCollectionAPersonne($this->donnees['personnes']); |
| $this->traiterDonneesElementAPublication($this->donnees['publications']); |
| $this->traiterDonneesCollectionDescription($this->donnees['info']); |
| $this->traiterDonneesCollectionContenu($this->donnees['info']); |
| $this->traiterDonneesCollectionInventaire($this->donnees['info']); |
| $this->traiterDonneesCollectionACommentaire($this->donnees['commentaires']); |
| $this->postraiterDonnees($this->donnees); |
| $this->donnees['info'] = $this->formaterMetaDonneesSpecifiques($this->donnees['info']); |
| $this->donnees['metadonnees'] = $this->traiterMetaDonnees($this->donnees['info']); |
| // Création des méta-données de la page |
| $titre = $this->donnees['info']['cc_nom']; |
| $description = $this->donnees['info']['cc_description']; |
| $tags = "Collection, id:{$this->donnees['id']}, {$this->donnees['info']['_guid_']}"; |
| // Envoie à la sortie |
| //Debug::printr($this->donnees); |
| $this->setSortie(self::META_TITRE, $titre); |
| $this->setSortie(self::META_DESCRIPTION, $description); |
| $this->setSortie(self::META_TAGS, $tags); |
| $this->setSortie(self::RENDU_CORPS, $this->getVue('fiche_collection', $this->donnees)); |
| $this->chargerPiedDePage(); |
| } |
| } |
| private function formaterMetaDonneesSpecifiques($donnees_info) { |
| // TODO: ceci cause trois appels de web services supplémentaires |
| // l'idéal serait d'avoir un service qui renvoie tout ça une fois |
| // (après l'appel n'est pas très couteux en temps et performance) |
| $sources = $this->collectionDao->getPublicationsSourcesLiees($this->donnees['id']); |
| $experts = $this->collectionDao->getPersonnesLieesExpertes($this->donnees['id']); |
| $contributeurs = $this->collectionDao->getPersonnesLieesContributrices($this->donnees['id']); |
| $donnees_info['contributeur'] = $this->formaterTableauMetadonnees($contributeurs, 'cp_fmt_nom_complet'); |
| $donnees_info['expert'] = $this->formaterTableauMetadonnees($experts, 'cp_fmt_nom_complet'); |
| $donnees_info['cmhl_source'] = $this->formaterTableauMetadonnees($sources, 'cpu_fmt_nom_complet', "<br />"); |
| return $donnees_info; |
| } |
| private function formaterTableauMetadonnees(&$donnees, $champ_a_extraire, $separateur = ", ") { |
| $donnees_fmt = array(); |
| foreach($donnees as &$donnee) { |
| $donnees_fmt[] = $donnee[$champ_a_extraire]; |
| } |
| return implode($separateur, $donnees_fmt); |
| } |
| private function creerPaginationPersonnes($id_collection) { |
| // Gestion du nombre de résultats |
| $donnees_total = $this->collectionDao->getNbrePersonnesLiees($id_collection); |
| // Gestion du fragmenteur |
| $urlFiche = $this->obtenirObjetUrlFicheCollection($id_collection); |
| $options = array( |
| 'url' => $urlFiche, |
| 'url_var' => Config::get('parametre_url_page'), |
| 'donnees_total' => $donnees_total, |
| 'donnees_par_page' => Config::get('resultat_par_page_defaut'), |
| 'donnees_par_page_choix' => Config::get('resultat_par_page_choix'), |
| ); |
| $fragmenteur = Composant::fabrique('fragmenteur', $options); |
| $this->donnees['personnesFrag'] = $fragmenteur->executer(); |
| list($de, $a) = $fragmenteur->getDeplacementParPageId(); |
| $this->url->unsetVariablesRequete(array('page')); |
| // Gestion de l'accès aux données |
| $this->collectionDao->setLimitation(($de - 1), $fragmenteur->getDonneesParPage()); |
| $this->collectionDao->setDistinction(1); |
| $this->donnees['personnes'] = $this->collectionDao->getPersonnesLiees($id_collection); |
| } |
| private function creerPaginationPublications($id_collection) { |
| // Gestion du nombre de résultats |
| $donnees_total = $this->collectionDao->getNbrePublicationsLiees($id_collection); |
| // Gestion du fragmenteur |
| $urlFiche = $this->obtenirObjetUrlFicheCollection($id_collection); |
| $options = array( |
| 'url' => $urlFiche, |
| 'url_var' => Config::get('parametre_url_page'), |
| 'donnees_total' => $donnees_total, |
| 'donnees_par_page' => Config::get('resultat_par_page_defaut'), |
| 'donnees_par_page_choix' => Config::get('resultat_par_page_choix'), |
| ); |
| $fragmenteur = Composant::fabrique('fragmenteur', $options); |
| $this->donnees['publicationsFrag'] = $fragmenteur->executer(); |
| list($de, $a) = $fragmenteur->getDeplacementParPageId(); |
| $this->url->unsetVariablesRequete(array('page')); |
| // Gestion de l'accès aux données |
| $this->collectionDao->setLimitation(($de - 1), $fragmenteur->getDonneesParPage()); |
| $this->collectionDao->setDistinction(1); |
| $this->donnees['publications'] = $this->collectionDao->getPublicationsLiees($id_collection); |
| } |
| private function creerPaginationCommentaires($id_collection) { |
| // Gestion du nombre de résultats |
| $donnees_total = $this->collectionDao->getNbreCommentairesLies($id_collection); |
| // Gestion du fragmenteur |
| $urlFiche = $this->obtenirObjetUrlFicheCollection($id_collection); |
| $options = array( |
| 'url' => $urlFiche, |
| 'url_var' => Config::get('parametre_url_page'), |
| 'donnees_total' => $donnees_total, |
| 'donnees_par_page' => Config::get('resultat_par_page_defaut'), |
| 'donnees_par_page_choix' => Config::get('resultat_par_page_choix'), |
| ); |
| $fragmenteur = Composant::fabrique('fragmenteur', $options); |
| $this->donnees['commentairesFrag'] = $fragmenteur->executer(); |
| list($de, $a) = $fragmenteur->getDeplacementParPageId(); |
| $this->url->unsetVariablesRequete(array('page')); |
| // Gestion de l'accès aux données |
| $this->collectionDao->setLimitation(($de - 1), $fragmenteur->getDonneesParPage()); |
| $this->collectionDao->setDistinction(1); |
| $this->donnees['commentaires'] = $this->collectionDao->getCommentairesLies($id_collection); |
| } |
| private function traiterDonneesCollection(&$donnees) { |
| // liste 29 : Liste des types de collection dans le standard NCD |
| Ontologie::chargerListe(1032); |
| // liste 30 : Liste des types de dépôt de collection |
| Ontologie::chargerListe(1033); |
| // liste 31 : Liste des principes de groupement d'une collection dans le standard NCD |
| Ontologie::chargerListe(1034); |
| // liste 32 : Liste des buts de réalisation d'une collection dans le standard NCD |
| Ontologie::chargerListe(1035); |
| // liste 38 : Liste indéterminé/peut-être/oui/non |
| Ontologie::chargerListe(1041); |
| // liste 39 : Liste des types de classement des spécimens types dans une collection |
| Ontologie::chargerListe(1042); |
| // liste 79 : Liste exact/approximatif |
| Ontologie::chargerListe(1082); |
| $guid_id_valeur = Config::get('guid_id_collection').$donnees['cc_id_collection']; |
| $donnees['_guid_'] = sprintf(Config::get('guid'), $guid_id_valeur); |
| $donnees['_structure_url_'] = $this->obtenirUrlFicheStructure($donnees['cc_ce_structure']); |
| $donnees['_nom_alternatif_'] = $this->construireTxtTruck($donnees['cc_truk_nom_alternatif']); |
| $donnees['_type_ncd_'] = $this->construireTxtListeOntologie($donnees['cc_ce_type']); |
| $donnees['_type_depot_'] = $this->construireTxtListeOntologie($donnees['cc_ce_type_depot']); |
| $donnees['_code_'] = $this->construireTxtTruckSansMajuscule($donnees['cc_truk_code']); |
| $donnees['_url_'] = $this->construireTxtTruckSansMajuscule($donnees['cc_truk_url']); |
| $donnees['_specimen_type_'] = $this->construireTxtListeOntologie($donnees['cc_ce_specimen_type']); |
| $donnees['_specimen_type_nbre_'] = ($donnees['cc_specimen_type_nbre'] == 0) ? '' : $donnees['cc_specimen_type_nbre']; |
| $donnees['_specimen_type_nbre_precision_'] = $this->construireTxtListeOntologie($donnees['cc_ce_specimen_type_nbre_precision']); |
| $donnees['_specimen_type_nbre_precision_'] = $this->formaterParenthese($donnees['_specimen_type_nbre_precision_']); |
| $donnees['_specimen_type_classement_'] = $this->construireTxtListeOntologie($donnees['cc_ce_specimen_type_classement']); |
| $donnees['_couverture_lieu_'] = $this->construireTxtTruck($donnees['cc_truk_couverture_lieu']); |
| $donnees['_couverture_periode_'] = $donnees["cc_periode_constitution_debut"]; |
| $donnees['_couverture_periode_'] .= ($donnees["cc_periode_constitution_fin"] != "") ? " - ".$donnees["cc_periode_constitution_fin"] : ""; |
| } |
| private function traiterDonneesCollectionAPersonne(&$personnes) { |
| // liste 27 : Liste des relations entre une collection et une personne |
| Ontologie::chargerListe(1030); |
| // liste 77 : Liste indéterminé/oui/non |
| Ontologie::chargerListe(1080); |
| foreach ($personnes as &$personne) { |
| $personne['_role_'] = $this->construireTxtListeOntologie($personne['ccap_id_role']); |
| $personne['_deces_'] = $this->construireTxtListeOntologie($personne['cp_ce_deces']); |
| $personne['_naissance_date_'] = $this->formaterDate($personne['cp_naissance_date'], aControleur::FMT_DATE); |
| $personne['_deces_date_'] = $this->formaterDate($personne['cp_deces_date'], aControleur::FMT_DATE, ''); |
| $personne['_url_'] = $this->obtenirUrlFichePersonne($personne['ccap_id_personne']); |
| } |
| } |
| private function traiterDonneesCollectionDescription(&$donnees) { |
| // liste 22 : Liste de traitement anti-insecte pour les collections botaniques |
| Ontologie::chargerListe(1025); |
| // liste 23 : Liste des poisons utilisés pour les collections botaniques |
| Ontologie::chargerListe(1026); |
| // liste 38 : Liste indéterminé/peut-être/oui/non |
| Ontologie::chargerListe(1041); |
| // liste 41 : Liste des types d'unité de rangement pour les collections botaniques |
| Ontologie::chargerListe(1044); |
| // liste 42 : Liste des états |
| Ontologie::chargerListe(1045); |
| // liste 43 : Liste des types de support pour les spécimens des collections botaniques |
| Ontologie::chargerListe(1046); |
| // liste 44 : Liste des types de papier de support pour les spécimens des collections botaniques |
| Ontologie::chargerListe(1047); |
| // liste 45 : Liste des méthodes de rangement des supports pour les spécimens des collections botaniques |
| Ontologie::chargerListe(1048); |
| // liste 46 : Liste des méthodes de fixation sur le support pour les collections botaniques |
| Ontologie::chargerListe(1049); |
| // liste 47 : Liste des méthodes de fixation des étiquettes sur les spécimens pour les collections botaniques |
| Ontologie::chargerListe(1050); |
| // liste 48 : Liste des types d'écriture d'étiquette |
| Ontologie::chargerListe(1051); |
| // liste 49 : Liste des origines des dégradations des spécimens de collections botaniques |
| Ontologie::chargerListe(1052); |
| // liste 50 : Liste des origines des dégradations des supports de collections botaniques |
| Ontologie::chargerListe(1053); |
| // liste 51 : Liste des niveaux de détermination des spécimens de collections botaniques |
| Ontologie::chargerListe(1054); |
| $donnees['_type_'] = $this->construireTxtListeOntologie($donnees['ccb_ce_truk_type']); |
| $etats = array("1" => "Très mauvais", "2" => "Mauvais", 3 => "Moyen", "4" => "Bon", 5 => "Très bon"); |
| $donnees['_unite_rangement_etat_'] = isset($etats[$donnees['ccb_ce_unite_rangement_etat']]) ? $etats[$donnees['ccb_ce_unite_rangement_etat']] : ""; |
| $donnees['_cartons_'] = ($donnees['ccb_format_cartons_herbier'] === "") ? $donnees['ccb_nb_cartons_herbier'] : $donnees['ccb_nb_cartons_herbier']." ".$donnees['ccb_format_cartons_herbier']; |
| $donnees['_liasses_'] = ($donnees['ccb_format_liasses'] === "") ? $donnees['ccb_nb_liasses'] : $donnees['ccb_nb_liasses']." ".$donnees['ccb_format_liasses']; |
| $donnees['_autres_rangements_'] = $donnees["ccb_autres_unites_rangement"]; |
| $donnees['_nb_planches_herbier_'] = $donnees["ccb_nb_planches_herbiers"]; |
| $donnees['_nb_especes_'] = $donnees["ccb_nb_especes"]; |
| $donnees['_conservation_papier_type_'] = $this->construireTxtListeOntologie($donnees['ccb_truk_conservation_papier_type']); |
| $donnees['_conservation_methode_'] = $this->construireTxtListeOntologie($donnees['ccb_truk_conservation_methode']); |
| $donnees['_specimen_fixation_methode_'] = $this->construireTxtListeOntologie($donnees['ccb_truk_specimen_fixation_methode']); |
| $donnees['_etiquette_fixation_support_'] = $this->construireTxtListeOntologie($donnees['ccb_truk_etiquette_fixation_support']); |
| $donnees['_etiquette_fixation_specimen_'] = $this->construireTxtListeOntologie($donnees['ccb_truk_etiquette_fixation_specimen']); |
| $donnees['_etiquette_ecriture_'] = $this->construireTxtListeOntologie($donnees['ccb_truk_etiquette_ecriture']); |
| $donnees['_traitement_'] = $this->construireTxtListeOntologie($donnees['ccb_ce_traitement']); |
| $donnees['_traitement_poison_'] = $this->construireTxtListeOntologie($donnees['ccb_truk_traitement_poison']); |
| $donnees['_traitement_insecte_'] = $this->construireTxtListeOntologie($donnees['ccb_truk_traitement_insecte']); |
| $donnees['_etat_general_'] = isset($etats[$donnees['ccb_ce_etat_general']]) ? $etats[$donnees['ccb_ce_etat_general']] : ""; |
| $valeurEstOntologie = false; |
| $typeEstOntologie = true; |
| $donneeEstOntologie = true; |
| $donnees['_degradation_specimen_'] = $this->construireTxtListeOntologie($donnees['ccb_truk_degradation_specimen'], $valeurEstOntologie, $typeEstOntologie, $donneeEstOntologie); |
| $donnees['_degradation_presentation_'] = $this->construireTxtListeOntologie($donnees['ccb_truk_degradation_presentation'], $valeurEstOntologie, $typeEstOntologie, $donneeEstOntologie); |
| $donnees['_determination_'] = $this->construireTxtListeOntologie($donnees['ccb_ce_determination']); |
| } |
| private function traiterDonneesCollectionContenu(&$donnees) { |
| // liste 20 : Liste oui/non/en partie |
| Ontologie::chargerListe(1023); |
| // liste 37 : Liste des siècles pour les collections naturalistes |
| Ontologie::chargerListe(1040); |
| // liste 38 : Liste indéterminé/peut-être/oui/non |
| Ontologie::chargerListe(1041); |
| // liste 42 : Liste des états |
| Ontologie::chargerListe(1045); |
| // liste 52 : Liste des types de date de début |
| Ontologie::chargerListe(1055); |
| // liste 53 : Liste des types de date de fin |
| Ontologie::chargerListe(1056); |
| // liste 80 : Liste des types de collection botanique |
| Ontologie::chargerListe(1083); |
| $donnees['_nature_'] = $this->construireTxtListeOntologie($donnees['ccb_truk_nature']); |
| $donnees['_periode_constitution_'] = $this->construireTxtListeOntologie($donnees['cc_truk_periode_constitution']); |
| $donnees['_classement_etat_'] = $this->construireTxtListeOntologie($donnees['ccb_ce_classement_etat']); |
| $donnees['_etiquette_renseignement_'] = $this->construireTxtEtiquetteRenseignement($donnees['ccb_truk_etiquette_renseignement']); |
| $donnees['_precision_localite_'] = $this->construireTxtListeOntologie($donnees['ccb_ce_precision_localite']); |
| $donnees['_precision_date_'] = $this->construireTxtListeOntologie($donnees['ccb_ce_precision_date']); |
| $donnees['_collection_integre_'] = $this->construireTxtListeOntologie($donnees['ccb_ce_collection_integre']); |
| $donnees['_collection_integre_info_'] = $this->construireTxtListeOntologie($donnees['ccb_ce_collection_integre_info']); |
| } |
| private function traiterDonneesCollectionInventaire(&$donnees) { |
| // liste 38 : Liste indéterminé/peut-être/oui/non |
| Ontologie::chargerListe(1041); |
| // liste 57 : Liste indéterminé/parfois/oui/non |
| Ontologie::chargerListe(1060); |
| // liste 58 : Liste des formes d'inventaire |
| Ontologie::chargerListe(1061); |
| // liste 59 : Liste des types de logiciel pour les inventaires informatiques |
| Ontologie::chargerListe(1062); |
| // liste 60 : Liste des états d'inventaire |
| Ontologie::chargerListe(1063); |
| $donnees['_inventaire_'] = $this->construireTxtListeOntologie($donnees['ccb_ce_inventaire']); |
| $donnees['_inventaire_auteur_'] = $this->construireTxtListeOntologie($donnees['ccb_ce_inventaire_auteur']); |
| $donnees['_inventaire_forme_'] = $this->construireTxtListeOntologie($donnees['ccb_ce_inventaire_forme']); |
| $donnees['_inventaire_digital_'] = $this->construireTxtListeOntologie($donnees['ccb_ce_truk_inventaire_digital']); |
| $donnees['_inventaire_etat_'] = $this->construireTxtListeOntologie($donnees['ccb_ce_inventaire_etat']); |
| } |
| private function traiterDonneesCollectionACommentaire(&$commentaires) { |
| // liste 65 : Liste des types de commentaires associés à une collection |
| Ontologie::chargerListe(1068); |
| foreach ($commentaires as &$commentaire) { |
| $commentaire['_type_'] = $this->construireTxtListeOntologie($commentaire['ccac_truk_type']); |
| } |
| } |
| private function construireTxtEtiquetteRenseignement($valeur) { |
| $etiquetteRenseignements = ''; |
| $infos = $this->parserEtiquetteRenseignement($valeur); |
| if (count($infos) > 0) { |
| foreach ($infos as $cle => $info) { |
| if ($cle == 'AT') { |
| $etiquetteRenseignements .= 'auteur de la collection'; |
| } else if ($cle == 'F') { |
| $etiquetteRenseignements .= 'famille'; |
| } else if ($cle == 'G') { |
| $etiquetteRenseignements .= 'genre'; |
| } else if ($cle == 'SP') { |
| $etiquetteRenseignements .= 'espèce'; |
| } else if ($cle == 'ASP') { |
| $etiquetteRenseignements .= "auteur de l'espèce"; |
| } else if ($cle == 'L') { |
| $etiquetteRenseignements .= 'localité'; |
| } else if ($cle == 'D') { |
| $etiquetteRenseignements .= 'date de récolte'; |
| } else { |
| $etiquetteRenseignements .= 'Inconnue'; |
| } |
| $etiquetteRenseignements .= ': '.$info.'%, '; |
| } |
| $etiquetteRenseignements = rtrim($etiquetteRenseignements, ', ').'.'; |
| } |
| return $etiquetteRenseignements; |
| } |
| private function parserEtiquetteRenseignement($valeurTruk) { |
| $infos = array(); |
| if ($valeurTruk != '') { |
| $pourcentages = explode(self::SEPARATEUR_VALEURS, $valeurTruk); |
| foreach ($pourcentages as $pourcentage) { |
| $pourcentageIdValeur = explode(self::SEPARATEUR_TYPE_VALEUR, $pourcentage); |
| $id = $pourcentageIdValeur[0]; |
| $valeur = $pourcentageIdValeur[1]; |
| $infos[$id] = $valeur; |
| } |
| } |
| return $infos; |
| } |
| private function parserValeurUniteBase($valeurTruk) { |
| $unitesEnregistrees = array(); |
| if ($valeurTruk != '') { |
| $unites = explode(self::SEPARATEUR_VALEURS, $valeurTruk); |
| $unites_nbre = count($unites); |
| for ($i = 0; $i < $unites_nbre; $i++) { |
| $uniteTypeIdDonnees = explode(self::SEPARATEUR_TYPE_VALEUR, $unites[$i]); |
| $uniteChaineDonnees = $uniteTypeIdDonnees[1]; |
| $uniteDonnees = explode(self::SEPARATEUR_DONNEES, $uniteChaineDonnees); |
| $uniteDonneesNbre = count($uniteDonnees); |
| $uniteBase = array(); |
| if ($uniteDonneesNbre > 0) { |
| $uniteBase['nbre'] = $uniteDonnees[0]; |
| } |
| if ($uniteDonnees[0] > 0 || $uniteDonnees[2] != '' || $uniteDonnees[3] > 0 || $uniteDonnees[5] > 0) { |
| if ($uniteDonneesNbre > 1) { |
| $uniteBase['precision'] = self::getPrecisionNom($uniteDonnees[1]); |
| } |
| if ($uniteDonneesNbre > 2) { |
| $uniteBase['format'] = $uniteDonnees[2]; |
| } |
| if ($uniteDonneesNbre > 3) { |
| $uniteBase['part_nbre'] = $uniteDonnees[3]; |
| } |
| if ($uniteDonneesNbre > 4) { |
| $uniteBase['part_precision'] = self::getPrecisionNom($uniteDonnees[4]); |
| } |
| if ($uniteDonneesNbre > 5) { |
| $uniteBase['sp_nbre'] = $uniteDonnees[5]; |
| } |
| if ($uniteDonneesNbre > 6) { |
| $uniteBase['sp_precision'] = self::getPrecisionNom($uniteDonnees[6]); |
| } |
| if (preg_match('/^[0-9]+$/', $uniteTypeIdDonnees[0])) { |
| $uniteBase['id'] = $uniteTypeIdDonnees[0]; |
| $uniteBase['type'] = Ontologie::getValeurNom($uniteTypeIdDonnees[0]); |
| } else { |
| $uniteBase['type'] = $uniteTypeIdDonnees[0]; |
| } |
| $unitesEnregistrees[] = $uniteBase; |
| } |
| } |
| } |
| return $unitesEnregistrees; |
| } |
| private function parserValeurUniteRangement($valeurTruk) { |
| $unitesEnregistrees = array(); |
| if ($valeurTruk != '') { |
| $unites = explode(self::SEPARATEUR_VALEURS, $valeurTruk); |
| $unites_nbre = count($unites); |
| for ($i = 0; $i < $unites_nbre; $i++) { |
| $uniteTypeIdDonnees = explode(self::SEPARATEUR_TYPE_VALEUR, $unites[$i]); |
| $uniteChaineDonnees = $uniteTypeIdDonnees[1]; |
| $uniteDonnees = explode(self::SEPARATEUR_DONNEES, $uniteChaineDonnees); |
| $uniteDonneesNbre = count($uniteDonnees); |
| $uniteRangement = array(); |
| if ($uniteDonneesNbre > 0) { |
| $uniteRangement['nbre'] = $uniteDonnees[0]; |
| } |
| if ($uniteRangement['nbre'] > 0) { |
| if ($uniteDonneesNbre > 1) { |
| $uniteRangement['precision'] = self::getPrecisionNom($uniteDonnees[1]); |
| } |
| if ($uniteDonneesNbre > 2) { |
| $uniteRangement['format'] = $uniteDonnees[2]; |
| } |
| if (preg_match('/^[0-9]+$/', $uniteTypeIdDonnees[0])) { |
| $uniteRangement['id'] = $uniteTypeIdDonnees[0]; |
| $uniteRangement['type'] = Ontologie::getValeurNom($uniteTypeIdDonnees[0]); |
| } else { |
| $uniteRangement['type'] = $uniteTypeIdDonnees[0]; |
| } |
| $unitesEnregistrees[] = $uniteRangement; |
| } |
| } |
| } |
| return $unitesEnregistrees; |
| } |
| private static function getPrecisionNom($precisionAbr) { |
| $precision_nom = ''; |
| if ($precisionAbr != 'NULL') { |
| // liste 79 : Liste exact/approximatif |
| $precisions = Ontologie::getListeFormatee(1082); |
| foreach ($precisions as $precision) { |
| if ($precision['abreviation'] == $precisionAbr) { |
| $precision_nom = $precision['nom']; |
| break; |
| } |
| } |
| } |
| return $precision_nom; |
| } |
| } |
| /tags/v1.13-la-grande-rue/controleurs/AppControleur.php |
|---|
| New file |
| 0,0 → 1,213 |
| <?php |
| // declare(encoding='UTF-8'); |
| /** |
| * Collection est le controlleur principal de l'application. |
| * Elle repartie les demandes utilisateurs dans les différents modules, executent les actions et redistribue le code |
| * html dans les différentes fonctions d'affichage. |
| * C'est une Singleton. |
| * |
| * @category PHP 5.2 |
| * @package Collection |
| * @author Jean-Pascal MILCENT <jpm@tela-botanica.org> |
| * @copyright 2010 Tela-Botanica |
| * @license GPL-v3 et CECILL-v2 |
| * @version $Id$ |
| */ |
| class AppControleur extends Controleur { |
| /** |
| * Instance de la classe pointant sur elle même (pour le pattern singleton) |
| */ |
| private static $instance = null; |
| /** |
| * Paramètres pour les collections |
| */ |
| private static $parametres = array(); |
| /** |
| * Constructeur vide |
| */ |
| public function __construct() { |
| $sortie = array('titre' => '', 'description' => '', 'tags' => '', |
| 'corps' => '', 'tete' => '', 'pied' => '', 'navigation' => ''); |
| $url = new Url(Config::get('url_base_index')); |
| self::$parametres = array( 'module' => 'Recherche', |
| 'action' => 'executerActionParDefaut', |
| 'sortie' => $sortie, |
| 'url' => $url); |
| parent::__construct(); |
| } |
| /** |
| * Initialisation du controleur principal en fonction des paramêtres de l'url. |
| */ |
| public static function initialiser() { |
| self::verifierCreationInstance(); |
| self::gererSession(); |
| if (isset($_GET['module'])) { |
| self::$parametres['module'] = $_GET['module']; |
| } |
| self::$parametres['url']->setVariableRequete('module', self::$parametres['module']); |
| if (isset($_GET['action'])) { |
| self::$parametres['action'] = $_GET['action']; |
| } |
| self::$parametres['url']->setVariableRequete('action', self::$parametres['action']); |
| self::initialiserRegistre(); |
| $ClasseModule = self::$parametres['module']; |
| $action = self::$parametres['action']; |
| $module = new $ClasseModule(); |
| $module->$action(); |
| self::fusionnerSortie($module->getSortie()); |
| } |
| private static function initialiserRegistre() { |
| $registre = Registre::getInstance(); |
| // Ajout des paramètres au registre |
| $registre->set('parametres', self::$parametres); |
| // Ajout du contexte au registre |
| if (isset($_GET['contexte'])) { |
| $registre->set('contexte', $_GET['contexte']); |
| } |
| } |
| private static function gererSession() { |
| if (Config::get('session_demarrage')) { |
| // Attribution d'un nom à la session |
| session_name(Config::get('session_nom')); |
| // Démarrage de la session |
| session_start(); |
| } |
| } |
| /** |
| * Fusionne un tableau de sortie par défaut avec le tableau renvoyé par l'action du module. |
| * @param array le tableau à fusionner |
| */ |
| private static function fusionnerSortie($sortie) { |
| self::$parametres['sortie'] = array_merge(self::$parametres['sortie'], $sortie); |
| } |
| /** |
| * Vérifie si l'instance de classe à été crée, si non la crée. |
| */ |
| private static function verifierCreationInstance() { |
| if (empty(self::$instance)) { |
| self::$instance = new AppControleur(); |
| } |
| } |
| /** |
| * Retourne le titre du contenu de l'application. |
| */ |
| public static function getMetaTitre() { |
| $sortie = self::$parametres['sortie']['titre']; |
| if (Config::get('sortie_encodage') != Config::get('appli_encodage')) { |
| $sortie = mb_convert_encoding($sortie, Config::get('sortie_encodage'), Config::get('appli_encodage')); |
| } |
| return $sortie; |
| } |
| /** |
| * Retourne la description du contenu de l'application. |
| */ |
| public static function getMetaDescription() { |
| $sortie = self::$parametres['sortie']['description']; |
| if (Config::get('sortie_encodage') != Config::get('appli_encodage')) { |
| $sortie = mb_convert_encoding($sortie, Config::get('sortie_encodage'), Config::get('appli_encodage')); |
| } |
| return $sortie; |
| } |
| /** |
| * Retourne les mots-clés (tags) du contenu de l'application. |
| */ |
| public static function getMetaTags() { |
| $sortie = self::$parametres['sortie']['tags']; |
| if (Config::get('sortie_encodage') != Config::get('appli_encodage')) { |
| $sortie = mb_convert_encoding($sortie, Config::get('sortie_encodage'), Config::get('appli_encodage')); |
| } |
| return $sortie; |
| } |
| /** |
| * Retourne le contenu du corps de l'application. |
| */ |
| public static function getContenuCorps() { |
| $sortie = self::$parametres['sortie']['corps']; |
| if (Config::get('sortie_encodage') != Config::get('appli_encodage')) { |
| $sortie = mb_convert_encoding($sortie, Config::get('sortie_encodage'), Config::get('appli_encodage')); |
| } |
| return $sortie; |
| } |
| /** |
| * Retourne le contenu de la tête de l'application. |
| */ |
| public static function getContenuTete() { |
| $sortie = self::$parametres['sortie']['tete']; |
| if (Config::get('sortie_encodage') != Config::get('appli_encodage')) { |
| $sortie = mb_convert_encoding($sortie, Config::get('sortie_encodage'), Config::get('appli_encodage')); |
| } |
| return $sortie; |
| } |
| /** |
| * Retourne le contenu du pied de l'application. |
| */ |
| public static function getContenuPied() { |
| $sortie = self::$parametres['sortie']['pied']; |
| if (Config::get('sortie_encodage') != Config::get('appli_encodage')) { |
| $sortie = mb_convert_encoding($sortie, Config::get('sortie_encodage'), Config::get('appli_encodage')); |
| } |
| return $sortie; |
| } |
| /** |
| * Retourne les éléments de navigation de l'application. |
| */ |
| public static function getContenuNavigation() { |
| $sortie = self::$parametres['sortie']['navigation']; |
| if (Config::get('sortie_encodage') != Config::get('appli_encodage')) { |
| $sortie = mb_convert_encoding($sortie, Config::get('sortie_encodage'), Config::get('appli_encodage')); |
| } |
| return $sortie; |
| } |
| /** |
| * Retourne le nom du module en cours (défini par GET ou par la config), |
| * pour l'intégration Wordpress notamment |
| */ |
| public static function getModule() { |
| return self::$parametres['module']; |
| } |
| /** |
| * Retourne les chronos pris dans l'appli |
| */ |
| public static function getChrono() { |
| $sortie = ''; |
| if (Config::get('chronometrage')) { |
| $chrono = Chronometre::afficherChrono(); |
| $sortie = mb_convert_encoding($chrono, Config::get('sortie_encodage'), Config::get('appli_encodage')); |
| } |
| return $sortie; |
| } |
| /** |
| * Retourne les messages d'exceptions et d'erreurs. |
| */ |
| public static function getExceptions() { |
| $sortie = (Config::get('fw_debogage')) ? GestionnaireException::getExceptions() : ''; |
| if (Config::get('sortie_encodage') != Config::get('appli_encodage')) { |
| $sortie = mb_convert_encoding($sortie, Config::get('sortie_encodage'), Config::get('appli_encodage')); |
| } |
| return $sortie; |
| } |
| } |
| Property changes: |
| Added: svn:keywords |
| +Id Author Date Revision HeadURL |
| \ No newline at end of property |
| /tags/v1.13-la-grande-rue/controleurs/aControleur.php |
|---|
| New file |
| 0,0 → 1,469 |
| <?php |
| // declare(encoding='UTF-8'); |
| /** |
| * Classe Controleur générale de l'application Collection. |
| * |
| * @category php5.2 |
| * @package Collection |
| * @author Jean-Pascal MILCENT <jpm@tela-botanica.org> |
| * @copyright 2010 Tela-Botanica |
| * @license http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt Licence CECILL |
| * @license http://www.gnu.org/licenses/gpl.html Licence GNU-GPL |
| * @version SVN: $Id$ |
| */ |
| abstract class aControleur extends Controleur { |
| const FMT_DATE = '%d/%m/%Y';// Supporte les formats de dates non valides (1989-00-00) |
| const FMT_DATE_TXT = '%A %d %B %Y'; |
| const FMT_DATE_HEURE = '%d/%m/%Y %H:%i:%s';// Supporte les formats de dates non valides (1989-00-00 00:00:00) |
| const FMT_DATE_HEURE_TXT = '%A %d %B %Y à %H:%M'; |
| const META_TITRE = 'titre'; |
| const META_DESCRIPTION = 'description'; |
| const META_TAGS = 'tags'; |
| const RENDU_TETE = 'tete'; |
| const RENDU_CORPS = 'corps'; |
| const RENDU_PIED = 'pied'; |
| const TYPE_AUTRE = 'AUTRE'; |
| const TYPE_TOTAL = 'TOTAL'; |
| const SEPARATEUR_TYPE_VALEUR = '##'; |
| const SEPARATEUR_VALEURS = ';;'; |
| const SEPARATEUR_DONNEES = '||'; |
| const VALEUR_NULL = 'NC'; |
| private $sortie = array(); |
| private $parametres = array(); |
| // FIXME : voir s'il est plus intéressant d'utiliser une méthode dans les classes filles |
| protected $url = null; |
| protected $registre = array(); |
| public function __construct() { |
| $this->registre = Registre::getInstance(); |
| $this->parametres = $this->registre->get('parametres'); |
| $this->url = $this->parametres['url']; |
| parent::__construct(); |
| } |
| /** |
| * Attribue une position de sortie à un contenu. |
| */ |
| protected function setSortie($position, $contenu, $fusionner = false) { |
| if ($this->verifierExistenceTypeSortie($position)) { |
| if ($fusionner) { |
| $this->sortie[$position] .= $contenu; |
| } else { |
| $this->sortie[$position] = $contenu; |
| } |
| } |
| } |
| /** |
| * Vérifie l'existence du type de sortie indiqué pour son utilisation dans le tableau de sortie. |
| * @param string le type de sortie à tester. |
| * @return bool true si le type de sortie est valide, sinon false. |
| */ |
| private function verifierExistenceTypeSortie($type) { |
| $existe = true; |
| if ($type != self::RENDU_TETE && |
| $type != self::RENDU_CORPS && |
| $type != self::RENDU_PIED && |
| $type != self::META_TITRE && |
| $type != self::META_DESCRIPTION && |
| $type != self::META_TAGS) { |
| trigger_error("Le type de sortie '$type' n'est pas une valeur prédéfinie.", E_USER_WARNING); |
| $existe = false; |
| } |
| return $existe; |
| } |
| /** |
| * Retourne le tableau de sortie à utiliser dans le controleur principal de l'application. |
| */ |
| public function getSortie() { |
| return $this->sortie; |
| } |
| /** |
| * Execute l'action d'un module donnée et fusionne le résultat avec le tableau de sortie. |
| */ |
| protected function executerAction($ClasseModule, $action) { |
| $module = new $ClasseModule(); |
| $module->$action(); |
| $this->fusionnerSortie($module->getSortie()); |
| } |
| /** |
| * Fusionne un tableau de sortie par défaut avec le tableau passé en paramêtre. |
| * @param array le tableau à fusionner |
| */ |
| private function fusionnerSortie($sortie) { |
| $this->sortie = array_merge($this->sortie, $sortie); |
| } |
| protected function construireTxtTruckSimple($chaine_a_analyser) { |
| return $this->construireTxtTruck($chaine_a_analyser, false, false); |
| } |
| protected function construireTxtTruckSansMajuscule($chaine_a_analyser) { |
| return $this->construireTxtTruck($chaine_a_analyser, false, true); |
| } |
| protected function construireTxtTruckSansPointFinal($chaine_a_analyser) { |
| return $this->construireTxtTruck($chaine_a_analyser, true, false); |
| } |
| protected function construireTxtTruck($chaine_a_analyser, $majuscule = true, $point_final = true) { |
| $termes = $this->traiterTxtTruck($chaine_a_analyser); |
| $chaine_a_retourner = $this->formaterTableauDeTxt($termes, $majuscule, $point_final); |
| return $chaine_a_retourner; |
| } |
| protected function traiterTxtTruck($chaine_a_analyser) { |
| $termes = array(); |
| if ((!is_null($chaine_a_analyser)) && (trim($chaine_a_analyser) != '')) { |
| $valeurs = explode(self::SEPARATEUR_VALEURS, $chaine_a_analyser); |
| $nbre_valeurs = count($valeurs); |
| if ($nbre_valeurs > 0) { |
| for ($i = 0; $i < $nbre_valeurs; $i++) { |
| $valeur = trim($valeurs[$i]); |
| if ($valeur != '') { |
| $valeur_formatee = $this->formaterValeurTruck($valeur); |
| $termes[] = $valeur_formatee; |
| } |
| } |
| } |
| } |
| return $termes; |
| } |
| protected function getTxtTruckParPosition($chaine_a_analyser, $position = 1) { |
| $retour = ''; |
| if ((!is_null($chaine_a_analyser)) && (trim($chaine_a_analyser) != '')) { |
| $valeurs = explode(self::SEPARATEUR_VALEURS, $chaine_a_analyser); |
| $nbre_valeurs = count($valeurs); |
| if ($nbre_valeurs > 0) { |
| $position = $position - 1; |
| $valeur = trim($valeurs[$position]); |
| if ($valeur != '') { |
| $retour = $this->formaterValeurTruck($valeur); |
| } |
| } |
| } |
| return $retour; |
| } |
| protected function getTableauTruck($chaine_a_analyser) { |
| $tableau_retour = array(); |
| if ((!is_null($chaine_a_analyser)) && (trim($chaine_a_analyser) != '')) { |
| $valeurs = explode(self::SEPARATEUR_VALEURS, $chaine_a_analyser); |
| $nbre_valeurs = count($valeurs); |
| if ($nbre_valeurs > 0) { |
| for ($i = 0; $i < $nbre_valeurs; $i++) { |
| $valeur = trim($valeurs[$i]); |
| if ($valeur != '') { |
| $tableau_retour[] = $valeur; |
| } |
| } |
| } |
| } |
| return $tableau_retour; |
| } |
| private function formaterValeurTruck($valeur) { |
| $chaine_a_retourner = ''; |
| if (preg_match('/^[^#]+##[^$]+$/', $valeur)) { |
| $cle_valeur = explode(self::SEPARATEUR_TYPE_VALEUR, $valeur); |
| $chaine_a_retourner = (($cle_valeur[1] == '' || $cle_valeur[1] == 'null') ? self::VALEUR_NULL : $cle_valeur[1]); |
| $chaine_a_retourner .= ' '.$this->formaterParenthese($cle_valeur[0]); |
| } else if ($valeur != '') { |
| $chaine_a_retourner = $valeur; |
| } else { |
| trigger_error("Valeur truck posant problème :$valeur", E_USER_NOTICE); |
| } |
| return $chaine_a_retourner; |
| } |
| protected function formaterParenthese($chaine_a_afficher) { |
| if ($chaine_a_afficher != '') { |
| $chaine_a_afficher = '('.$chaine_a_afficher.')'; |
| } |
| return $chaine_a_afficher; |
| } |
| protected function formaterSautDeLigne($chaine_a_formater) { |
| $txt_a_retourner = preg_replace('/\n/', '<br />', $chaine_a_formater); |
| return $txt_a_retourner; |
| } |
| protected function formaterTableauDeTxt($tableau_de_txt, $majuscule = true, $point_final = true) { |
| $chaine_a_afficher = ''; |
| $taille_du_tableau = count($tableau_de_txt); |
| if ($taille_du_tableau > 0) { |
| $index_avt_dernier = $taille_du_tableau - 1; |
| for ($i = 0; $i < $taille_du_tableau; $i++) { |
| $mot = $tableau_de_txt[$i]; |
| if ($i != $index_avt_dernier) { |
| $chaine_a_afficher .= $mot.', '; |
| } else { |
| $chaine_a_afficher .= $this->nettoyerPointFinal($mot); |
| if ($point_final) { |
| $chaine_a_afficher .= '.'; |
| } |
| } |
| } |
| } |
| if ($majuscule) { |
| $chaine_a_afficher = ucfirst($chaine_a_afficher); |
| } |
| return $chaine_a_afficher; |
| } |
| protected function formaterAutre($chaine_a_afficher) { |
| if ($chaine_a_afficher != '') { |
| $chaine_a_afficher = ' [Autre : '.$chaine_a_afficher.']'; |
| } |
| return $chaine_a_afficher; |
| } |
| protected function formaterOuiNon($chaine_a_formater) { |
| $txt_a_retourner = ''; |
| if ($chaine_a_formater == '0') { |
| $txt_a_retourner = 'non'; |
| } else if ($chaine_a_formater == '1') { |
| $txt_a_retourner = 'oui'; |
| } |
| return $txt_a_retourner; |
| } |
| protected function formaterDate($date, $format = self::FMT_DATE_HEURE, $chaineSiVide = 'Inconnue') { |
| if ($date == '' || $date == '0000-00-00' || $date == '0000-00-00 00:00:00') { |
| $date = $chaineSiVide; |
| } else { |
| if (preg_match('/^([0-9]{4})-([0-9]{2})-([0-9]{2})(?: ([0-9]{2}):([0-9]{2}):([0-9]{2})|)$/', $date, $match)) {// Date Heure |
| $annee = $match[1]; |
| $mois = $match[2]; |
| $jour = $match[3]; |
| $heure = (isset($match[4])) ? $match[4] : '00'; |
| $minute = (isset($match[5])) ? $match[5] : '00'; |
| $seconde = (isset($match[6])) ? $match[6] : '00'; |
| if ($format == self::FMT_DATE && $jour == '00' && $mois == '00') { |
| $date = $annee; |
| } else if ($format == self::FMT_DATE && $jour == '00') { |
| $date = strftime('%b', mktime(0, 0, 0, $mois, 1)).' '.$annee; |
| } else { |
| $timestamp = strtotime($date); |
| if ($timestamp !== false) { |
| $date = strftime($format, $timestamp); |
| } |
| } |
| } else { |
| $e = "La chaine '$date' n'est pas reconnue."; |
| trigger_error($e, E_USER_WARNING); |
| } |
| } |
| return $date; |
| } |
| protected function formaterCourriels($courriels) { |
| $fmt_courriels = ''; |
| if (!empty($courriels)) { |
| $courriels = (is_array($courriels)) ? $courriels : array($courriels); |
| foreach ($courriels as $cle => $courriel) { |
| $courriel = preg_replace('/@/', ' [arrobase] ', $courriel); |
| $courriel = preg_replace('/[.]([^.]+)$/', " [point] $1", $courriel); |
| $fmt_courriels[] = $this->getVue('courriel', array('courriel' => $courriel)); |
| } |
| $fmt_courriels = implode(', ', $fmt_courriels); |
| } |
| return $fmt_courriels; |
| } |
| protected function nettoyerPointFinal($mot) { |
| $mot = preg_replace('/[.]$/', '', $mot); |
| return $mot; |
| } |
| public function construireTxtListeOntologie($chaineAAnalyser, $valeurEstOntologie = true, $typeEstOntologie = true, $donneeEstOntologie = false) { |
| $termes = array(); |
| $autres = array(); |
| $chaineAAnalyser = trim($chaineAAnalyser); |
| if ($chaineAAnalyser != '') { |
| $valeurs = explode(self::SEPARATEUR_VALEURS, $chaineAAnalyser); |
| $nbreValeurs = count($valeurs); |
| if ($nbreValeurs > 0) { |
| for ($i = 0; $i < $nbreValeurs; $i++) { |
| $valeur = $valeurs[$i]; |
| // VALEUR SANS TYPE |
| // La valeur sans type est une entrée de l'ontologie |
| if ($valeurEstOntologie && preg_match('/^[0-9]+$/u', $valeur)) { |
| if ($valeur == '0') { |
| $valeur = ''; |
| } else { |
| $valeurOntologie = Ontologie::getValeur($valeur); |
| if ($valeurOntologie != '') { |
| $valeur = $valeurOntologie['nom']; |
| } |
| } |
| } |
| // VALEUR AVEC TYPE |
| // Type : AUTRE |
| $valeurTypeAutre = self::TYPE_AUTRE.self::SEPARATEUR_TYPE_VALEUR; |
| if (preg_match('/^'.$valeurTypeAutre.'.+$/u', $valeur)) { |
| $txtAutre = preg_replace('/^'.$valeurTypeAutre.'/u', '', $valeur); |
| if ($txtAutre != '') { |
| $autres[] = $txtAutre; |
| } |
| $valeur = ''; |
| } |
| // Type correspondant à une entrée de l'ontologie |
| if ($typeEstOntologie) { |
| $valeurTypeOntologie = '([0-9]+)'.self::SEPARATEUR_TYPE_VALEUR; |
| $valeurTypeAutre = '([[:alnum:]]+)'.self::SEPARATEUR_TYPE_VALEUR; |
| if (preg_match('/^'.$valeurTypeOntologie.'.*$/u', $valeur, $match)) {// Cas type : réf. numérique |
| $type = $match[1]; |
| $valeurOntologieNom = Ontologie::getValeurNom($type); |
| if ($valeurOntologieNom !== false) { |
| $valeurOntologieNom .= ' : '; |
| $valeur = preg_replace('/^'.$type.'/u', $valeurOntologieNom, $valeur); |
| } |
| } else if (preg_match('/^'.$valeurTypeAutre.'.*$/u', $valeur, $match)) {// Cas type : AUTRE |
| $type = $match[1]; |
| $valeur = preg_replace('/^'.$type.'/u', $type.' : ', $valeur); |
| } |
| } |
| // Donnée correspondant à une entrée de l'ontologie |
| if ($donneeEstOntologie) { |
| $donneeOntologie = self::SEPARATEUR_TYPE_VALEUR.'([0-9]+)'; |
| if (preg_match('/^.+'.$donneeOntologie.'$/u', $valeur, $match)) { |
| $donnee = $match[1]; |
| $donnee = str_replace(self::SEPARATEUR_TYPE_VALEUR, '', $donnee); |
| $valeurOntologieNom = Ontologie::getValeurNom($donnee); |
| if ($valeurOntologieNom !== false) { |
| $valeur = preg_replace('/'.$donnee.'$/u', $valeurOntologieNom, $valeur); |
| } |
| } |
| } |
| // Nettoyage final |
| $valeur = preg_replace('/'.self::SEPARATEUR_TYPE_VALEUR.'/', '', $valeur); |
| if ($valeur != '') { |
| $termes[] = $valeur; |
| } |
| } |
| } |
| } |
| $chaineTermes = $this->formaterTableauDeTxt($termes); |
| $chaineAutres = $this->formaterTableauDeTxt($autres); |
| $chaineARetourner = $chaineTermes.$this->formaterAutre($chaineAutres); |
| return $chaineARetourner; |
| } |
| protected function obtenirUrlRecherche($txt = null) { |
| $this->url->setRequete(false); |
| if (!is_null($this->registre->get('contexte'))) { |
| $this->url->setVariableRequete('contexte', $this->registre->get('contexte')); |
| } |
| $this->url->setVariableRequete('module', 'Recherche'); |
| $this->url->setVariableRequete('action', 'rechercher'); |
| if (!is_null($txt)) { |
| $this->url->setVariableRequete('recherche', $txt); |
| } |
| $url = $this->url->getURL(); |
| $this->url->unsetVariablesRequete(array('module', 'action', 'recherche')); |
| return $url; |
| } |
| protected function obtenirUrlFicheStructure($id_structure) { |
| $url = $this->obtenirObjetUrlFicheStructure($id_structure); |
| return $url->getURL(); |
| } |
| protected function obtenirObjetUrlFicheStructure($id_structure) { |
| $this->url->setRequete(false); |
| if (!is_null($this->registre->get('contexte'))) { |
| $this->url->setVariableRequete('contexte', $this->registre->get('contexte')); |
| } |
| $this->url->setVariableRequete('module', 'FicheStructure'); |
| $this->url->setVariableRequete('id', $id_structure); |
| $url = clone $this->url; |
| $this->url->unsetVariablesRequete(array('module', 'id')); |
| return $url; |
| } |
| protected function obtenirUrlFicheCollection($id_collection) { |
| $url = $this->obtenirObjetUrlFicheCollection($id_collection); |
| return $url->getURL(); |
| } |
| protected function obtenirObjetUrlFicheCollection($id_collection) { |
| $this->url->setRequete(false); |
| if (!is_null($this->registre->get('contexte'))) { |
| $this->url->setVariableRequete('contexte', $this->registre->get('contexte')); |
| } |
| $this->url->setVariableRequete('module', 'FicheCollection'); |
| $this->url->setVariableRequete('id', $id_collection); |
| $url = clone $this->url; |
| $this->url->unsetVariablesRequete(array('module', 'id')); |
| return $url; |
| } |
| protected function obtenirUrlFichePersonne($id_personne) { |
| $url = $this->obtenirObjetUrlFichePersonne($id_personne); |
| return $url->getURL(); |
| } |
| protected function obtenirObjetUrlFichePersonne($id_personne) { |
| $this->url->setRequete(false); |
| if (!is_null($this->registre->get('contexte'))) { |
| $this->url->setVariableRequete('contexte', $this->registre->get('contexte')); |
| } |
| $this->url->setVariableRequete('module', 'FichePersonne'); |
| $this->url->setVariableRequete('id', $id_personne); |
| $url = clone $this->url; |
| $this->url->unsetVariablesRequete(array('module', 'id')); |
| return $url; |
| } |
| protected function obtenirPermalienGuid($guid) { |
| $url = Config::get('url_base_permalien'); |
| $url .= (substr($url, -1, 1) == '/') ? '' : '/'; |
| $url .= $guid; |
| return $url; |
| } |
| protected function postraiterDonnees(&$tableau) { |
| if (count($tableau) > 0) { |
| foreach ($tableau as $cle => &$valeur) { |
| // ajout d'un nbsp pour ne pas fausser l'affichage du template |
| // afin que les <dd> et <dt> aient la même largeur |
| if ($valeur == '') { |
| $valeur = ' '; |
| } else if (is_string($valeur)) { |
| $valeur = $this->remplacerEsperluette($valeur); |
| } else if (is_array($valeur)) { |
| $this->postraiterDonnees($valeur); |
| } |
| } |
| } |
| } |
| private function remplacerEsperluette($txt) { |
| $txt = preg_replace('/&(?!([a-z]+|#[0-9]+|#x[0-9a-f]+);)/i', '&', $txt, -1); |
| return $txt; |
| } |
| protected function chargerPiedDePage() { |
| $donnees['appli'] = Application::getInfo(); |
| $donnees['url_base_widget_remarques'] = Config::get('url_base_widget_remarques'); |
| $this->setSortie(self::RENDU_PIED, $this->getVue('pied', $donnees)); |
| } |
| } |
| Property changes: |
| Added: svn:keywords |
| +Id Author Date Revision HeadURL |
| \ No newline at end of property |