| /branches/v1.11-okuzgozu/jrest/services/CoelCollectionACommentaire.php |
|---|
| New file |
| 0,0 → 1,201 |
| <?php |
| /** |
| * Service fournissant la liste des relations "structure à personne". |
| * Encodage en entrée : utf8 |
| * Encodage en sortie : utf8 |
| * |
| * @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 $Id$ |
| * @copyright 2009 |
| */ |
| class CoelCollectionACommentaire extends Coel { |
| const MODE_SUPPRESSION_PAR_COLLECTION = 'SuppressionParCollection'; |
| const MODE_SUPPRESSION_PAR_COMMENTAIRE = 'SuppressionParCommentaire'; |
| /** Contient les infos sur les tables gérées par ce service. |
| * Bien respecter l'ordre avec en premier les tables liées et en dernier la table établissant la relation. */ |
| protected $tables = array( 102 => array( 'nom' => 'coel_collection_a_commentaire', |
| 'prefixe' => 'ccac', |
| 'id' => array('ccac_id_collection', 'ccac_id_commentaire'))); |
| /** |
| * Méthode appelée avec une requête de type GET. |
| */ |
| public function getElement($param = array()) { |
| // Initialisation des variables |
| $info = array(); |
| // Pré traitement des paramêtres |
| $p = $this->traiterParametresUrl(array('id_collection', 'mark_public'), $param); |
| // Construction de la requête |
| $requete = (($this->distinct) ? 'SELECT DISTINCT ' : 'SELECT '). |
| ' ccac.*, ccm.* '. |
| 'FROM coel_collection_a_commentaire AS ccac '. |
| ' LEFT JOIN coel_meta_historique_ligne ON (ccac_ce_meta = cmhl_id_historique_ligne) '. |
| ' LEFT JOIN coel_commentaire AS ccm ON (ccac_id_commentaire = ccm_id_commentaire) '. |
| ((count($p) != 0) ? 'WHERE ' : ''). |
| (isset($p['id_collection']) ? "AND ccac_id_collection = {$p['id_collection']} " : ''). |
| (isset($p['mark_public']) ? "AND ccm_mark_public = {$p['mark_public']} " : ''). |
| 'ORDER BY '.((!is_null($this->orderby)) ? $this->orderby : 'ccac_ce_meta DESC').' '; |
| $requete = str_replace('WHERE AND', 'WHERE', $requete); |
| $requeteCount = $requete; |
| $requete .= "LIMIT $this->start, $this->limit "; |
| // Récupération des résultats |
| try { |
| $donnees = $this->bdd->query($requete)->fetchAll(PDO::FETCH_ASSOC); |
| if ($donnees === false) { |
| $this->messages[] = "La requête a retourné aucun résultat."; |
| } |
| $nbElements = $this->bdd->query($requeteCount)->rowCount(); |
| $info['nbElements'] = $nbElements; |
| $info['collectionsACommentaire'] = $donnees; |
| } catch (PDOException $e) { |
| $this->messages[] = sprintf($this->getTxt('sql_erreur'), $e->getFile(), $e->getLine(), $e->getMessage()); |
| } |
| // Envoie sur la sortie standard |
| $this->envoyer($info); |
| } |
| /** |
| * Méthode appelée pour ajouter un élément. |
| */ |
| public function createElement($params) { |
| // Identification de l'utilisateur |
| list($id_utilisateur, $id_session) = $this->getIdentification($params); |
| // Contrôle du non détournement de l'utilisateur |
| if ($this->etreAutorise($id_utilisateur)) { |
| // Vérification des tables à vraiment mettre à jour en fonction des données passées. |
| $tables_a_modifier = $this->recupererTablesAModifier($params); |
| try { |
| // Pour chaque table du module nous lançons si nécessaire l'historisation puis la mise à jour |
| // Nous ne pouvons pas utiliser foreach car il travaille sur une copie du tableau or nous le modifions dynamiquement dans la boucle |
| reset($tables_a_modifier); |
| while (list($table_id, $table) = each($tables_a_modifier)) { |
| if (!is_null($table['champs'])) { |
| if (!$this->avoirCleComplete($table)) { |
| $this->messages[] = 'Il est nécessaire de fournir toutes les clés à ce service.'; |
| } else { |
| $this->mettreAJourAvecCle($id_utilisateur, $id_session, $table_id, $table); |
| } |
| } |
| } |
| } catch (PDOException $e) { |
| $this->messages[] = sprintf($this->getTxt('sql_erreur'), $e->getFile(), $e->getLine(), $e->getMessage()); |
| } |
| } else { |
| $this->messages[] = "Il faut être identifié pour accéder à ce service"; |
| } |
| // Envoie sur la sortie standard |
| $this->envoyer(); |
| } |
| /** |
| * Méthode appelée pour mettre à jour un élément |
| */ |
| public function updateElement($uid, $params) { |
| // Vérification de la présence des id passés par l'url |
| if (!isset($uid[0]) && !isset($uid[1])) { |
| $this->messages[] = 'Aucun identifiant de collection a été passé. Vous ne devriez pas avoir accès à ce service.'; |
| } else { |
| // Identification de l'utilisateur |
| list($id_utilisateur, $id_session) = $this->getIdentification($params); |
| // Contrôle du non détournement de l'utilisateur |
| if ($this->etreAutorise($id_utilisateur)) { |
| // Vérification des tables à vraiment mettre à jour en fonction des données passées. |
| $tables_a_modifier = $this->recupererTablesAModifier($params); |
| try { |
| // Pour chaque table du module nous lançons si nécessaire l'historisation puis la mise à jour |
| foreach ($tables_a_modifier as $table_id => $table) { |
| $this->mettreAJourAvecCle($id_utilisateur, $id_session, $table_id, $table); |
| } |
| } catch (PDOException $e) { |
| $this->messages[] = sprintf($this->getTxt('sql_erreur'), $e->getFile(), $e->getLine(), $e->getMessage(), $requete); |
| } |
| } |
| } |
| // Envoie sur la sortie standard |
| $this->envoyer(); |
| } |
| /** |
| * Méthode appelée pour supprimer un ou plusieurs éléments |
| */ |
| public function deleteElement($uid) { |
| // NOTES : la suppression ne supprime pas les personnes mais seulements les relations |
| // Vérification de la présence des id passés par l'url |
| if (!isset($uid[0]) || !isset($uid[1])) { |
| $this->messages[] = "Identifiant de relations ou d'utilisateur manquant. Vous ne devriez pas avoir accès à ce service."; |
| } else { |
| // Identification de l'utilisateur |
| list($id_utilisateur, $id_session) = $this->getIdentification($uid[0]); |
| // Mode de suppression |
| $mode_de_suppression = ''; |
| if (isset($uid[2])) { |
| $mode_de_suppression = $uid[2]; |
| } |
| // Contrôle du non détournement de l'utilisateur |
| if ($this->etreAutorise($id_utilisateur)) { |
| // Récupération des identifiant à supprimer |
| $identifiants = array(); |
| $identifiants_agreges = explode(',', rtrim($uid[1], ',')); |
| foreach ($identifiants_agreges as $identifiant) { |
| $identifiants[] = explode('-', $identifiant); |
| } |
| if (count($identifiants) == 0) { |
| $this->messages[] = "Aucun enregistrement n'a été supprimé."; |
| } else { |
| try { |
| foreach ($identifiants as $id) { |
| if (count($id) == 1) { // Seulement des id de collection |
| if ($mode_de_suppression == MODE_SUPPRESSION_PAR_COLLECTION) { |
| $params = array('ccac_id_collection' => $id[0]); |
| } else if ($mode_de_suppression == MODE_SUPPRESSION_PAR_COMMENTAIRE) { |
| $params = array('ccac_id_commentaire' => $id[0]); |
| } else { |
| $params = array('ccac_id_collection' => $id[0]); |
| } |
| } else if (count($id) == 2) { // Tous les id... |
| $params = array('ccac_id_collection' => $id[0], 'ccac_id_commentaire' => $id[1]); |
| } |
| $tables_a_modifier = $this->recupererTablesAModifier($params); |
| $table = $tables_a_modifier[102]; |
| if ($this->avoirEnregistrement($table)) { |
| $resultat = $this->supprimer($table); |
| if ($resultat === true) { |
| // Historisation (Ajout des méta-données) |
| $cle = $this->recupererCle($table); |
| $this->historiser(102, $cle, 'NULL', $id_utilisateur, Coel::ETAT_SUPPRIMER, $id_session); |
| } |
| } |
| } |
| } catch (PDOException $e) { |
| $this->messages[] = sprintf($this->getTxt('sql_erreur'), $e->getFile(), $e->getLine(), $e->getMessage(), $requete); |
| } |
| } |
| } |
| } |
| // Envoie sur la sortie standard |
| $this->envoyer(); |
| } |
| } |
| ?> |
| /branches/v1.11-okuzgozu/jrest/services/CoelExport.php |
|---|
| New file |
| 0,0 → 1,334 |
| <?php |
| /** |
| * Service exportant des informations concernant COEL au format CSV. |
| * Encodage en entrée : utf8 |
| * Encodage en sortie : utf8 |
| * |
| * @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 $Id$ |
| * @copyright 2010 |
| */ |
| class CoelExport extends Coel { |
| const META_LISTE_STOCK_PARAMS = 1020;// Liste des paramètres de contrôle environnemental d'un local |
| const META_LISTES_EXPERTISE_COLLECTION = '1040,1041,1043,1045,1046,1049,1050,1053,1057,1081';// Liste des métadonnées pour les informations des des collections |
| private $format = null; |
| private $service = null; |
| private $squelette = null; |
| private $squelette_dossier = null; |
| /** |
| * Méthode appelée avec une requête de type GET. |
| */ |
| public function getElement($params = array()) { |
| // Initialisation des variables |
| $info = array(); |
| $contenu = ''; |
| // Pré traitement des paramêtres |
| $pour_bdd = false; |
| $this->parametres = $this->traiterParametresUrl(array('service', 'format'), $params, $pour_bdd); |
| // Chargement du bon type de service demandé |
| if (isset($this->parametres['service'])) { |
| $this->service = strtolower($this->parametres['service']); |
| $methode = $this->getNomMethodeService(); |
| if (method_exists($this, $methode)) { |
| if (isset($this->parametres['format']) && preg_match('/^(?:csv|txt)$/i', $this->parametres['format'])) { |
| // Mise en minuscule de l'indication du format |
| $this->format = strtolower($this->parametres['format']); |
| // Définition du fichier squelette demandé |
| $this->definirSquelette(); |
| } else { |
| $this->format = ''; |
| $this->messages[] = "Le service COEL Export nécessite d'indiquer en second paramètre le format : csv, txt."; |
| } |
| // Récupération du contenu à renvoyer |
| $contenu = $this->$methode(); |
| } else { |
| $this->messages[] = "Le type d'information demandé '$this->service' n'est pas disponible."; |
| } |
| } else { |
| $this->messages[] = "Le service COEL Syndication nécessite d'indiquer en premier paramètre le type d'information demandé."; |
| } |
| // Envoie sur la sortie standard |
| $encodage = 'utf-8'; |
| $mime = $this->getTypeMime(); |
| $formatage_json = $this->getFormatageJson(); |
| $this->envoyer($contenu, $mime, $encodage, $formatage_json); |
| } |
| private function definirSquelette() { |
| $this->squelette_dossier = dirname(__FILE__).DIRECTORY_SEPARATOR.'squelettes'.DIRECTORY_SEPARATOR; |
| $ext = $this->getExtensionFichierSquelette(); |
| $this->squelette = $this->squelette_dossier.'export_'.$this->service.'.tpl.'.$ext; |
| } |
| private function getExtensionFichierSquelette() { |
| $ext = ''; |
| switch ($this->format) { |
| case 'csv' : |
| case 'txt' : |
| $ext = 'csv'; |
| break; |
| default: |
| $ext = 'csv'; |
| } |
| return $ext; |
| } |
| private function getNomMethodeService() { |
| $methode = ''; |
| $service_formate = str_replace(' ', '', ucwords(implode(' ', explode('_', $this->service)))); |
| $methode = 'getService'.$service_formate; |
| return $methode; |
| } |
| private function getTypeMime() { |
| $mime = ''; |
| switch ($this->format) { |
| case 'csv' : |
| $mime = 'text/csv'; |
| break; |
| case 'txt' : |
| $mime = 'text/plain'; |
| break; |
| default: |
| $mime = 'text/html'; |
| } |
| return $mime; |
| } |
| private function getFormatageJson() { |
| $json = false; |
| switch ($this->service) { |
| default: |
| $json = false; |
| } |
| return $json; |
| } |
| private function getServiceStructureExpertise() { |
| $donnees = array(); |
| // Construction de la requête |
| $requete = 'SELECT '.(($this->distinct) ? 'DISTINCT' : '').' '. |
| ' cs_id_structure, cs_nom, cs_description, cs_adresse_01, cs_code_postal, cs_ville, cs_courriel, '. |
| ' cs_truk_telephone, cs_truk_url,'. |
| ' SUM(csap_bota_travail_hebdo_tps) AS personnel_heure_nbre, '. |
| ' csc_truk_stockage_parametre, cmlv_nom, csv_mark_visite_avec_motif '. |
| 'FROM coel_structure '. |
| ' LEFT JOIN coel_structure_a_personne ON (cs_id_structure = csap_id_structure) '. |
| ' LEFT JOIN coel_structure_conservation ON (cs_id_structure = csc_id_structure) '. |
| ' LEFT JOIN coel_structure_valorisation ON (cs_id_structure = csv_id_structure) '. |
| ' LEFT JOIN coel_meta_liste_valeur on `cmlv_id_valeur` =`cs_ce_truk_type_public`'. |
| 'GROUP BY cs_id_structure '. |
| 'ORDER BY '.((!is_null($this->orderby)) ? $this->orderby : 'cs_nom ASC').' '; |
| $message_echec = "La requête n'a retourné aucun résultat."; |
| $structures = $this->executerRequete($requete, $message_echec); |
| // Construction de la requête |
| $requete = 'SELECT '.(($this->distinct) ? 'DISTINCT' : '').' '. |
| ' cs_id_structure, '. |
| ' COUNT(cc_id_collection) AS collection_nbre '. |
| 'FROM coel_structure '. |
| ' LEFT JOIN coel_collection ON (cs_id_structure = cc_ce_structure) '. |
| 'GROUP BY cs_id_structure '; |
| $message_echec = "La requête comptant le nombre de collections n'a retourné aucun résultat."; |
| $collections_nbre = $this->executerRequete($requete, $message_echec); |
| // Récupération des métadonnées nécessaires |
| $requete = 'SELECT cmlv_id_valeur, cmlv_nom, cmlv_abreviation '. |
| 'FROM coel_meta_liste_valeur '. |
| 'WHERE cmlv_ce_parent = '.self::META_LISTE_STOCK_PARAMS.' '; |
| $message_echec = "La requête de recherche des métadonnées a retourné aucun résultat."; |
| $metadonnees = $this->executerRequete($requete, $message_echec); |
| // Traitement des données |
| if ($structures !== false) { |
| // Traitement du nombre de collection par structure |
| $collections_par_structure = array(); |
| foreach ($collections_nbre as $collection) { |
| $nbre = (empty($collection['collection_nbre'])) ? 0 : $collection['collection_nbre']; |
| $collections_par_structure[$collection['cs_id_structure']] = $nbre; |
| } |
| // Instanciation des objets nécessaires aux traitements |
| $ontologie = new Ontologie($metadonnees); |
| $utilTruck = new UtilTruck($ontologie); |
| // Traitement final des données concernant les structures |
| foreach ($structures as $structure) { |
| $id_structure = $structure['cs_id_structure']; |
| $nom = $structure['cs_nom']; |
| $description = $structure['cs_description']; |
| $adresse_01 = $structure['cs_adresse_01']; |
| $code_postal = $structure['cs_code_postal']; |
| $ville = $structure['cs_ville']; |
| $telephone = $utilTruck->construireTxtListeOntologie($structure['cs_truk_telephone']); |
| $courriel = $structure['cs_courriel']; |
| $type = $structure['cmlv_nom']; |
| $url = $utilTruck->construireTxtListeOntologie($structure['cs_truk_url']); |
| $stockage_params = $utilTruck->construireTxtListeOntologie($structure['csc_truk_stockage_parametre']); |
| $stockage_params_nbre = $utilTruck->getNbreValeur($structure['csc_truk_stockage_parametre']); |
| $stockage_params_nbre = empty($stockage_params_nbre) ? 0 : $stockage_params_nbre; |
| $collection_nbre = $collections_par_structure[$structure['cs_id_structure']]; |
| $collection_nbre = empty($collection_nbre) ? 0 : $collection_nbre; |
| // désactivé à la demande de Louise - 01/09/2014 |
| //$personnel_heure_nbre = empty($structure['personnel_heure_nbre']) ? 0 : $structure['personnel_heure_nbre']; |
| //$visite_avec_motif_science = $structure['csv_mark_visite_avec_motif']; |
| $structure_affichage = array( |
| 'nom' => $nom, |
| 'description' => $description, |
| 'adresse' => $adresse_01, |
| 'code_postal' => $code_postal, |
| 'ville' => $ville, |
| 'telephone' => $telephone, |
| 'courriel' => $courriel, |
| 'url' => $url, |
| 'type' => $type, |
| 'stockage_params' => $stockage_params, |
| 'stockage_params_nbre' => $stockage_params_nbre, |
| 'collection_nbre' => $collection_nbre, |
| //'personnel_heure_nbre' => $personnel_heure_nbre, |
| //'visite_avec_motif_science' => $visite_avec_motif_science |
| ); |
| $structure_affichage = $this->nettoyerTableau($structure_affichage); |
| $donnees['structures'][$id_structure] = $structure_affichage; |
| } |
| } |
| // Création du contenu |
| $contenu = $this->executerService($donnees); |
| return $contenu; |
| } |
| private function getServiceCollectionExpertise() { |
| // Construction de la requête |
| $requete = 'SELECT '.(($this->distinct) ? 'DISTINCT' : '').' '. |
| ' cc_id_collection, '. |
| ' cc_ce_structure, '. |
| ' cc_nom, cc_cote, cs_nom, cc_ce_specimen_type, cc_description, cc_periode_constitution_debut, cc_periode_constitution_fin, '. |
| ' cc_truk_couverture_lieu, ccb_truk_etiquette_renseignement, ccb_truk_nature, '. |
| ' ccb_nb_planches_herbiers, ccb_nb_especes, ccb_ce_etat_general, ccb_specimen_fixation_pourcent, '. |
| ' ccb_truk_specimen_fixation_methode, ccb_truk_etiquette_fixation_support, '. |
| ' ccb_truk_etiquette_fixation_specimen, ccb_truk_degradation_presentation, '. |
| ' ccb_ce_classement_etat, ccb_ce_inventaire '. |
| 'FROM coel_collection '. |
| ' LEFT JOIN coel_collection_botanique ON (cc_id_collection = ccb_id_collection) '. |
| ' LEFT JOIN coel_structure ON (cs_id_structure = cc_ce_structure) '. |
| 'ORDER BY '.((!is_null($this->orderby)) ? $this->orderby : 'cc_nom ASC').' '; |
| $message_echec = "La requête a retourné aucun résultat."; |
| $collections = $this->executerRequete($requete, $message_echec); |
| // Récupération des métadonnées nécessaires |
| $requete = 'SELECT cmlv_id_valeur, cmlv_ce_parent, cmlv_nom, cmlv_abreviation '. |
| 'FROM coel_meta_liste_valeur '. |
| 'WHERE cmlv_ce_parent IN ('.self::META_LISTES_EXPERTISE_COLLECTION.') '; |
| $message_echec = "La requête de recherche des métadonnées a retourné aucun résultat."; |
| $metadonnees = $this->executerRequete($requete, $message_echec); |
| // Traitement des données |
| $donnees = array(); |
| if ($collections !== false) { |
| // Instanciation des objets nécessaires aux traitements |
| $ontologie = new Ontologie($metadonnees); |
| $utilTruck = new UtilTruck($ontologie); |
| $etat_ontologie = array("" =>"", "0" => "", "1" => "Très mauvais état", "2" => "Mauvais état", "3" => "État moyen", |
| "4" => "Bon état", "5" => "Très bon état"); |
| // Traitement final des données concernant les structures |
| foreach ($collections as $collection) { |
| $id_collection = $collection['cc_id_collection']; |
| $nom = $collection['cc_nom']; |
| $cote = $collection['cc_cote']; |
| $id_structure = $collection['cc_ce_structure']; |
| $nom_structure = $collection['cs_nom']; |
| $specimen_type = $utilTruck->construireTxtListeOntologie($collection['cc_ce_specimen_type']); |
| $description = $collection['cc_description']; |
| $couverture_lieu = $utilTruck->construireTxtListeOntologie($collection['cc_truk_couverture_lieu']); |
| $specimen_fixation_pourcent = $collection['ccb_specimen_fixation_pourcent']; |
| $specimen_fixation_methode = $utilTruck->construireTxtListeOntologie($collection['ccb_truk_specimen_fixation_methode']); |
| $etiquette_renseignement = $utilTruck->construireTxtListeOntologie($collection['ccb_truk_etiquette_renseignement']); |
| $nature = $utilTruck->construireTxtListeOntologie($collection['ccb_truk_nature']); |
| $etat_general = $etat_ontologie[$collection['ccb_ce_etat_general']]; |
| $etiquette_fixation_support = $utilTruck->construireTxtListeOntologie($collection['ccb_truk_etiquette_fixation_support']); |
| $etiquette_fixation_specimen = $utilTruck->construireTxtListeOntologie($collection['ccb_truk_etiquette_fixation_specimen']); |
| $degradation_presentation = $utilTruck->construireTxtListeOntologie($collection['ccb_truk_degradation_presentation'], false, true, true); |
| $classement_etat = $utilTruck->construireTxtListeOntologie($collection['ccb_ce_classement_etat']); |
| $inventaire = $utilTruck->construireTxtListeOntologie($collection['ccb_ce_inventaire']); |
| $collection_affichage = array( |
| 'id' => $id_collection, |
| 'cote' => $cote, |
| 'nom' => $nom, |
| 'nom_structure' => $nom_structure, |
| 'id_structure' => $id_structure, |
| 'specimen_type' => $specimen_type, |
| 'description' => $description, |
| 'periode_constitution_debut' => $collection['cc_periode_constitution_debut'], |
| 'periode_constitution_fin' => $collection['cc_periode_constitution_fin'], |
| 'couverture_lieu' => $couverture_lieu, |
| 'etiquette_renseignement' => $etiquette_renseignement, |
| 'nature' => $nature, |
| 'nombre_planches_herbier' => $collection['ccb_nb_planches_herbiers'], |
| 'etat_general' => $etat_general, |
| 'etiquette_fixation_support' => $etiquette_fixation_support, |
| 'etiquette_fixation_specimen' => $etiquette_fixation_specimen, |
| 'specimen_fixation_pourcent' => $specimen_fixation_pourcent, |
| 'specimen_fixation_methode' => $specimen_fixation_methode, |
| 'degradation_presentation' => $degradation_presentation, |
| 'classement_etat' => $classement_etat, |
| 'inventaire' => $inventaire); |
| $collection_affichage = $this->nettoyerTableau($collection_affichage); |
| $donnees['collections'][] = $collection_affichage; |
| } |
| $donnees['champs'] = array_keys(current($donnees['collections'])); |
| } |
| // Création du contenu |
| $contenu = $this->executerService($donnees); |
| return $contenu; |
| } |
| private function executerRequete($requete, $message_echec) { |
| try { |
| $infos = $this->bdd->query($requete)->fetchAll(PDO::FETCH_ASSOC); |
| if ($infos === false) { |
| $this->messages[] = $message_echec; |
| } |
| } catch (PDOException $e) { |
| $this->messages[] = sprintf($this->getTxt('sql_erreur_requete'), $e->getFile(), $e->getLine(), $e->getMessage(), $requete); |
| } |
| return $infos; |
| } |
| private function executerService($donnees) { |
| // Création du contenu à partir d'un template PHP |
| $contenu = Coel::traiterSquelettePhp($this->squelette, $donnees); |
| return $contenu; |
| } |
| private function nettoyerTableau(Array $tableau) { |
| foreach ($tableau as $cle => $valeur) { |
| $tableau[$cle] = self::nettoyerGuillemets($valeur); |
| } |
| return $tableau; |
| } |
| private static function nettoyerGuillemets($txt) { |
| $txt = preg_replace('/"/', '""', $txt); |
| return $txt; |
| } |
| } |
| /branches/v1.11-okuzgozu/jrest/services/bibliotheque/UtilTruck.php |
|---|
| New file |
| 0,0 → 1,284 |
| <?php |
| /** |
| * Classe permettant de traiter plus facilement les champs dégueulasses de la base de données COEL. |
| * |
| * @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 $Id$ |
| * @copyright 2010 |
| */ |
| class UtilTruck { |
| const TYPE_AUTRE = 'AUTRE'; |
| const TYPE_TOTAL = 'TOTAL'; |
| const SEPARATEUR_TYPE_VALEUR = '##'; |
| const SEPARATEUR_VALEURS = ';;'; |
| const SEPARATEUR_DONNEES = '||'; |
| const VALEUR_NULL = 'NC'; |
| private $ontologie = null; |
| public function __construct(Ontologie $ontologie = null) { |
| $this->setOntologie($ontologie); |
| } |
| public function setOntologie(Ontologie $ontologie) { |
| $this->ontologie = $ontologie; |
| } |
| public function construireTxtTruckSimple($chaine_a_analyser) { |
| return $this->construireTxtTruck($chaine_a_analyser, false, false); |
| } |
| public static function construireTxtTruckSansMajuscule($chaine_a_analyser) { |
| return $this->construireTxtTruck($chaine_a_analyser, false, true); |
| } |
| public function construireTxtTruckSansPointFinal($chaine_a_analyser) { |
| return $this->construireTxtTruck($chaine_a_analyser, true, false); |
| } |
| private function construireTxtTruck($chaine_a_analyser, $majuscule = true, $point_final = true) { |
| $termes = $this->traiterTxtTruck($chaine_a_analyser); |
| $chaine_a_retourner = self::formaterTableauDeTxt($termes, $majuscule, $point_final); |
| return $chaine_a_retourner; |
| } |
| public 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; |
| } |
| public 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; |
| } |
| public 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; |
| } |
| public function getNbreValeur($chaine_a_analyser) { |
| $nbre_valeurs = null; |
| if ((!is_null($chaine_a_analyser)) && (trim($chaine_a_analyser) != '')) { |
| $valeurs = explode(self::SEPARATEUR_VALEURS, $chaine_a_analyser); |
| $nbre_valeurs = count($valeurs); |
| } |
| return $nbre_valeurs; |
| } |
| 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; |
| } |
| public function formaterParenthese($chaine_a_afficher) { |
| if ($chaine_a_afficher != '') { |
| $chaine_a_afficher = '('.$chaine_a_afficher.')'; |
| } |
| return $chaine_a_afficher; |
| } |
| public static function formaterTableauDeTxt(Array $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 .= self::nettoyerPointFinal($mot); |
| if ($point_final) { |
| $chaine_a_afficher .= '.'; |
| } |
| } |
| } |
| } |
| if ($majuscule) { |
| $chaine_a_afficher = ucfirst($chaine_a_afficher); |
| } |
| return $chaine_a_afficher; |
| } |
| private static function formaterAutre($chaine_a_afficher) { |
| if ($chaine_a_afficher != '') { |
| $chaine_a_afficher = ' [Autre : '.$chaine_a_afficher.']'; |
| } |
| return $chaine_a_afficher; |
| } |
| private static 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; |
| } |
| private static 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 { |
| if (isset($this->ontologie)) { |
| $valeurOntologie = $this->ontologie->getTableauValeur($valeur); |
| if (isset($valeurOntologie)) { |
| $valeur = $valeurOntologie['nom']; |
| } |
| } else { |
| $e = "Veuillez définir l'ontologie à utiliser en employant la méthode setOntologie()."; |
| trigger_error($e, E_USER_WARNING); |
| } |
| } |
| } |
| // 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]; |
| if (isset($this->ontologie)) { |
| $valeurOntologieNom = $this->ontologie->getNom($type); |
| if (isset($valeurOntologieNom)) { |
| $valeurOntologieNom .= ' : '; |
| $valeur = preg_replace('/^'.$type.'/u', $valeurOntologieNom, $valeur); |
| } |
| } else { |
| $e = "Veuillez définir l'ontologie à utiliser en employant la méthode setOntologie()."; |
| trigger_error($e, E_USER_WARNING); |
| } |
| } 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); |
| if (isset($this->ontologie)) { |
| $valeurOntologieNom = $this->ontologie->getNom($donnee); |
| if (isset($valeurOntologieNom)) { |
| $valeur = preg_replace('/'.$donnee.'$/u', $valeurOntologieNom, $valeur); |
| } |
| } else { |
| $e = "Veuillez définir l'ontologie à utiliser en employant la méthode setOntologie()."; |
| trigger_error($e, E_USER_WARNING); |
| } |
| } |
| } |
| // Nettoyage final |
| $valeur = preg_replace('/'.self::SEPARATEUR_TYPE_VALEUR.'/', '', $valeur); |
| if ($valeur != '') { |
| $termes[] = $valeur; |
| } |
| } |
| } |
| } |
| $chaineTermes = self::formaterTableauDeTxt($termes); |
| $chaineAutres = self::formaterTableauDeTxt($autres); |
| $chaineARetourner = $chaineTermes.self::formaterAutre($chaineAutres); |
| return $chaineARetourner; |
| } |
| public static function extraireNbrePart($truk_unite_base) { |
| $types = explode(self::SEPARATEUR_VALEURS, $truk_unite_base); |
| $nbre = 0; |
| foreach ($types as $type) { |
| $unite_base = explode(self::SEPARATEUR_TYPE_VALEUR, $type); |
| $nbre_part = 0; |
| if (isset($unite_base[1])) { |
| $unite_base_info = explode('||', $unite_base[1]); |
| $nbre_part = $unite_base_info[3]; |
| } |
| $nbre += $nbre_part; |
| } |
| return $nbre; |
| } |
| } |
| /branches/v1.11-okuzgozu/jrest/services/bibliotheque/WdHTMLParser.php |
|---|
| New file |
| 0,0 → 1,144 |
| <?php |
| /** |
| * |
| * @author Olivier Laviale |
| * @see http://www.weirdog.com/blog/php/un-parser-html-des-plus-leger.html |
| * |
| */ |
| class WdHTMLParser { |
| private $encoding; |
| private $matches; |
| private $escaped; |
| private $opened = array(); |
| public $malformed; |
| public function parse($html, $namespace=NULL, $encoding='utf-8') { |
| $this->malformed = false; |
| $this->encoding = $encoding; |
| // we take care of escaping comments and processing options. they will not be parsed |
| // and will end as text nodes |
| $html = $this->escapeSpecials($html); |
| // in order to create a tree, we first need to split the HTML using the markups, |
| // creating a nice flat array of texts and opening and closing markups. |
| // |
| // the array can be read as follows : |
| // |
| // i+0 => some text |
| // i+1 => '/' for closing markups, nothing otherwise |
| // i+2 => the markup it self, without the '<' '>' |
| // |
| // note that i+2 might end with a '/' indicating an auto-closing markup |
| $this->matches = preg_split('#<(/?)' . $namespace . '([^>]*)>#', $html, -1, PREG_SPLIT_DELIM_CAPTURE); |
| // the flat representation is now ready, we can create our tree |
| $tree = $this->buildTree(); |
| // if comments or processing options where escaped, we can |
| // safely unescape them now |
| if ($this->escaped) { |
| $tree = $this->unescapeSpecials($tree); |
| } |
| return $tree; |
| } |
| private function escapeSpecials($html) { |
| // here we escape comments |
| $html = preg_replace_callback('#<\!--.+-->#sU', array($this, 'escapeSpecials_callback'), $html); |
| // and processing options |
| $html = preg_replace_callback('#<\?.+\?>#sU', array($this, 'escapeSpecials_callback'), $html); |
| return $html; |
| } |
| private function escapeSpecials_callback($m) { |
| $this->escaped = true; |
| $text = $m[0]; |
| $text = str_replace(array('<', '>'), array("\x01", "\x02"), $text); |
| return $text; |
| } |
| private function unescapeSpecials($tree) { |
| return is_array($tree) ? array_map(array($this, 'unescapeSpecials'), $tree) : str_replace(array("\x01", "\x02"), array('<', '>'), $tree); |
| } |
| private function buildTree() { |
| $nodes = array(); |
| $i = 0; |
| $text = NULL; |
| while (($value = array_shift($this->matches)) !== NULL) { |
| switch ($i++ % 3) { |
| case 0: |
| // if the trimed value is not empty we preserve the value, |
| // otherwise we discard it. |
| if (trim($value)){ |
| $nodes[] = $value; |
| } |
| break; |
| case 1: |
| $closing = ($value == '/'); |
| break; |
| case 2: |
| if (substr($value, -1, 1) == '/') { |
| // auto closing |
| $nodes[] = $this->parseMarkup(substr($value, 0, -1)); |
| } else if ($closing) { |
| // closing markup |
| $open = array_pop($this->opened); |
| if ($value != $open) { |
| $this->error($value, $open); |
| } |
| return $nodes; |
| } else { |
| // this is an open markup with possible children |
| $node = $this->parseMarkup($value); |
| // push the markup name into the opened markups |
| $this->opened[] = $node['name']; |
| // create the node and parse its children |
| $node['children'] = $this->buildTree($this->matches); |
| $nodes[] = $node; |
| } |
| break; |
| } |
| } |
| return $nodes; |
| } |
| public function parseMarkup($markup) { |
| // get markup's name |
| preg_match('#^[^\s]+#', $markup, $matches); |
| $name = $matches[0]; |
| // get markup's arguments |
| preg_match_all('#\s+([^=]+)\s*=\s*"([^"]+)"#', $markup, $matches, PREG_SET_ORDER); |
| // transform the matches into a nice key/value array |
| $args = array(); |
| foreach ($matches as $m) { |
| // we unescape the html entities of the argument's value |
| $args[$m[1]] = html_entity_decode($m[2], ENT_QUOTES, $this->encoding); |
| } |
| return array('name' => $name, 'args' => $args); |
| } |
| public function error($markup, $expected) { |
| $this->malformed = true; |
| printf('unexpected closing markup "%s", should be "%s"', $markup, $expected); |
| } |
| } |
| ?> |
| /branches/v1.11-okuzgozu/jrest/services/bibliotheque/Ontologie.php |
|---|
| New file |
| 0,0 → 1,71 |
| <?php |
| class Ontologie { |
| private $ontologie = null; |
| /** |
| * Le contructeur transforme la sortie d'une requête sur la table coel_meta_liste_valeur en tableau Ontologie au format : |
| * $ontologie[id_valeur] = array( |
| * 'nom' => 'nom de la valeur', |
| * 'abr' => 'abréviation de la valeur, |
| * 'dsc' => 'description de la vaeur'); |
| * @param $ontologie tableau listant les valeurs de l'ontologie. |
| */ |
| public function __construct(Array $metadonnees) { |
| $ontologie = array(0 => array('nom' => 'Non renseigné', 'abr' => 'NR')); |
| foreach ($metadonnees as $meta) { |
| $id = $meta['cmlv_id_valeur']; |
| $nom = isset($meta['cmlv_nom']) ? $meta['cmlv_nom'] : null; |
| $abr = isset($meta['cmlv_abreviation']) ? $meta['cmlv_abreviation'] : null; |
| $dsc = isset($meta['cmlv_description']) ? $meta['cmlv_description'] : null; |
| $ontologie[$id] = array('nom' => $nom, 'abr' => $abr, 'dsc' => $dsc); |
| } |
| $this->ontologie = $ontologie; |
| } |
| /** |
| * Retourne le nom de la valeur de l'ontologie correspondant à l'id. |
| * |
| * @param int $id l'identifiant de la valeur de l'ontologie. |
| * @return string le nom de la valeur. |
| */ |
| public function getNom($id) { |
| $nom = null; |
| if (isset($this->ontologie[$id])) { |
| $nom = $this->ontologie[$id]['nom']; |
| } |
| return $nom; |
| } |
| /** |
| * Retourne l'abréviation de la valeur de l'ontologie correspondant à l'id. |
| * |
| * @param int $id l'identifiant de la valeur de l'ontologie. |
| * @return string l'abreviation de la valeur. |
| */ |
| public function getAbreviation($id) { |
| $abr = null; |
| if (isset($this->ontologie[$id])) { |
| $abr = $this->ontologie[$id]['abr']; |
| } |
| return $abr; |
| } |
| /** |
| * Le tableau de retour Ontologie est au format : |
| * $ontologie[id_valeur] = array( |
| * 'nom' => 'nom de la valeur', |
| * 'abr' => 'abréviation de la valeur); |
| * |
| * @param int $id l'identifiant de la valeur de l'ontologie. |
| * @return $ontologie tableau listant les valeurs de l'ontologie. |
| */ |
| public function getTableauValeur($id) { |
| $valeur = null; |
| if (isset($this->ontologie[$id])) { |
| $valeur = $this->ontologie[$id]; |
| } |
| return $valeur; |
| } |
| } |
| /branches/v1.11-okuzgozu/jrest/services/CoelSyndication.php |
|---|
| New file |
| 0,0 → 1,717 |
| <?php |
| /** |
| * Service fournissant des informations concernant COEL au format RSS1, RSS2 ou ATOM. |
| * Encodage en entrée : utf8 |
| * Encodage en sortie : utf8 |
| * |
| * Notes : pour les requêtes sur la table d'historique cela peut être assez compliqué! |
| * Voir : http://www.xaprb.com/blog/2006/12/07/how-to-select-the-firstleastmax-row-per-group-in-sql/ |
| * |
| * @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 $Id: CoelSyndication.php 381 2010-05-17 17:10:37Z jpm $ |
| * @copyright 2009 |
| */ |
| class CoelSyndication extends Coel { |
| private $format = null; |
| private $service = null; |
| private $squelette = null; |
| private $squelette_dossier = null; |
| private $squelette_diff = null; |
| private $flux = array(); |
| /** |
| * Méthode appelée avec une requête de type GET. |
| */ |
| public function getElement($param = array()) { |
| // Initialisation des variables |
| $info = array(); |
| $contenu = ''; |
| // Pré traitement des paramêtres |
| $pour_bdd = false; |
| $p = $this->traiterParametresUrl(array('service', 'format'), $param, $pour_bdd); |
| // Récupération de la liste des flux |
| $this->chargerListeDesFlux(); |
| // Chargement du bon type de service demandé |
| if (isset($p['service'])) { |
| $this->service = strtolower($p['service']); |
| $methode = $this->getNomMethodeService(); |
| if (method_exists($this, $methode)) { |
| if ($this->service != 'liste_des_flux') { |
| if (isset($p['format']) && preg_match('/^(?:rss1|rss2|atom)$/i', $p['format'])) { |
| // Multiplication par deux de la limite car nous récupérons deux lignes par item |
| $this->limit = $this->limit*2; |
| // Mise en minuscule de l'indication du format |
| $this->format = strtolower($p['format']); |
| // Définition du fichier squelette demandé |
| $this->squelette_dossier = dirname(__FILE__).DIRECTORY_SEPARATOR.'squelettes'.DIRECTORY_SEPARATOR; |
| $this->squelette = $this->squelette_dossier.$this->format.'.tpl.xml'; |
| $this->squelette_diff = $this->squelette_dossier.'diff.tpl.html'; |
| } else { |
| $this->format = ''; |
| $this->messages[] = "Le service COEL Syndication nécessite d'indiquer en second paramètre le format : rss1, rss2 ou atom."; |
| } |
| } |
| // Récupération du contenu à renvoyer |
| $contenu = $this->$methode(); |
| } else { |
| $this->messages[] = "Le type d'information demandé '$this->service' n'est pas disponible."; |
| } |
| } else { |
| $this->messages[] = "Le service COEL Syndication nécessite d'indiquer en premier paramètre le type d'information demandé."; |
| } |
| // Envoie sur la sortie standard |
| $encodage = 'utf-8'; |
| $mime = $this->getTypeMime(); |
| $formatage_json = $this->getFormatageJson(); |
| $this->envoyer($contenu, $mime, $encodage, $formatage_json); |
| } |
| private function getUrlServiceBase() { |
| $url_service = $this->config['coel']['urlBaseJrest'].'CoelSyndication/'.$this->service.'/'.$this->format; |
| return $url_service; |
| } |
| private function getNomMethodeService() { |
| $methode = ''; |
| $service_formate = str_replace(' ', '', ucwords(implode(' ', explode('_', $this->service)))); |
| $methode = 'getService'.$service_formate; |
| return $methode; |
| } |
| private function getTypeMime() { |
| $mime = ''; |
| switch ($this->format) { |
| case 'atom' : |
| $mime = 'application/atom+xml'; |
| break; |
| case 'rss1' : |
| case 'rss2' : |
| $mime = 'application/rss+xml'; |
| break; |
| default: |
| $mime = 'text/html'; |
| } |
| return $mime; |
| } |
| private function getFormatageJson() { |
| $json = false; |
| switch ($this->service) { |
| case 'liste_des_flux' : |
| $json = true; |
| break; |
| default: |
| $json = false; |
| } |
| return $json; |
| } |
| private function getFlux($nom) { |
| $nom = strtolower($nom); |
| return isset($this->flux[$nom]) ? $this->flux[$nom] : array(); |
| } |
| private function setFlux($nom, $titre, $description) { |
| $url_base = $this->config['coel']['urlBaseJrest'].'CoelSyndication/'; |
| $formats = array('atom', 'rss2', 'rss1'); |
| $flux = array(); |
| foreach ($formats as $format) { |
| $url = $url_base.$nom.'/'.$format; |
| $flux[$format] = $url; |
| } |
| $this->flux[$nom] = array('titre' => $titre, 'description' => $description, 'urls' => $flux); |
| } |
| private function chargerListeDesFlux() { |
| $this->setFlux('structure','Flux de syndication des institutions', |
| 'Ce flux fournit des informations sur les mises à jour des institutions saisies dans COEL.'); |
| $this->setFlux('collection', 'Flux de syndication des Collections', |
| 'Ce flux fournit des informations sur les mises à jour des collections saisies dans COEL.'); |
| $this->setFlux('personne', 'Flux de syndication des personnes', |
| 'Ce flux fournit des informations sur les mises à jour des personnes saisies dans COEL.'); |
| $this->setFlux('publication', 'Flux de syndication des publications', |
| 'Ce flux fournit des informations sur les mises à jour des publications saisies dans COEL.'); |
| $this->setFlux('commentaire', 'Flux de syndication des notes', |
| 'Ce flux fournit des informations sur les mises à jour des notes saisies dans COEL.'); |
| } |
| private function getServiceListeDesFlux() { |
| return $this->flux; |
| } |
| private function getServiceStructure() { |
| $elements = array(); |
| $elements = array_merge($elements, $this->getHistoriqueTableStructure(120)); |
| $elements = array_merge($elements, $this->getHistoriqueTableStructure(122)); |
| $elements = array_merge($elements, $this->getHistoriqueTableStructure(123)); |
| $elements = array_merge($elements, $this->getHistoriqueStructureAPersonne()); |
| krsort($elements); |
| $elements = array_slice($elements, 0, ($this->limit/2)); |
| // Création du contenu |
| $contenu = $this->executerService('cs_nom', $elements); |
| return $contenu; |
| } |
| private function getHistoriqueTableStructure($table_id) { |
| $requete = (($this->distinct) ? 'SELECT DISTINCT' : 'SELECT').' '. |
| ' h1.cmhl_id_historique_ligne, h1.cmhl_ce_table, h1.cmhl_cle_ligne, h1.cmhl_enregistrement, '. |
| ' h1.cmhl_date_modification, h1.cmhl_ce_etat, h1.cmhl_ip, '. |
| ' h1.cmhl_cle_ligne AS guid, '. |
| " 'str' AS guid_type, ". |
| (($table_id != 120) ? ' CONCAT(IF (h1.cmhl_ce_table = 122, "Conservation", "Valorisation"), " - ", cs_nom) AS titre, ' : ''). |
| ' cp_fmt_nom_complet AS modifier_par '. |
| 'FROM coel_meta_historique_ligne AS h1 '. |
| ' LEFT JOIN coel_meta_historique_ligne AS h2 '. |
| ' ON (h1.cmhl_ce_table = h2.cmhl_ce_table '. |
| ' AND h1.cmhl_cle_ligne = h2.cmhl_cle_ligne '. |
| ' AND h1.cmhl_date_modification <= h2.cmhl_date_modification ) '. |
| ' LEFT JOIN coel_personne ON (h1.cmhl_ce_modifier_par = cp_id_personne) '. |
| (($table_id != 120) ? ' LEFT JOIN coel_structure ON (cs_id_structure = h1.cmhl_cle_ligne) ' : ''). |
| "WHERE h1.cmhl_ce_table = $table_id %s ". |
| (($table_id != 120) ? ' AND h1.cmhl_ce_etat != 3 ' : ''). |
| 'GROUP BY h1.cmhl_ce_table, h1.cmhl_cle_ligne, h1.cmhl_date_modification '. |
| 'HAVING COUNT(*) = %s '. |
| 'ORDER BY '.((!is_null($this->orderby)) ? $this->orderby : 'h1.cmhl_date_modification DESC').' '. |
| "LIMIT $this->start,$this->limit "; |
| $elements = $this->executerRequeteHistorique($requete); |
| return $elements; |
| } |
| private function getHistoriqueStructureAPersonne() { |
| $requete = (($this->distinct) ? 'SELECT DISTINCT' : 'SELECT').' '. |
| ' h1.cmhl_id_historique_ligne, h1.cmhl_ce_table, h1.cmhl_cle_ligne, h1.cmhl_enregistrement, '. |
| ' h1.cmhl_date_modification, h1.cmhl_ce_etat, h1.cmhl_ip, '. |
| ' h1.cmhl_cle_ligne AS guid, '. |
| " 'csap' AS guid_type, ". |
| ' p1.cp_fmt_nom_complet AS modifier_par, '. |
| ' CONCAT(IF(h1.cmhl_ce_etat = 1, "Ajout", IF (h1.cmhl_ce_etat = 3, "Suppression", "Modification")), " d\'une personne liée à «", s1.cs_nom, "»") AS titre, '. |
| ' CONCAT("Personne «", p2.cp_fmt_nom_complet, "» liée à «", s1.cs_nom, "» avec rôle «", lv1.cmlv_nom, "»") AS description '. |
| 'FROM coel_meta_historique_ligne AS h1 '. |
| ' LEFT JOIN coel_meta_historique_ligne AS h2 '. |
| ' ON (h1.cmhl_ce_table = h2.cmhl_ce_table '. |
| ' AND h1.cmhl_cle_ligne = h2.cmhl_cle_ligne '. |
| ' AND h1.cmhl_date_modification <= h2.cmhl_date_modification ) '. |
| ' LEFT JOIN coel_personne AS p1 ON (h1.cmhl_ce_modifier_par = p1.cp_id_personne) '. |
| ' LEFT JOIN coel_personne AS p2 '. |
| " ON (SUBSTRING_INDEX(h1.cmhl_cle_ligne, '-', 1) = p2.cp_id_personne) ". |
| ' LEFT JOIN coel_structure AS s1 '. |
| " ON (SUBSTRING_INDEX(h1.cmhl_cle_ligne, '-', -1) = s1.cs_id_structure) ". |
| ' LEFT JOIN coel_meta_liste_valeur AS lv1 '. |
| " ON (SUBSTRING_INDEX(SUBSTRING_INDEX(h1.cmhl_cle_ligne, '-', 2), '-', -1) = lv1.cmlv_id_valeur) ". |
| 'WHERE h1.cmhl_ce_table = 121 %s '. |
| 'GROUP BY h1.cmhl_ce_table, h1.cmhl_cle_ligne, h1.cmhl_date_modification '. |
| 'HAVING COUNT(*) = %s '. |
| 'ORDER BY '.((!is_null($this->orderby)) ? $this->orderby : 'h1.cmhl_date_modification DESC').' '. |
| "LIMIT $this->start,$this->limit "; |
| $elements = $this->executerRequeteHistorique($requete); |
| return $elements; |
| } |
| private function getServiceCollection() { |
| $elements = array(); |
| $elements = array_merge($elements, $this->getHistoriqueTableCollection(101)); |
| $elements = array_merge($elements, $this->getHistoriqueTableCollection(106)); |
| $elements = array_merge($elements, $this->getHistoriqueCollectionAPersonne()); |
| $elements = array_merge($elements, $this->getHistoriqueCollectionAPublication()); |
| $elements = array_merge($elements, $this->getHistoriqueCollectionACommentaire()); |
| krsort($elements); |
| $elements = array_slice($elements, 0, ($this->limit/2)); |
| //echo '<pre>'.print_r($elements, true).'</pre>'; |
| // Création du contenu |
| $contenu = $this->executerService('cc_nom', $elements); |
| return $contenu; |
| } |
| private function getHistoriqueTableCollection($table_id) { |
| // Reque générale avec paramêtres |
| $requete = (($this->distinct) ? 'SELECT DISTINCT' : 'SELECT').' '. |
| ' h1.cmhl_id_historique_ligne, h1.cmhl_ce_table, h1.cmhl_cle_ligne, h1.cmhl_enregistrement, '. |
| ' h1.cmhl_date_modification, h1.cmhl_ce_etat, h1.cmhl_ip, '. |
| ' h1.cmhl_cle_ligne AS guid, '. |
| " 'col' AS guid_type, ". |
| (($table_id == 106) ? ' CONCAT("Botanique", " - ", cc_nom) AS titre, ' : ''). |
| ' cp_fmt_nom_complet AS modifier_par '. |
| 'FROM coel_meta_historique_ligne AS h1 '. |
| ' LEFT JOIN coel_meta_historique_ligne AS h2 '. |
| ' ON (h1.cmhl_ce_table = h2.cmhl_ce_table '. |
| ' AND h1.cmhl_cle_ligne = h2.cmhl_cle_ligne '. |
| ' AND h1.cmhl_date_modification <= h2.cmhl_date_modification ) '. |
| ' LEFT JOIN coel_personne ON (h1.cmhl_ce_modifier_par = cp_id_personne) '. |
| (($table_id == 106) ? ' LEFT JOIN coel_collection ON (cc_id_collection = h1.cmhl_cle_ligne) ' : ''). |
| "WHERE h1.cmhl_ce_table = $table_id %s ". |
| (($table_id == 106) ? ' AND h1.cmhl_ce_etat != 3 ' : ''). |
| 'GROUP BY h1.cmhl_ce_table, h1.cmhl_cle_ligne, h1.cmhl_date_modification '. |
| 'HAVING COUNT(*) = %s '. |
| 'ORDER BY '.((!is_null($this->orderby)) ? $this->orderby : 'h1.cmhl_date_modification DESC').' '. |
| "LIMIT $this->start,$this->limit "; |
| $elements = $this->executerRequeteHistorique($requete); |
| return $elements; |
| } |
| private function getHistoriqueCollectionAPersonne() { |
| $requete = (($this->distinct) ? 'SELECT DISTINCT' : 'SELECT').' '. |
| ' h1.cmhl_id_historique_ligne, h1.cmhl_ce_table, h1.cmhl_cle_ligne, h1.cmhl_enregistrement, '. |
| ' h1.cmhl_date_modification, h1.cmhl_ce_etat, h1.cmhl_ip, '. |
| ' p1.cp_fmt_nom_complet AS modifier_par, '. |
| ' h1.cmhl_cle_ligne AS guid, '. |
| " 'ccap' AS guid_type, ". |
| ' CONCAT(IF(h1.cmhl_ce_etat = 1, "Ajout", IF (h1.cmhl_ce_etat = 3, "Suppression", "Modification")), " d\'une personne liée à «", c1.cc_nom, "»") AS titre, '. |
| ' CONCAT("Personne «", p2.cp_fmt_nom_complet, "» liée à «", c1.cc_nom, "» avec rôle «", lv1.cmlv_nom, "»") AS description '. |
| 'FROM coel_meta_historique_ligne AS h1 '. |
| ' LEFT JOIN coel_meta_historique_ligne AS h2 '. |
| ' ON (h1.cmhl_ce_table = h2.cmhl_ce_table '. |
| ' AND h1.cmhl_cle_ligne = h2.cmhl_cle_ligne '. |
| ' AND h1.cmhl_date_modification <= h2.cmhl_date_modification ) '. |
| ' LEFT JOIN coel_personne AS p1 ON (h1.cmhl_ce_modifier_par = p1.cp_id_personne) '. |
| ' LEFT JOIN coel_personne AS p2 '. |
| " ON (SUBSTRING_INDEX(SUBSTRING_INDEX(h1.cmhl_cle_ligne, '-', 2), '-', -1) = p2.cp_id_personne) ". |
| ' LEFT JOIN coel_collection AS c1 '. |
| " ON (SUBSTRING_INDEX(h1.cmhl_cle_ligne, '-', 1) = c1.cc_id_collection) ". |
| ' LEFT JOIN coel_meta_liste_valeur AS lv1 '. |
| " ON (SUBSTRING_INDEX(h1.cmhl_cle_ligne, '-', -1) = lv1.cmlv_id_valeur) ". |
| 'WHERE h1.cmhl_ce_table = 103 %s '. |
| 'GROUP BY h1.cmhl_ce_table, h1.cmhl_cle_ligne, h1.cmhl_date_modification '. |
| 'HAVING COUNT(*) = %s '. |
| 'ORDER BY '.((!is_null($this->orderby)) ? $this->orderby : 'h1.cmhl_date_modification DESC').' '. |
| "LIMIT $this->start,$this->limit "; |
| $elements = $this->executerRequeteHistorique($requete); |
| return $elements; |
| } |
| private function getHistoriqueCollectionAPublication() { |
| $requete = (($this->distinct) ? 'SELECT DISTINCT' : 'SELECT').' '. |
| ' h1.cmhl_id_historique_ligne, h1.cmhl_ce_table, h1.cmhl_cle_ligne, h1.cmhl_enregistrement, '. |
| ' h1.cmhl_date_modification, h1.cmhl_ce_etat, h1.cmhl_ip, '. |
| ' p1.cp_fmt_nom_complet AS modifier_par, '. |
| ' h1.cmhl_cle_ligne AS guid, '. |
| " 'ccapu' AS guid_type, ". |
| ' CONCAT(IF(h1.cmhl_ce_etat = 1, "Ajout", IF (h1.cmhl_ce_etat = 3, "Suppression", "Modification")), " d\'une publication liée à «", c1.cc_nom, "»") AS titre, '. |
| ' CONCAT("Publication «", p2.cpu_fmt_nom_complet, "» liée à «", c1.cc_nom, "»") AS description '. |
| 'FROM coel_meta_historique_ligne AS h1 '. |
| ' LEFT JOIN coel_meta_historique_ligne AS h2 '. |
| ' ON (h1.cmhl_ce_table = h2.cmhl_ce_table '. |
| ' AND h1.cmhl_cle_ligne = h2.cmhl_cle_ligne '. |
| ' AND h1.cmhl_date_modification <= h2.cmhl_date_modification ) '. |
| ' LEFT JOIN coel_personne AS p1 ON (h1.cmhl_ce_modifier_par = p1.cp_id_personne) '. |
| ' LEFT JOIN coel_publication AS p2 '. |
| " ON (SUBSTRING_INDEX(h1.cmhl_cle_ligne, '-', -1) = p2.cpu_id_publication) ". |
| ' LEFT JOIN coel_collection AS c1 '. |
| " ON (SUBSTRING_INDEX(h1.cmhl_cle_ligne, '-', 1) = c1.cc_id_collection) ". |
| 'WHERE h1.cmhl_ce_table = 104 %s '. |
| 'GROUP BY h1.cmhl_ce_table, h1.cmhl_cle_ligne, h1.cmhl_date_modification '. |
| 'HAVING COUNT(*) = %s '. |
| 'ORDER BY '.((!is_null($this->orderby)) ? $this->orderby : 'h1.cmhl_date_modification DESC').' '. |
| "LIMIT $this->start,$this->limit "; |
| $elements = $this->executerRequeteHistorique($requete); |
| return $elements; |
| } |
| private function getHistoriqueCollectionACommentaire() { |
| $requete = (($this->distinct) ? 'SELECT DISTINCT' : 'SELECT').' '. |
| ' h1.cmhl_id_historique_ligne, h1.cmhl_ce_table, h1.cmhl_cle_ligne, h1.cmhl_enregistrement, '. |
| ' h1.cmhl_date_modification, h1.cmhl_ce_etat, h1.cmhl_ip, '. |
| ' p1.cp_fmt_nom_complet AS modifier_par, '. |
| ' h1.cmhl_cle_ligne AS guid, '. |
| " 'ccacm' AS guid_type, ". |
| ' CONCAT(IF(h1.cmhl_ce_etat = 1, "Ajout", IF (h1.cmhl_ce_etat = 3, "Suppression", "Modification")), " d\'un commentaire lié à «", c1.cc_nom, "»") AS titre, '. |
| ' CONCAT("Commentaire «", c.ccm_titre, "» liée à «", c1.cc_nom, "»") AS description '. |
| 'FROM coel_meta_historique_ligne AS h1 '. |
| ' LEFT JOIN coel_meta_historique_ligne AS h2 '. |
| ' ON (h1.cmhl_ce_table = h2.cmhl_ce_table '. |
| ' AND h1.cmhl_cle_ligne = h2.cmhl_cle_ligne '. |
| ' AND h1.cmhl_date_modification <= h2.cmhl_date_modification ) '. |
| ' LEFT JOIN coel_personne AS p1 ON (h1.cmhl_ce_modifier_par = p1.cp_id_personne) '. |
| ' LEFT JOIN coel_commentaire AS c '. |
| " ON (SUBSTRING_INDEX(h1.cmhl_cle_ligne, '-', -1) = c.ccm_id_commentaire) ". |
| ' LEFT JOIN coel_collection AS c1 '. |
| " ON (SUBSTRING_INDEX(h1.cmhl_cle_ligne, '-', 1) = c1.cc_id_collection) ". |
| 'WHERE h1.cmhl_ce_table = 102 %s '. |
| 'GROUP BY h1.cmhl_ce_table, h1.cmhl_cle_ligne, h1.cmhl_date_modification '. |
| 'HAVING COUNT(*) = %s '. |
| 'ORDER BY '.((!is_null($this->orderby)) ? $this->orderby : 'h1.cmhl_date_modification DESC').' '. |
| "LIMIT $this->start,$this->limit "; |
| $elements = $this->executerRequeteHistorique($requete); |
| return $elements; |
| } |
| private function getServicePersonne() { |
| $elements = array(); |
| $elements = array_merge($elements, $this->getHistoriqueTable(113, 'per')); |
| $elements = array_merge($elements, $this->getHistoriquePublicationAPersonne()); |
| krsort($elements); |
| $elements = array_slice($elements, 0, ($this->limit/2)); |
| //echo '<pre>'.print_r($elements, true).'</pre>'; |
| // Création du contenu |
| $contenu = $this->executerService('cp_fmt_nom_complet', $elements); |
| return $contenu; |
| } |
| private function getHistoriquePublicationAPersonne() { |
| $requete = (($this->distinct) ? 'SELECT DISTINCT' : 'SELECT').' '. |
| ' h1.cmhl_id_historique_ligne, h1.cmhl_ce_table, h1.cmhl_cle_ligne, h1.cmhl_enregistrement, '. |
| ' h1.cmhl_date_modification, h1.cmhl_ce_etat, h1.cmhl_ip, '. |
| ' p1.cp_fmt_nom_complet AS modifier_par, '. |
| ' h1.cmhl_cle_ligne AS guid, '. |
| " 'cpap' AS guid_type, ". |
| ' CONCAT(IF(h1.cmhl_ce_etat = 1, "Ajout", IF (h1.cmhl_ce_etat = 3, "Suppression", "Modification")), " d\'une publication liée à «", p2.cp_fmt_nom_complet, "»") AS titre, '. |
| ' CONCAT("Publication «", pu.cpu_fmt_nom_complet, "» liée à «", p2.cp_fmt_nom_complet, "» avec rôle «", lv1.cmlv_nom, "»") AS description '. |
| 'FROM coel_meta_historique_ligne AS h1 '. |
| ' LEFT JOIN coel_meta_historique_ligne AS h2 '. |
| ' ON (h1.cmhl_ce_table = h2.cmhl_ce_table '. |
| ' AND h1.cmhl_cle_ligne = h2.cmhl_cle_ligne '. |
| ' AND h1.cmhl_date_modification <= h2.cmhl_date_modification ) '. |
| ' LEFT JOIN coel_personne AS p1 ON (h1.cmhl_ce_modifier_par = p1.cp_id_personne) '. |
| ' LEFT JOIN coel_publication AS pu '. |
| " ON (SUBSTRING_INDEX(SUBSTRING_INDEX(h1.cmhl_cle_ligne, '-', 2), '-', -1) = pu.cpu_id_publication) ". |
| ' LEFT JOIN coel_personne AS p2 '. |
| " ON (SUBSTRING_INDEX(h1.cmhl_cle_ligne, '-', 1) = p2.cp_id_personne) ". |
| ' LEFT JOIN coel_meta_liste_valeur AS lv1 '. |
| " ON (SUBSTRING_INDEX(h1.cmhl_cle_ligne, '-', -1) = lv1.cmlv_id_valeur) ". |
| 'WHERE h1.cmhl_ce_table = 119 '. |
| ' %s '. |
| " AND SUBSTRING_INDEX(h1.cmhl_cle_ligne, '-', -1) IN (2361,2362,2363) ". |
| 'GROUP BY h1.cmhl_ce_table, h1.cmhl_cle_ligne, h1.cmhl_date_modification '. |
| 'HAVING COUNT(*) = %s '. |
| 'ORDER BY '.((!is_null($this->orderby)) ? $this->orderby : 'h1.cmhl_date_modification DESC').' '. |
| "LIMIT $this->start,$this->limit "; |
| $elements = $this->executerRequeteHistorique($requete); |
| return $elements; |
| } |
| private function getServicePublication() { |
| $elements = array(); |
| $elements = $this->getHistoriqueTable(118, 'pub'); |
| krsort($elements); |
| $elements = array_slice($elements, 0, ($this->limit/2)); |
| //echo '<pre>'.print_r($elements, true).'</pre>'; |
| // Création du contenu |
| $contenu = $this->executerService('cpu_fmt_nom_complet', $elements); |
| return $contenu; |
| } |
| private function getServiceCommentaire() { |
| $elements = array(); |
| $elements = $this->getHistoriqueTable(107, 'com'); |
| krsort($elements); |
| $elements = array_slice($elements, 0, ($this->limit/2)); |
| //echo '<pre>'.print_r($elements, true).'</pre>'; |
| // Création du contenu |
| $contenu = $this->executerService('ccm_titre', $elements); |
| return $contenu; |
| } |
| private function getHistoriqueTable($table_id, $guid_type) { |
| // Reque générale avec paramêtres |
| $requete = (($this->distinct) ? 'SELECT DISTINCT' : 'SELECT').' '. |
| ' h1.cmhl_id_historique_ligne, h1.cmhl_ce_table, h1.cmhl_cle_ligne, h1.cmhl_enregistrement, '. |
| ' h1.cmhl_date_modification, h1.cmhl_ce_etat, h1.cmhl_ip, '. |
| ' h1.cmhl_cle_ligne AS guid, '. |
| " '$guid_type' AS guid_type, ". |
| ' cp_fmt_nom_complet AS modifier_par '. |
| 'FROM coel_meta_historique_ligne AS h1 '. |
| ' LEFT JOIN coel_meta_historique_ligne AS h2 '. |
| ' ON (h1.cmhl_ce_table = h2.cmhl_ce_table '. |
| ' AND h1.cmhl_cle_ligne = h2.cmhl_cle_ligne '. |
| ' AND h1.cmhl_date_modification <= h2.cmhl_date_modification ) '. |
| ' LEFT JOIN coel_personne ON (h1.cmhl_ce_modifier_par = cp_id_personne) '. |
| "WHERE h1.cmhl_ce_table = $table_id %s ". |
| 'GROUP BY h1.cmhl_ce_table, h1.cmhl_cle_ligne, h1.cmhl_date_modification '. |
| 'HAVING COUNT(*) = %s '. |
| 'ORDER BY '.((!is_null($this->orderby)) ? $this->orderby : 'h1.cmhl_date_modification DESC').' '. |
| "LIMIT $this->start,$this->limit "; |
| $elements = $this->executerRequeteHistorique($requete); |
| return $elements; |
| } |
| private function executerRequete($requete) { |
| $infos = null; |
| try { |
| $infos = $this->bdd->query($requete)->fetchAll(PDO::FETCH_ASSOC); |
| if ($infos === false) { |
| $this->messages[] = "La requête a retourné aucun résultat."; |
| } |
| } catch (PDOException $e) { |
| $this->messages[] = sprintf($this->getTxt('sql_erreur'), $e->getFile(), $e->getLine(), $e->getMessage()); |
| } |
| return $infos; |
| } |
| private function fusionnerEnregistrements($infos) { |
| // Fusion des lignes |
| $elements = array(); |
| foreach ($infos as $info) { |
| $id = $info['cmhl_ce_table'].'|'.$info['cmhl_cle_ligne']; |
| if (!isset($elements[$id])) { |
| $elements[$id] = $info; |
| } else { |
| if ($elements[$id]['cmhl_date_modification'] < $info['cmhl_date_modification']) { |
| $elements[$id] = $this->traiterInfosPrecedentes($info, $elements[$id]); |
| } else { |
| $elements[$id] = $this->traiterInfosPrecedentes($elements[$id], $info); |
| } |
| } |
| } |
| // Nettoyage et utilisation de la date pour pouvoir trier le tableau |
| $sortie = array(); |
| foreach ($elements as $id => $element) { |
| $element = $this->nettoyerNomChamps($element); |
| $id_avec_date = $element['cmhl_date_modification'].'|'.$id; |
| $sortie[$id_avec_date] = $element; |
| } |
| return $sortie; |
| } |
| private function executerRequeteHistorique($requete) { |
| $elements = array(); |
| // Récupération des 1er éléments |
| $requete_elements_1er = sprintf($requete, '', '1'); |
| $infos_elements_1er = $this->executerRequete($requete_elements_1er); |
| // Construction de la requête pour récupérer les second éléments |
| $elements_1er_cle_ligne = array(); |
| foreach ($infos_elements_1er as $info) { |
| $elements_1er_cle_ligne[] = '"'.$info['cmhl_cle_ligne'].'"'; |
| } |
| $chaine_1er_elements = 'AND h1.cmhl_cle_ligne IN ('.str_replace(',,',',',implode(',', $elements_1er_cle_ligne)).') '; |
| $requete_elements_2nd = sprintf($requete, $chaine_1er_elements, '2'); |
| // Récupération des 2nd éléments |
| $infos_elements_2nd = $this->executerRequete($requete_elements_2nd); |
| // Fusion des 1er et 2nd éléments |
| $infos = array_merge($infos_elements_1er, $infos_elements_2nd); |
| $elements = $this->fusionnerEnregistrements($infos); |
| return $elements; |
| } |
| private function executerService($champ_titre, $elements) { |
| // Prétraitement des données |
| $donnees = $this->construireDonneesCommunesAuFlux($elements); |
| foreach ($elements as $element) { |
| $xml = $this->getXmlHisto($element); |
| $enrg = $this->getTableauDepuisXmlHisto($xml); |
| $diff = $this->getDiffInfos($element); |
| $diff['differences'] = $this->getDiff($element); |
| $diff_html = (!is_null($diff['differences'])) ? Coel::traiterSquelettePhp($this->squelette_diff, $diff) : ''; |
| $item = $this->construireDonneesCommunesAuxItems($element); |
| $item['titre'] = $this->creerTitre($champ_titre, $element, $enrg); |
| $item['guid'] = sprintf($this->config['coel']['guid'], 'coel:'.$element['guid_type'].$element['guid']); |
| $item['lien'] = $this->config['coel']['urlBaseFicheConsultation'].urlencode($item['guid']); |
| $item['description'] = '<p>'.$this->getMessageModif($item).'</p>'; |
| $item['description'] .= $this->creerDescription($element, $enrg); |
| $item['description'] .= $diff_html; |
| $item['description'] = $this->nettoyerTexte($item['description']); |
| $item['description_encodee'] = htmlspecialchars($item['description']); |
| $donnees['items'][] = $item; |
| } |
| // Création du contenu à partir d'un template PHP |
| $contenu = Coel::traiterSquelettePhp($this->squelette, $donnees); |
| return $contenu; |
| } |
| private function creerTitre($champ, $element, $enrg) { |
| $titre = ''; |
| if (isset($element['titre'])) { |
| $titre = $element['titre']; |
| } else if (isset($element[$champ])) { |
| $titre = $element[$champ]; |
| } else if (isset($enrg[$champ])) { |
| $titre = $enrg[$champ]; |
| } |
| $titre = $this->nettoyerTexte($titre); |
| return $titre; |
| } |
| private function creerDescription($element, $enrg) { |
| $description = ''; |
| if (isset($element['description'])) { |
| $description = $element['description']; |
| } |
| return $description; |
| } |
| private function nettoyerNomChamps($infos) { |
| $sortie = array(); |
| foreach ($infos as $champ => $valeur) { |
| if (preg_match('/^__(.+)$/', $champ, $match)) { |
| $sortie[$match[1]] = $valeur; |
| } else { |
| $sortie[$champ] = $valeur; |
| } |
| } |
| return $sortie; |
| } |
| private function traiterInfosPrecedentes($infos_courantes, $infos_precedentes) { |
| $infos_precedentes_traitees = array(); |
| foreach ($infos_precedentes as $champ => $valeur) { |
| $infos_precedentes_traitees['enrg_prec'] = null; |
| $infos_precedentes_traitees['date_prec'] = null; |
| if ($champ == 'cmhl_date_modification') { |
| $infos_precedentes_traitees['date_prec'] = $valeur; |
| } else if ($champ == 'cmhl_enregistrement') { |
| $infos_precedentes_traitees['enrg_prec'] = $valeur; |
| } else if (preg_match('/^__(.+)$/', $champ, $match)) { |
| $infos_precedentes_traitees[$match[1].'_prec'] = $valeur; |
| } |
| } |
| $sortie = array_merge($infos_courantes, $infos_precedentes_traitees); |
| return $sortie; |
| } |
| private function nettoyerTexte($txt) { |
| $txt = preg_replace('/&(?!amp;)/i', '&', $txt, -1); |
| return $txt; |
| } |
| private function getMessageModif($item) { |
| $message = $item['etat'].' le '.$item['date_maj_simple'].' par '.$item['modifier_par'].' depuis l\'IP '.$item['ip']; |
| return $message; |
| } |
| private function construireDonneesCommunesAuxItems($info) { |
| $item = array(); |
| $date_modification_timestamp = strtotime($info['cmhl_date_modification']); |
| $item['date_maj_simple'] = strftime('%A %d %B %Y à %H:%M', $date_modification_timestamp); |
| $item['date_maj_RSS'] = date(DATE_RSS, $date_modification_timestamp); |
| $item['date_maj_ATOM'] = date(DATE_ATOM, $date_modification_timestamp); |
| $item['date_maj_W3C'] = date(DATE_W3C, $date_modification_timestamp); |
| $item['guid'] = $info['cmhl_id_historique_ligne']; |
| $item['cle'] = $info['cmhl_cle_ligne']; |
| $item['ip'] = $info['cmhl_ip']; |
| $item['modifier_par'] = $info['modifier_par']; |
| $item['etat'] = isset($info['cmhl_ce_etat']) ? $this->getTexteEtat($info['cmhl_ce_etat']) : ''; |
| return $item; |
| } |
| private function getXmlHisto($info) { |
| $xml = ''; |
| if ($info['cmhl_ce_etat'] == '3') { |
| $xml = @$info['enrg_prec']; |
| } else { |
| $xml = $info['cmhl_enregistrement']; |
| } |
| return $xml; |
| } |
| private function getDiff($info) { |
| $diff = null; |
| if ($info['cmhl_ce_etat'] == '1') { |
| $nouveau = $this->getTableauDepuisXmlHisto($info['cmhl_enregistrement']); |
| foreach ($nouveau as $cle => $valeur) { |
| $diff[$cle] = array('type' => 'A', 'type_txt' => 'Ajout', 'nouveau' => $valeur, 'ancien' => ' '); |
| } |
| } else if ($info['cmhl_ce_etat'] == '2') { |
| $nouveau = $this->getTableauDepuisXmlHisto($info['cmhl_enregistrement']); |
| $ancien = @$this->getTableauDepuisXmlHisto($info['enrg_prec']); |
| foreach ($nouveau as $cle => $valeur) { |
| if (!isset($ancien[$cle])) { |
| $diff[$cle] = array('type' => 'A', 'type_txt' => 'Ajout', 'nouveau' => $valeur, 'ancien' => ' '); |
| } else if (isset($ancien[$cle]) && $ancien[$cle] != $valeur) { |
| $diff[$cle] = array('type' => 'M', 'type_txt' => 'Modification', 'nouveau' => $valeur, 'ancien' => $ancien[$cle]); |
| } |
| } |
| foreach ($ancien as $cle => $valeur) { |
| if (!isset($nouveau[$cle])) { |
| $diff[$cle] = array('type' => 'S', 'type_txt' => 'Suppression', 'nouveau' => ' ', 'ancien' => $valeur); |
| } |
| } |
| } |
| return $diff; |
| } |
| private function getDiffInfos($info) { |
| $diff = null; |
| $format = '%d/%m/%Y à %H:%M:%S'; |
| if ($info['cmhl_ce_etat'] == '1') { |
| $diff['date_nouvelle'] = strftime($format, strtotime($info['cmhl_date_modification'])); |
| $diff['date_ancienne'] = ''; |
| $diff['etat'] = 'A'; |
| } else if ($info['cmhl_ce_etat'] == '2') { |
| $diff['date_nouvelle'] = strftime($format, strtotime($info['cmhl_date_modification'])); |
| $diff['date_ancienne'] = @strftime($format, strtotime($info['date_prec'])); |
| $diff['etat'] = 'M'; |
| } else if ($info['cmhl_ce_etat'] == '3') { |
| $diff['etat'] = 'S'; |
| } |
| return $diff; |
| } |
| private function getTexteEtat($code) { |
| $etat = ''; |
| switch ($code) { |
| case '1' : |
| $etat = 'Ajouté'; |
| break; |
| case '2' : |
| $etat = 'Modifié'; |
| break; |
| case '3' : |
| $etat = 'Supprimé'; |
| break; |
| default : |
| $etat = '!Problème!'; |
| $e = "Le champ cmhl_ce_etat possède une valeur innatendue : $code"; |
| $this->messages[] = $e; |
| } |
| return $etat; |
| } |
| private function construireDonneesCommunesAuFlux($infos) { |
| $donnees = $this->getFlux($this->service); |
| $donnees['guid'] = $this->getUrlServiceBase(); |
| $donnees['lien_service'] = htmlentities($this->creerUrlService()); |
| $donnees['lien_coel'] = $this->config['coel']['urlBaseCoel']; |
| $donnees['editeur'] = $this->config['coel']['editeur']; |
| $derniere_info_en_date = reset($infos); |
| $date_modification_timestamp = strtotime($derniere_info_en_date['cmhl_date_modification']); |
| $donnees['date_maj_RSS'] = date(DATE_RSS, $date_modification_timestamp); |
| $donnees['date_maj_ATOM'] = date(DATE_ATOM, $date_modification_timestamp); |
| $donnees['date_maj_W3C'] = date(DATE_W3C, $date_modification_timestamp); |
| $donnees['annee_courante'] = date('Y'); |
| $donnees['generateur'] = 'COEL - Jrest'; |
| preg_match('/([0-9]+)/', '$Revision: 381 $', $match); |
| $donnees['generateur_version'] = $match[1]; |
| return $donnees; |
| } |
| private function creerUrlService() { |
| $url_service = $this->getUrlServiceBase(); |
| if (isset($this->start) || isset($this->limit)) { |
| $arguments = array(); |
| if (isset($this->start) && isset($_GET['start'])) { |
| $arguments[] = 'start='.$this->start; |
| } |
| if (isset($this->limit) && isset($_GET['limit'])) { |
| $arguments[] = 'limit='.($this->limit/2); |
| } |
| if (count($arguments) > 0) { |
| $url_service .= '?'.implode('&', $arguments); |
| } |
| } |
| return $url_service; |
| } |
| } |
| /branches/v1.11-okuzgozu/jrest/services/CoelPublicationAPersonne.php |
|---|
| New file |
| 0,0 → 1,287 |
| <?php |
| /** |
| * Service fournissant la liste des relations "publication à personne". |
| * Encodage en entrée : utf8 |
| * Encodage en sortie : utf8 |
| * |
| * @category PHP 5.2 |
| * @package jrest |
| * @author Aurélien PERONNET <aurelien@tela-botanica.org> |
| * @author Jean-Pascal MILCENT <jpm@tela-botanica.org> |
| * @copyright © 2009, Tela Botanica |
| * @license GPL v3 <http://www.gnu.org/licenses/gpl.txt> |
| * @license CECILL v2 <http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt> |
| * @version $Id$ |
| * @link /doc/jrest/ |
| */ |
| class CoelPublicationAPersonne extends Coel { |
| const ROLE_AUTEUR = 2360; |
| /** Contient les infos sur les tables gérées par ce service. |
| * Bien respecter l'ordre avec en premier les tables liées et en dernier la table établissant la relation. */ |
| protected $tables = array( 119 => array( 'nom' => 'coel_publication_a_personne', |
| 'prefixe' => 'cpuap', |
| 'id' => array('cpuap_id_personne', 'cpuap_id_publication', 'cpuap_id_role'))); |
| /** |
| * Méthode appelée avec une requête de type GET. |
| */ |
| public function getElement($param = array()) { |
| // Initialisation des variables |
| $info = array(); |
| // Pré traitement des paramêtres |
| $p = $this->traiterParametresUrl(array('id_publication', 'id_personne', 'id_role'), $param, false); |
| // Construction de la requête |
| $requete = (($this->distinct) ? 'SELECT DISTINCT ' : 'SELECT '). |
| ' cpu.*, cpuap.*, cp_id_personne, cp_prenom, cp_nom, cp_fmt_nom_complet, cp_code_postal, cp_truk_courriel, cp_ville '. |
| 'FROM coel_publication_a_personne AS cpuap '. |
| ' LEFT JOIN coel_meta_historique_ligne ON (cpuap_ce_meta = cmhl_id_historique_ligne) '. |
| ' LEFT JOIN coel_personne AS cp ON (cpuap_id_personne = cp_id_personne) '. |
| ' LEFT JOIN coel_publication AS cpu ON (cpuap_id_publication = cpu_id_publication) '. |
| ((count($p) != 0) ? 'WHERE ' : ''). |
| (isset($p['id_personne']) ? "AND cpuap_id_personne IN ({$p['id_personne']}) " : ''). |
| (isset($p['id_publication']) ? "AND cpuap_id_publication = '{$p['id_publication']}' " : ''). |
| (isset($p['id_role']) ? "AND cpuap_id_role IN ({$p['id_role']}) " : ''). |
| 'ORDER BY '.((!is_null($this->orderby)) ? $this->orderby : 'cpuap_ce_meta DESC').' '; |
| $requete = str_replace('WHERE AND', 'WHERE', $requete); |
| $requeteCount = $requete; |
| $requete .= "LIMIT $this->start, $this->limit "; |
| // Récupération des résultats |
| try { |
| $donnees = (count($p) == 3) ? $this->bdd->query($requete)->fetch(PDO::FETCH_OBJ) : $this->bdd->query($requete)->fetchAll(PDO::FETCH_ASSOC); |
| if ($donnees === false) { |
| $this->messages[] = "La requête n'a retourné aucun résultat."; |
| } |
| $nbElements = $this->bdd->query($requeteCount)->rowCount(); |
| $info['nbElements'] = $nbElements; |
| $info['publicationsAPersonne'] = $donnees; |
| } catch (PDOException $e) { |
| $this->messages[] = sprintf($this->getTxt('sql_erreur'), $e->getFile(), $e->getLine(), $e->getMessage()); |
| } |
| // Envoie sur la sortie standard |
| $this->envoyer($info); |
| } |
| /** |
| * Méthode appelée pour ajouter un élément. |
| */ |
| public function createElement($params) { |
| // Identification de l'utilisateur |
| list($id_utilisateur, $id_session) = $this->getIdentification($params); |
| // Contrôle du non détournement de l'utilisateur |
| if ($this->etreAutorise($id_utilisateur)) { |
| $auteurs = $role = $ordre_des_auteurs = $publications = array(); |
| // Traitement spécial pour ajouter plusieurs personnes liées à une publication à la fois... |
| if (isset($params['cpuap_id_auteur'])) { |
| $auteurs = explode(',', $params['cpuap_id_auteur']); |
| unset($params['cpuap_id_auteur']); |
| } |
| if (isset($params['cpuap_id_role'])) { |
| $role = explode(',', $params['cpuap_id_role']); |
| } |
| if (isset($params['cpuap_ordre'])) { |
| $ordre_des_auteurs = explode(',', $params['cpuap_ordre']); |
| unset($params['cpuap_ordre']); |
| } |
| // Traitement spécial pour ajouter plusieurs publications liées à une personne à la fois... |
| if (isset($params['cpuap_id_publication'])) { |
| $publications = explode(',', $params['cpuap_id_publication']); |
| if (count($publications) > 1) { |
| unset($params['cpuap_id_publication']); |
| } |
| } |
| if (count($auteurs) != 0 || count($publications) != 0) { |
| // Formulaire Publication : nous lions des auteurs à une publication |
| // Cas où il y a une seule publication et un ou plusieurs auteurs ; c'est donc une liaison d'une publi a plusieurs personne avec le role "auteur" |
| if (count($auteurs) >= 1 && count($publications) == 1 && (count($role) == 1 && $role[0] == self::ROLE_AUTEUR)) { |
| $compteur = 0; |
| foreach ($auteurs as $params['cpuap_id_personne']) { |
| $params['cpuap_ordre'] = $ordre_des_auteurs[$compteur++]; |
| // Vérification des tables à vraiment mettre à jour en fonction des données passées. |
| $tables_a_modifier = $this->recupererTablesAModifier($params); |
| // Pour chaque table du module nous lançons si nécessaire l'historisation puis la mise à jour |
| // Nous ne pouvons pas utiliser foreach car il travaille sur une copie du tableau or nous le modifions dynamiquement dans la boucle |
| reset($tables_a_modifier); |
| while (list($table_id, $table) = each($tables_a_modifier)) { |
| if (!is_null($table['champs'])) { |
| try { |
| $this->mettreAJourAvecCle($id_utilisateur, $id_session, $table_id, $table); |
| } catch (PDOException $e) { |
| $this->messages[] = sprintf($this->getTxt('sql_erreur'), $e->getFile(), $e->getLine(), $e->getMessage()); |
| } |
| } |
| } |
| } |
| } |
| // Formulaire Personne : nous lions des publications à une personne |
| // Cas où il y a plusieurs publications ; c'est donc une liaison de plusieurs publis a une personne avec n roles |
| else if (count($auteurs) == 1 && count($publications) >= 1 && (count($role) > 1 || (count($role) == 1 && $role[0] != self::ROLE_AUTEUR)) ) { |
| $params['cpuap_id_personne'] = $auteurs[0]; |
| for ($i = 0; $i < count($publications); $i++ ) { |
| $params['cpuap_id_publication'] = $publications[$i]; |
| $params['cpuap_id_role'] = $role[$i]; |
| // Vérification des tables à vraiment mettre à jour en fonction des données passées. |
| $tables_a_modifier = $this->recupererTablesAModifier($params); |
| // Pour chaque table du module nous lançons si nécessaire l'historisation puis la mise à jour |
| // Nous ne pouvons pas utiliser foreach car il travaille sur une copie du tableau or nous le modifions dynamiquement dans la boucle |
| reset($tables_a_modifier); |
| while (list($table_id, $table) = each($tables_a_modifier)) { |
| if (!is_null($table['champs'])) { |
| try { |
| $this->mettreAJourAvecCle($id_utilisateur, $id_session, $table_id, $table); |
| } catch (PDOException $e) { |
| $this->messages[] = sprintf($this->getTxt('sql_erreur'), $e->getFile(), $e->getLine(), $e->getMessage()); |
| } |
| } |
| } |
| } |
| } |
| } else { |
| $this->messages[] = "Aucun identifiant d'auteur ou de publication fournis"; |
| } |
| } else { |
| $this->messages[] = "Il faut être identifié pour accéder à ce service"; |
| } |
| // Envoie sur la sortie standard |
| $this->envoyer(); |
| } |
| /** |
| * Méthode appelée pour mettre à jour un élément |
| */ |
| public function updateElement($uid, $params) { |
| // Vérification de la présence des id passés par l'url |
| if (!isset($uid[0]) && !isset($uid[1]) && !isset($uid[2])) { |
| $this->messages[] = 'Aucun identifiant de publication, personne et role a été passé. Vous ne devriez pas avoir accès à ce service.'; |
| } else { |
| // Identification de l'utilisateur |
| list($id_utilisateur, $id_session) = $this->getIdentification($params); |
| // Contrôle du non détournement de l'utilisateur |
| if ($this->etreAutorise($id_utilisateur)) { |
| // Vérification des tables à vraiment mettre à jour en fonction des données passées. |
| $tables_a_modifier = $this->recupererTablesAModifier($params); |
| $id_publication = $params['cpuap_id_publication']; |
| $auteurs = explode(',', $params['cpuap_id_auteur']); |
| $id_role = $params['cpuap_id_role']; |
| $ordre = explode(',', $params['cpuap_ordre']); |
| if (count($auteurs) != 0 && $params['cpuap_id_publication'] != '') { |
| $compteur = 0; |
| foreach ($auteurs as $auteur) { |
| $params = array('cpuap_id_publication' => $id_publication, |
| 'cpuap_id_personne' => $auteur, |
| 'cpuap_id_role' => $id_role, |
| 'cpuap_ordre' => $ordre[$compteur++]); |
| $tables_a_modifier = $this->recupererTablesAModifier($params); |
| $table = $tables_a_modifier[119]; |
| if ($this->avoirEnregistrement($table)) { |
| $resultat = $this->supprimer($table); |
| if ($resultat === true) { |
| // Historisation (Ajout des méta-données) |
| $cle = $this->recupererCle($table); |
| $this->historiser(119, $cle, 'NULL', $id_utilisateur, 3, $id_session); |
| } |
| } |
| reset($tables_a_modifier); |
| while (list($table_id, $table) = each($tables_a_modifier)) { |
| if (!is_null($table['champs'])) { |
| try { |
| $this->mettreAJourAvecCle($id_utilisateur, $id_session, $table_id, $table); |
| } catch (PDOException $e) { |
| $this->messages[] = sprintf($this->getTxt('sql_erreur'), $e->getFile(), $e->getLine(), $e->getMessage(), $requete); |
| } |
| } |
| } |
| } |
| } else { |
| $this->messages[] = "Aucun identifiant d'auteur et de publication fournis"; |
| } |
| } else { |
| $this->messages[] = "Il faut être identifié pour accéder à ce service"; |
| } |
| } |
| // Envoie sur la sortie standard |
| $this->envoyer(); |
| } |
| /** |
| * Méthode appelée pour supprimer un élément |
| */ |
| public function deleteElement($uid) { |
| // NOTES : la suppression ne supprime pas les personnes mais seulements les relations |
| // Vérification de la présence des id passés par l'url |
| if (!isset($uid[0]) || !isset($uid[1])) { |
| $this->messages[] = "Identifiant de relations ou d'utilisateur manquant. Vous ne devriez pas avoir accès à ce service."; |
| } else { |
| // Identification de l'utilisateur |
| list($id_utilisateur, $id_session) = $this->getIdentification($uid[0]); |
| // Contrôle du non détournement de l'utilisateur |
| if ($this->etreAutorise($id_utilisateur)) { |
| // Récupération des identifiant à supprimer |
| $identifiants = array(); |
| $identifiants_agreges = explode(',', rtrim($uid[1], ',')); |
| foreach ($identifiants_agreges as $identifiant) { |
| $identifiants[] = explode('-', $identifiant); |
| } |
| if (count($identifiants) == 0) { |
| $this->messages[] = "Aucun enregistrement n'a été supprimé."; |
| } else { |
| try { |
| foreach ($identifiants as $id) { |
| if (count($id) == 1) { // Seulement des id de publication |
| // Suppression en une seule fois toutes les relations d'une publication |
| $params = array('cpuap_id_publication' => $id[0]); |
| } else if (count($id) == 3) { // Tous les id... |
| // Suppression d'une seule relation particulière |
| $params = array('cpuap_id_publication' => $id[0], 'cpuap_id_personne' => $id[1], 'cpuap_id_role' => $id[2]); |
| } |
| $tables_a_modifier = $this->recupererTablesAModifier($params); |
| $table = $tables_a_modifier[119]; |
| if ($this->avoirEnregistrement($table)) { |
| $resultat = $this->supprimer($table); |
| if ($resultat === true) { |
| // Historisation (Ajout des méta-données) |
| $cle = $this->recupererCle($table); |
| $this->historiser(119, $cle, 'NULL', $id_utilisateur, 3, $id_session); |
| } |
| } |
| } |
| } catch (PDOException $e) { |
| $this->messages[] = sprintf($this->getTxt('sql_erreur'), $e->getFile(), $e->getLine(), $e->getMessage(), $requete); |
| } |
| } |
| } |
| } |
| // Envoie sur la sortie standard |
| $this->envoyer(); |
| } |
| } |
| ?> |
| /branches/v1.11-okuzgozu/jrest/services/CoelCollectionAPublication.php |
|---|
| New file |
| 0,0 → 1,187 |
| <?php |
| /** |
| * Service fournissant la liste des relations "structure à personne". |
| * Encodage en entrée : utf8 |
| * Encodage en sortie : utf8 |
| * |
| * @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 $Id$ |
| * @copyright 2009 |
| */ |
| class CoelCollectionAPublication extends Coel { |
| /** Contient les infos sur les tables gérées par ce service. |
| * Bien respecter l'ordre avec en premier les tables liées et en dernier la table établissant la relation. */ |
| protected $tables = array( 104 => array( 'nom' => 'coel_collection_a_publication', |
| 'prefixe' => 'ccapu', |
| 'id' => array('ccapu_id_collection', 'ccapu_id_publication'))); |
| /** |
| * Méthode appelée avec une requête de type GET. |
| */ |
| public function getElement($param = array()) { |
| // Initialisation des variables |
| $info = array(); |
| // Pré traitement des paramêtres |
| $p = $this->traiterParametresUrl(array('id_collection','source'), $param); |
| // Construction de la requête |
| $requete = (($this->distinct) ? 'SELECT DISTINCT ' : 'SELECT '). |
| ' ccapu.*, cpu.*, cs.* '. |
| 'FROM coel_collection_a_publication AS ccapu '. |
| ' LEFT JOIN coel_meta_historique_ligne ON (ccapu_ce_meta = cmhl_id_historique_ligne) '. |
| ' LEFT JOIN coel_publication AS cpu ON (ccapu_id_publication = cpu_id_publication) '. |
| ' LEFT JOIN coel_structure AS cs ON (cs_id_structure = cpu_ce_truk_editeur) '. |
| ((count($p) != 0) ? 'WHERE ' : ''). |
| (isset($p['id_collection']) ? "AND ccapu_id_collection = {$p['id_collection']} " : ''). |
| (isset($p['source']) ? "AND ccapu_source = {$p['source']} " : ''). |
| 'ORDER BY '.((!is_null($this->orderby)) ? $this->orderby : 'ccapu_ce_meta DESC').' '; |
| $requete = str_replace('WHERE AND', 'WHERE', $requete); |
| $requeteCount = $requete; |
| $requete .= "LIMIT $this->start, $this->limit "; |
| //echo $requete;exit; |
| // Récupération des résultats |
| try { |
| $donnees = $this->bdd->query($requete)->fetchAll(PDO::FETCH_ASSOC); |
| if ($donnees === false) { |
| $this->messages[] = "La requête a retourné aucun résultat."; |
| } |
| $nbElements = $this->bdd->query($requeteCount)->rowCount(); |
| $info['nbElements'] = $nbElements; |
| $info['collectionsAPublication'] = $donnees; |
| } catch (PDOException $e) { |
| $this->messages[] = sprintf($this->getTxt('sql_erreur'), $e->getFile(), $e->getLine(), $e->getMessage()); |
| } |
| // Envoie sur la sortie standard |
| $this->envoyer($info); |
| } |
| /** |
| * Méthode appelée pour ajouter un élément. |
| */ |
| public function createElement($params) { |
| // Identification de l'utilisateur |
| list($id_utilisateur, $id_session) = $this->getIdentification($params); |
| // Contrôle du non détournement de l'utilisateur |
| if ($this->etreAutorise($id_utilisateur)) { |
| // Vérification des tables à vraiment mettre à jour en fonction des données passées. |
| $tables_a_modifier = $this->recupererTablesAModifier($params); |
| try { |
| // Pour chaque table du module nous lançons si nécessaire l'historisation puis la mise à jour |
| // Nous ne pouvons pas utiliser foreach car il travaille sur une copie du tableau or nous le modifions dynamiquement dans la boucle |
| reset($tables_a_modifier); |
| while (list($table_id, $table) = each($tables_a_modifier)) { |
| if (!is_null($table['champs'])) { |
| if (!$this->avoirCleComplete($table)) { |
| $this->messages[] = 'Il est nécessaire de fournir toutes les clés à ce service.'; |
| } else { |
| $this->mettreAJourAvecCle($id_utilisateur, $id_session, $table_id, $table); |
| } |
| } |
| } |
| } catch (PDOException $e) { |
| $this->messages[] = sprintf($this->getTxt('sql_erreur'), $e->getFile(), $e->getLine(), $e->getMessage()); |
| } |
| } |
| // Envoie sur la sortie standard |
| $this->envoyer(); |
| } |
| /** |
| * Méthode appelée pour mettre à jour un élément |
| */ |
| public function updateElement($uid, $params) { |
| // Vérification de la présence des id passés par l'url |
| if (!isset($uid[0]) && !isset($uid[1])) { |
| $this->messages[] = 'Aucun identifiant de collection a été passé. Vous ne devriez pas avoir accès à ce service.'; |
| } else { |
| // Identification de l'utilisateur |
| list($id_utilisateur, $id_session) = $this->getIdentification($params); |
| // Contrôle du non détournement de l'utilisateur |
| if ($this->etreAutorise($id_utilisateur)) { |
| // Vérification des tables à vraiment mettre à jour en fonction des données passées. |
| $tables_a_modifier = $this->recupererTablesAModifier($params); |
| try { |
| // Pour chaque table du module nous lançons si nécessaire l'historisation puis la mise à jour |
| foreach ($tables_a_modifier as $table_id => $table) { |
| $this->mettreAJourAvecCle($id_utilisateur, $id_session, $table_id, $table); |
| } |
| } catch (PDOException $e) { |
| $this->messages[] = sprintf($this->getTxt('sql_erreur'), $e->getFile(), $e->getLine(), $e->getMessage(), $requete); |
| } |
| } |
| } |
| // Envoie sur la sortie standard |
| $this->envoyer(); |
| } |
| /** |
| * Méthode appelée pour supprimer un ou plusieurs éléments |
| */ |
| public function deleteElement($uid) { |
| // NOTES : la suppression ne supprime pas les personnes mais seulements les relations |
| // Vérification de la présence des id passés par l'url |
| if (!isset($uid[0]) || !isset($uid[1])) { |
| $this->messages[] = "Identifiant de relations ou d'utilisateur manquant. Vous ne devriez pas avoir accès à ce service."; |
| } else { |
| // Identification de l'utilisateur |
| list($id_utilisateur, $id_session) = $this->getIdentification($uid[0]); |
| // Contrôle du non détournement de l'utilisateur |
| if ($this->etreAutorise($id_utilisateur)) { |
| // Récupération des identifiant à supprimer |
| $identifiants = array(); |
| $identifiants_agreges = explode(',', rtrim($uid[1], ',')); |
| foreach ($identifiants_agreges as $identifiant) { |
| $identifiants[] = explode('-', $identifiant); |
| } |
| if (count($identifiants) == 0) { |
| $this->messages[] = "Aucun enregistrement n'a été supprimé."; |
| } else { |
| try { |
| foreach ($identifiants as $id) { |
| if (count($id) == 1) { // Seulement des id de collection |
| $params = array('ccapu_id_collection' => $id[0]); |
| } else if (count($id) == 2) { // Tous les id... |
| $params = array('ccapu_id_collection' => $id[0], 'ccapu_id_publication' => $id[1]); |
| } |
| $tables_a_modifier = $this->recupererTablesAModifier($params); |
| $table = $tables_a_modifier[104]; |
| if ($this->avoirEnregistrement($table)) { |
| $resultat = $this->supprimer($table); |
| if ($resultat === true) { |
| // Historisation (Ajout des méta-données) |
| $cle = $this->recupererCle($table); |
| $this->historiser(104, $cle, 'NULL', $id_utilisateur, Coel::ETAT_SUPPRIMER, $id_session); |
| } |
| } |
| } |
| } catch (PDOException $e) { |
| $this->messages[] = sprintf($this->getTxt('sql_erreur'), $e->getFile(), $e->getLine(), $e->getMessage(), $requete); |
| } |
| } |
| } |
| } |
| // Envoie sur la sortie standard |
| $this->envoyer(); |
| } |
| } |
| ?> |
| /branches/v1.11-okuzgozu/jrest/services/CoelRecherche.php |
|---|
| New file |
| 0,0 → 1,495 |
| <?php |
| /** |
| * Service fournissant des informations sur les collections et les structures répondant aux critères de recherche |
| * fournis en paramètre. |
| * |
| * @author Mathias Chouet |
| * @author Raphaël Droz <raphael@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> |
| * @copyright 2009, 2013 Tela-Botanica |
| */ |
| class CoelRecherche extends Coel { |
| protected $fromClause = array(); |
| protected $whereClause = array(); |
| protected $joinClause = array(); |
| /** |
| * Méthode principale appelée avec une requête de type GET. |
| * Elle sert d'aiguilleur pour appeller la méthode correspondant au type de recherche passé en paramêtre. |
| */ |
| public function getElement($param = array()) { |
| // Initialisation des variables |
| $info = array(); |
| // Nous recherchons le type de requête demandé |
| $type = $param[0]; |
| $methode = 'getElement'.$type; |
| if (method_exists($this, $methode)) { |
| array_shift($param); |
| $info = $this->$methode($param); |
| } else { |
| $this->messages[] = "Le type de recherche demandé '$type' n'est pas disponible."; |
| } |
| // Envoie sur la sortie standard |
| if($this->formatRetour == 'text/plain') { |
| $this->envoyer($info, 'text/plain', 'utf-8', false); |
| exit; |
| } |
| $this->envoyer($info); |
| } |
| /** @deprecated retro-compatibilité */ |
| public function getElementParDefaut($param) { |
| return $this->getElementCollections($param); |
| } |
| /** @deprecated retro-compatibilité */ |
| public function getElementNombre($param) { |
| return $this->getElementNombreCollections($param); |
| } |
| /** |
| * Retourne les collections correspondant aux critères de recherche |
| */ |
| public function getElementCollections($param) { |
| // Pré traitement des paramêtres |
| $p = $this->pretraiterParametresUrlCollections($param, $_GET); |
| // Construction des clauses |
| self::construireFromEtWhereCollections($p); |
| // Construction de la requête |
| $champs = "cs_id_structure, cs_ville, cs_nom, cs_code_postal, cs_latitude, cs_longitude, cc_id_collection, cc_nom"; |
| $this->orderby = is_null($this->orderby) ? 'cs_ville ASC, cs_nom ASC, cc_nom ASC' : $this->orderby; |
| $requete = $this->assemblerRequete($champs); |
| $info =$this->lancerRequete($requete); |
| return $info; |
| } |
| /** |
| * Retourne le nombre de collections correspondant aux critères de recherche |
| */ |
| public function getElementNombreCollections($param) { |
| // Pré traitement des paramêtres |
| $p = $this->pretraiterParametresUrlCollections($param, $_GET); |
| // Construction des clauses |
| self::construireFromEtWhereCollections($p); |
| // Construction de la requête |
| // Il est important de compter le nombre d'association structure-collection différentes pour obtenir le bon nombre |
| // @WTF si on compte(*) on a le nombre d'associations structure-collection |
| // si on compte(cs_id_structure) on a le nombre d'associations structure-collection dont la structure n'est pas null |
| // en aucun cas on n'a le nombre d'association structure-collection DIFFERENTES, à moins de faire un distinct, ce qui n'est pas le cas ici |
| // @AMHA on devrait compter(*) car la recherche de collections renvoie même celles qui ont une structure null |
| $champs = 'COUNT(*) AS nbre, cc_id_collection '; |
| $this->orderby = is_null($this->orderby) ? 'cs_ville ASC, cs_nom ASC, cc_nom ASC' : $this->orderby; |
| $requete = $this->assemblerRequete($champs); |
| $info = $this->lancerRequeteNombre($requete); |
| return $info; |
| } |
| /** |
| * Retourne les personnes correspondant aux critères de recherche |
| */ |
| public function getElementPersonnes($param) { |
| // Pré traitement des paramêtres |
| $p = $this->pretraiterParametresUrlPersonnes($param, $_GET); |
| // Construction des clauses |
| self::construireFromEtWherePersonnes($p); |
| $champs = 'cp_id_personne, cp_fmt_nom_complet, cp_prenom, cp_nom, cp_truk_nom_autre, cp_adresse_01, cp_ville, cp_naissance_date, cp_deces_date'; |
| $this->orderby = is_null($this->orderby) ? 'cp_nom ASC, cp_prenom ASC' : $this->orderby; |
| $requete = $this->assemblerRequete($champs); |
| $info = $this->lancerRequete($requete); |
| return $info; |
| } |
| /** |
| * Retourne le nombre de personnes correspondant aux critères de recherche |
| */ |
| public function getElementNombrePersonnes($param) { |
| // Pré traitement des paramêtres |
| $p = $this->pretraiterParametresUrlPersonnes($param, $_GET); |
| // Construction des clauses |
| self::construireFromEtWherePersonnes($p); |
| $this->orderby = is_null($this->orderby) ? 'cp_nom ASC, cp_prenom ASC' : $this->orderby; |
| $champs = 'count(*) as nbre'; |
| // Construction de la requête |
| $requete = $this->assemblerRequete($champs); |
| $info = $this->lancerRequeteNombre($requete); |
| return $info; |
| } |
| /** |
| * Retourne les publications correspondant aux critères de recherche |
| */ |
| public function getElementPublications($param) { |
| // Pré traitement des paramêtres |
| $p = $this->pretraiterParametresUrlPublications($param, $_GET); |
| // Construction des clauses |
| self::construireFromEtWherePublications($p); |
| $champs = '*'; |
| $this->orderby = is_null($this->orderby) ? 'cpu_fmt_auteur ASC' : $this->orderby; |
| $requete = $this->assemblerRequete($champs); |
| $info = $this->lancerRequete($requete); |
| return $info; |
| } |
| /** |
| * Retourne le nombre de personnes correspondant aux critères de recherche |
| */ |
| public function getElementNombrePublications($param) { |
| // Pré traitement des paramêtres |
| $p = $this->pretraiterParametresUrlPublications($param, $_GET); |
| // Construction des clauses |
| self::construireFromEtWherePublications($p); |
| $this->orderby = is_null($this->orderby) ? 'cpu_fmt_auteur ASC' : $this->orderby; |
| $champs = 'count(*) as nbre'; |
| // Construction de la requête |
| $requete = $this->assemblerRequete($champs); |
| $info = $this->lancerRequeteNombre($requete); |
| return $info; |
| } |
| private function assemblerRequete($champs) { |
| // Construction de la requête |
| $requete = sprintf( |
| 'SELECT %s %s' |
| . ' FROM %s %s' |
| . ' WHERE %s ORDER BY %s %s -- %s:%d', |
| $this->distinct ? 'DISTINCT' : '', |
| $champs, |
| implode(',', $this->fromClause), |
| implode(' ', $this->joinClause), |
| $this->whereClause ? implode(" AND ", $this->whereClause) : TRUE, |
| $this->orderby, |
| $this->limit != -1 ? "LIMIT {$this->start}, {$this->limit}" : "", |
| __FILE__, |
| __LINE__ |
| ); |
| //echo "REQUETE: " . $requete; |
| //exit; |
| return $requete; |
| } |
| private function lancerRequete($requete) { |
| $info = array(); |
| // Récupération des résultats |
| try { |
| $donnees = $this->bdd->query($requete)->fetchAll(PDO::FETCH_ASSOC); |
| if ($donnees === false) { |
| $this->messages[] = "La requête n'a retourné aucun résultat."; |
| } else { |
| $info = $donnees; |
| } |
| } catch (PDOException $e) { |
| $this->messages[] = sprintf($this->getTxt('sql_erreur'), $e->getFile(), $e->getLine(), $e->getMessage()); |
| } |
| return $info; |
| } |
| private function lancerRequeteNombre($requete) { |
| $info = array(); |
| // Récupération des résultats |
| try { |
| $donnees = $this->bdd->query($requete)->fetch(PDO::FETCH_ASSOC); |
| if ($donnees === false) { |
| $this->messages[] = "La requête n'a retourné aucun résultat."; |
| } else { |
| $info = $donnees['nbre']; |
| } |
| } catch (PDOException $e) { |
| $this->messages[] = sprintf($this->getTxt('sql_erreur'), $e->getFile(), $e->getLine(), $e->getMessage()); |
| } |
| return $info; |
| } |
| // Voici les paramètres qu'il faut passer au service Collections, tous et dans l'ordre (soit une valeur soit '*') |
| private function pretraiterParametresUrlCollections($param, $qs) { |
| $params_passes = array( |
| 'mots' => 'str', |
| 'sci' => 'bool', |
| 'bot' => 'int', |
| 'lieu-stockage' => 'str', |
| 'zg' => 'str', |
| 'p' => 'str', |
| 'pr' => 'int', |
| 'str-d' => 'frdepliste', |
| 'veg' => 'int' |
| ); |
| return $this->pretraiterParametresUrl($param, $qs, $params_passes); |
| } |
| // Voici les paramètres qu'il faut passer au service Personnes, tous et dans l'ordre (soit une valeur soit '*') |
| private function pretraiterParametresUrlPersonnes($param, $qs) { |
| $params_passes = array( |
| 'nom-famille' => 'str', |
| 'adresse' => 'str', |
| 'date-vivant' => 'int' |
| ); |
| return $this->pretraiterParametresUrl($param, $qs, $params_passes); |
| } |
| // Voici les paramètres qu'il faut passer au service Personnes, tous et dans l'ordre (soit une valeur soit '*') |
| private function pretraiterParametresUrlPublications($param, $qs) { |
| $params_passes = array( |
| 'libre' => 'str', |
| 'titre' => 'str', |
| 'auteur' => 'str', |
| 'mot-cle' => 'str', |
| 'ouvrage' => 'str', |
| 'date' => 'str' |
| ); |
| return $this->pretraiterParametresUrl($param, $qs, $params_passes); |
| } |
| private function pretraiterParametresUrl($param, $qs, $params_passes) { |
| $p = $this->traiterParametresUrl(array_keys($params_passes), $param, false); |
| $this->debug[] = $param; |
| foreach ($params_passes as $param_passe => $type) { |
| if (isset($p[$param_passe])) { |
| // Suppression des éventuels espaces en début et fin de chaine |
| $valeur = trim($p[$param_passe]); |
| // Type de paramêtre chaine |
| if ($type == 'str') { |
| // Suppression des slash |
| $valeur = stripslashes($valeur); |
| // Utilisation d'une recherche de chaîne exacte |
| if (preg_match('/^"(.*)"$/', $valeur, $match)) { |
| $valeur = '%'.$match[1].'%'; |
| } else { |
| // Recherche de mots non liés |
| $mots = explode(' ', $valeur); |
| $valeur = '%'.implode ('%', $mots).'%'; |
| } |
| // Mise en place des quotes pour l'intérogation dans la bdd |
| $valeur = $this->bdd->quote($valeur); |
| } |
| // Type de paramêtre booléen |
| if ($type == 'bool') { |
| if (preg_match('/^[0]$/', $valeur)) { |
| $valeur = false; |
| } else if (preg_match('/^[1]$/', $valeur)) { |
| $valeur = true; |
| } else { |
| $this->messages[] = "Le paramêtre '$param_passe' attend une valeur de type 0 ou 1 et non '$valeur'."; |
| $valeur = null; |
| } |
| } |
| // Type de paramêtre entier |
| if ($type == 'int') { |
| if (!preg_match('/^(?:[0-9]+,\s*)*[0-9]+$/', $valeur)) { |
| $this->messages[] = "Le paramêtre '$param_passe' attend une ou plusieurs valeurs de type entiers ". |
| "séparés par des virgules et non '$valeur'."; |
| $valeur = null; |
| } |
| } |
| if ($type == 'frdepliste') { |
| $valeur = array_filter(explode(',', $valeur), create_function('$val', 'return preg_match("/^(\d+|2A|2B)$/i", $val);')); |
| } |
| $p[$param_passe] = $valeur; |
| } |
| } |
| if(isset($qs['pays'])) { |
| $p['pays'] = array_filter(explode(',', $qs['pays']), create_function('$val', 'return preg_match("/^[A-Z][A-Z]$/", $val);')); |
| if(!$p['pays']) unset($p['pays']); |
| } |
| return $p; |
| } |
| // construit les clauses FROM et WHERE pour la recherche de collections (#CaptainObvious) |
| private function construireFromEtWhereCollections($p) { |
| $this->fromClause = array('coel_collection'); |
| $this->joinClause = array('LEFT JOIN coel_structure ON (cc_ce_structure = cs_id_structure)'); |
| $this->whereClause = array(); |
| // Gestion du from en fonction des paramêtres |
| if (isset($p['str-d'])) {// ATTENTION : Remplace $this->fromClause, doit être situé en première position! |
| $this->fromClause = array('coel_structure'); |
| $this->joinClause = array('LEFT JOIN coel_collection ON (cs_id_structure = cc_ce_structure)'); |
| } |
| // Construire from et where en fonction des paramêtres |
| if (isset($p['mots'])) { |
| $this->whereClause[] = '(' . implode(' OR ', array( |
| "cc_nom LIKE {$p['mots']}", |
| "cc_truk_nom_alternatif LIKE {$p['mots']}", |
| "cc_truk_code LIKE {$p['mots']}", |
| "cc_description LIKE {$p['mots']}", |
| "cc_description_specialiste LIKE {$p['mots']}", |
| "cc_historique LIKE {$p['mots']}", |
| "cs_nom LIKE {$p['mots']}", |
| "cs_truk_nom_alternatif LIKE {$p['mots']}", |
| "cs_description LIKE {$p['mots']}", |
| "cs_adresse_01 LIKE {$p['mots']}", |
| "cs_ville LIKE {$p['mots']}", |
| "cs_truk_identifiant_alternatif LIKE {$p['mots']}", |
| "cs_condition_acces LIKE {$p['mots']}", |
| "cs_condition_usage LIKE {$p['mots']}", |
| "cs_truk_telephone LIKE {$p['mots']}", |
| "cs_courriel LIKE {$p['mots']}", |
| "cs_truk_url LIKE {$p['mots']}")) . ')'; |
| } |
| if (isset($p['sci'])) { |
| if ($p['sci'] === true) { |
| $this->whereClause[] = 'csv_mark_visite_avec_motif = 1'; |
| } else if ($p['sci'] === false) { |
| $this->whereClause[] = 'csv_mark_acces_ss_motif = 1'; |
| } |
| } |
| if (isset($p['bot'])) { |
| $this->whereClause[] = "ccb_ce_truk_type IN ({$p['bot']})"; |
| } |
| if (isset($p['lieu-stockage'])) { |
| $this->joinClause[] = 'LEFT JOIN coel_meta_liste_valeur cmlv ON cmlv.cmlv_id_valeur = cs_ce_truk_pays'; |
| $this->whereClause[] = '(' . implode(' OR ', array( |
| "cs_adresse_01 LIKE {$p['lieu-stockage']}", |
| "cs_code_postal LIKE {$p['lieu-stockage']}", |
| "cs_ville LIKE {$p['lieu-stockage']}", |
| "cs_ce_truk_pays LIKE {$p['lieu-stockage']}", |
| "cmlv.cmlv_nom LIKE {$p['lieu-stockage']}", |
| )) . ')'; |
| } |
| if (isset($p['zg'])) { |
| $this->whereClause[] = "cc_truk_couverture_lieu LIKE {$p['zg']}"; |
| } |
| if (isset($p['p'])) { |
| $this->whereClause[] = "cp_fmt_nom_complet LIKE {$p['p']}"; |
| } |
| if (isset($p['pr'])) { |
| $this->whereClause[] = "ccap_id_role IN ({$p['pr']})"; |
| } |
| // par défaut, spécifier un département restreint à la France |
| // TODO: INNER JOIN |
| if (isset($p['str-d'])) { |
| $this->joinClause[] = 'LEFT JOIN coel_meta_liste_valeur cv ON cv.cmlv_id_valeur = cs_ce_truk_pays'; |
| $this->whereClause[] = "cv.cmlv_abreviation IN ('FR', 'RE', 'YT', 'GP', 'MQ', 'GF', 'NC')"; |
| $this->whereClause[] = sprintf("cs_code_postal REGEXP '^(%s).*'", implode('|', $p['str-d'])); |
| } |
| if (isset($p['pays'])) { |
| if(array_search('FR', $p['pays']) !== FALSE) $p['pays'] = array_merge($p['pays'], array('RE','YT','GP','MQ','GF','NC')); |
| $this->joinClause[] = 'LEFT JOIN coel_meta_liste_valeur cv ON cv.cmlv_id_valeur = cs_ce_truk_pays'; |
| $this->whereClause[] = sprintf('cv.cmlv_abreviation IN ("%s")', implode('","', $p['pays'])); |
| } |
| if (isset($p['veg'])) { |
| $veg = explode(',', $p['veg']); |
| $veg_nbre = count($veg); |
| if ($veg_nbre == 1) { |
| $this->whereClause[] = "ccb_truk_nature LIKE '%{$p['veg']}%'"; |
| } else { |
| $recherche = array(); |
| foreach ($veg as $id) { |
| $recherche[] = "ccb_truk_nature LIKE '%$id%'"; |
| } |
| $this->whereClause[] = '('.implode(' OR ', $recherche).') '; |
| } |
| } |
| if (isset($p['sci'])) { |
| $this->joinClause[] = 'LEFT JOIN coel_structure_valorisation ON (cs_id_structure = csv_id_structure)'; |
| } |
| if (isset($p['bot']) || isset($p['veg'])) { |
| $this->joinClause[] = 'LEFT JOIN coel_collection_botanique ON (cc_id_collection = ccb_id_collection)'; |
| } |
| if (isset($p['p']) || isset($p['pr'])) { |
| $this->joinClause[] = 'LEFT JOIN coel_collection_a_personne ON (cc_id_collection = ccap_id_collection)'; |
| } |
| if (isset($p['p'])) { |
| $this->joinClause[] = 'LEFT JOIN coel_personne ON (ccap_id_personne = cp_id_personne)'; |
| } |
| $this->joinClause = array_unique($this->joinClause); |
| } |
| // construit les clauses FROM et WHERE pour la recherche de personnes (#CaptainObvious) |
| private function construireFromEtWherePersonnes($p) { |
| $this->fromClause = array('coel_personne'); |
| $this->joinClause = array(); |
| $this->whereClause = array(); |
| //"cp_truk_recolte LIKE {$p['adresse']}", // Inclure le lieu de récolte ? |
| if (isset($p['nom-famille'])) { |
| $this->whereClause[] = "cp_nom LIKE {$p['nom-famille']}"; |
| } |
| if (isset($p['adresse'])) { |
| $this->joinClause[] = 'LEFT JOIN coel_meta_liste_valeur cmlv ON cmlv.cmlv_id_valeur = cp_ce_truk_pays'; |
| $this->whereClause[] = '(' . implode(' OR ', array( |
| "cp_adresse_01 LIKE {$p['adresse']}", |
| "cp_code_postal LIKE {$p['adresse']}", |
| "cp_ville LIKE {$p['adresse']}", |
| "cp_ce_truk_pays LIKE {$p['adresse']}", |
| "cp_naissance_lieu LIKE {$p['adresse']}", |
| "cp_deces_lieu LIKE {$p['adresse']}", |
| "cmlv.cmlv_nom LIKE {$p['adresse']}", |
| )) . ')'; |
| } |
| if (isset($p['date-vivant'])) { |
| $this->whereClause[] = "cp_naissance_date <= {$p['date-vivant']}"; |
| $this->whereClause[] = "cp_deces_date >= {$p['date-vivant']}"; |
| $this->whereClause[] = "cp_naissance_date IS NOT NULL"; |
| $this->whereClause[] = "cp_deces_date IS NOT NULL"; |
| //$this->whereClause[] = "(cp_deces_date IS NULL OR cp_deces_date >= {$p['date-vivant']})"; |
| } |
| // pour inclure éventuellement les adresses de la structure |
| /*if (isset($p['adresse'])) { |
| $this->joinClause[] = 'JOIN coel_structure_a_personne ON (cp_id_personne = csap_id_personne)'; |
| $this->joinClause[] = 'JOIN coel_structure ON (cs_id_structure = csap_id_structure)'; |
| }*/ |
| $this->joinClause = array_unique($this->joinClause); |
| } |
| // construit les clauses FROM et WHERE pour la recherche de publications (#CaptainObvious) |
| private function construireFromEtWherePublications($p) { |
| $this->fromClause = array('coel_publication'); |
| $this->joinClause = array(); |
| $this->whereClause = array(); |
| if (isset($p['libre'])) { |
| $this->whereClause[] = "cpu_fmt_nom_complet LIKE {$p['libre']}"; |
| } |
| if (isset($p['titre'])) { |
| $this->whereClause[] = "cpu_titre LIKE {$p['titre']}"; |
| } |
| if (isset($p['auteur'])) { |
| $this->whereClause[] = "cpu_fmt_auteur LIKE {$p['auteur']}"; |
| } |
| if (isset($p['mot-cle'])) { |
| $this->whereClause[] = "cpu_resume_mot_cle LIKE {$p['mot-cle']}"; |
| } |
| if (isset($p['ouvrage'])) { |
| $this->whereClause[] = "cpu_collection LIKE {$p['ouvrage']}"; |
| } |
| if (isset($p['date'])) { |
| $this->whereClause[] = "cpu_date_parution LIKE {$p['date']}"; |
| } |
| } |
| } |
| /branches/v1.11-okuzgozu/jrest/services/CoelPersonne.php |
|---|
| New file |
| 0,0 → 1,266 |
| <?php |
| /** |
| * Service fournissant la liste des personnes et leurs informations |
| * Encodage en entrée : utf8 |
| * Encodage en sortie : utf8 |
| * |
| * @author Grégoire duché <gregoire@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 $Id$ |
| * @copyright 2009 |
| */ |
| class CoelPersonne extends Coel { |
| protected $tables = array( 113 => array('nom' => 'coel_personne', |
| 'prefixe' => 'cp', |
| 'id' => array('cp_id_personne'))); |
| /** |
| * Méthode appelée avec une requête de type GET. |
| * |
| * Liste des paramètres : |
| * /Personne_Id/Nom_Complet/ |
| * Attention : pour avoir toutes les personnes, il faut éxécuter : CoelPersonneListe |
| * Pour avoir toutes les personnes dont le nom complet comment par NomComplet il faut éxécuter : CoelPersonneListe/* /NomComplet |
| */ |
| function getElement($param = array()) { |
| // Initialisation de variables |
| $info = array(); |
| // Pré traitement des paramêtres |
| $p = $this->traiterParametresUrl(array('id_personne', 'recherche'), $param); |
| // Construction de la requête |
| $requete = (($this->distinct) ? 'SELECT DISTINCT' : 'SELECT').' cp.*, '. |
| ' cmhl_date_modification, cmhl_notes, cmhl_source, cmhl_ce_modifier_par, cmhl_ce_etat, cmhl_ip '. |
| 'FROM coel_personne AS cp '. |
| ' LEFT JOIN coel_meta_historique_ligne ON (cp_ce_meta = cmhl_id_historique_ligne) '. |
| ((count($p) != 0) ? 'WHERE ' : ''). |
| (isset($p['id_personne']) ? "AND cp_id_personne = {$p['id_personne']} " : ''). |
| (isset($p['recherche']) ? $this->construireWhereRecherche($p['recherche']) : ''). |
| 'ORDER BY '.((!is_null($this->orderby)) ? $this->orderby : 'TRIM(cp_nom) ASC').' '; |
| $requete = str_replace('WHERE AND', 'WHERE', $requete); |
| $requeteCount = $requete; |
| $requete .= "LIMIT $this->start, $this->limit "; |
| // Exécution de la requêtre SQL et test d'éventuelles erreurs |
| try { |
| $donnees = $this->bdd->query($requete)->fetchAll(PDO::FETCH_ASSOC); |
| if ($donnees === false) { |
| $this->messages[] = "La requête a retourné aucun résultat."; |
| } |
| $nbElements = $this->bdd->query($requeteCount)->rowCount(); |
| $info['nbElements'] = $nbElements; |
| $info['personnes'] = $donnees; |
| } catch (PDOException $e) { |
| $this->messages[] = sprintf($this->getTxt('sql_erreur'), $e->getFile(), $e->getLine(), $e->getMessage()); |
| } |
| // Envoie sur la sortie standard |
| $this->envoyer($info); |
| } |
| private function construireWhereRecherche($recherche) { |
| $recherche = "AND ". |
| "(". |
| "cp_fmt_nom_complet LIKE {$recherche} OR ". |
| "cp_code_postal LIKE {$recherche} OR ". |
| "cp_ville LIKE {$recherche} OR ". |
| "cp_truk_courriel LIKE {$recherche} ". |
| ")"; |
| return $recherche; |
| } |
| /** |
| * Méthode appelée pour ajouter un élément. |
| */ |
| public function createElement($params) { |
| // Identification de l'utilisateur |
| list($id_utilisateur, $id_session) = $this->getIdentification($params); |
| $id_personne = null; |
| // Contrôle du non détournement de l'utilisateur |
| if ($this->etreAutorise($id_utilisateur)) { |
| try { |
| // Vérification des tables à vraiment mettre à jour en fonction des données passées. |
| $tables_a_modifier = $this->recupererTablesAModifier($params); |
| reset($tables_a_modifier); |
| while (list($table_id, $table) = each($tables_a_modifier)) { |
| if (!is_null($table['champs'])) { |
| if (!$this->avoirCleComplete($table)) { |
| // Ajout des données à la table des données |
| $id_personne = $this->ajouter($table); |
| if ($id_personne !== false) { |
| $table['champs_valeurs_id']['cp_id_personne'] = $id_personne; |
| $table['champs_valeurs_brut']['cp_id_personne'] = $id_personne; |
| // Historisation (Ajout des méta-données) |
| $etat = 1; // Ajout |
| $cle = $this->recupererCle($table); |
| $info = $this->creerXmlHisto($table['champs_valeurs_brut']); |
| $id_meta = $this->historiser($table_id, $cle, $info, $id_utilisateur, $etat, $id_session); |
| // Liaison de la table des données à ses méta-données |
| $champ_meta = "{$table['prefixe']}_ce_meta"; |
| $table['champs_valeurs_protege'] = array($champ_meta => $id_meta); |
| $this->modifier($table); |
| } |
| } else { |
| $this->mettreAJourAvecCle($id_utilisateur, $id_session, $table_id, $table); |
| } |
| } |
| } |
| } catch (PDOException $e) { |
| $this->messages[] = sprintf($this->getTxt('sql_erreur'), $e->getFile(), $e->getLine(), $e->getMessage(), $requete); |
| } |
| } |
| $this->envoyer((string) $id_personne); |
| } |
| /** |
| * Méthode appelée pour mettre à jour un élément |
| */ |
| public function updateElement($uid, $params) { |
| //Mise à jour de la personne |
| // Identification de l'utilisateur |
| list($id_utilisateur, $id_session) = $this->getIdentification($params); |
| // Contrôle du non détournement de l'utilisateur |
| if ($this->etreAutorise($id_utilisateur)) { |
| try { |
| $id_personne = $uid[0]; |
| if (($id_personne == null)||(trim($id_personne) == "")) { |
| $this->messages[] = 'Aucun identifiant de personne n\'a été fourni'; |
| } else { |
| // Vérification des tables à vraiment mettre à jour en fonction des données passées. |
| $tables_a_modifier = $this->recupererTablesAModifier($params); |
| // Pour chaque table du module nous lançons si nécessaire l'historisation puis la mise à jour |
| foreach ($tables_a_modifier as $table_id => $table) { |
| $this->mettreAJourAvecCle($id_utilisateur, $id_session, $table_id, $table); |
| } |
| $infos_utilisateur = $this->getUtilisateur(); |
| // si la mise à jour concerne l'utilisateur actuellement identifié |
| // @TODO refaire autrement - de toute façon, ne marchait pas (rechargeait à chaque fois !) |
| /*if($id_utilisateur == $infos_utilisateur['id']) { |
| $this->rechargerCookieUtilisateur(); |
| }*/ |
| } |
| } catch (PDOException $e) { |
| $messages[] = sprintf($this->getTxt('sql_erreur'), $e->getFile(), $e->getLine(), $e->getMessage(), $requete); |
| } |
| } |
| $this->envoyer(); |
| } |
| /** |
| * Méthode appelée pour supprimer un élément |
| */ |
| public function deleteElement($uid) { |
| // Vérification de la présence des id passés par l'url |
| if (!isset($uid[0]) || !isset($uid[1])) { |
| $this->messages[] = "Identifiant d'utilisateur ou de personne manquant. Vous ne devriez pas avoir accès à ce service."; |
| } else { |
| list($id_utilisateur, $id_session) = $this->getIdentification($uid[0]); |
| // Contrôle du non détournement de l'utilisateur |
| if ($this->etreAutorise($id_utilisateur)) { |
| // Récupération des id passés par l'url |
| $identifiants = explode(',', rtrim($uid[1], ',')); |
| if (count($identifiants) == 0) { |
| $this->messages[] = "Aucun enregistrement n'a été supprimé."; |
| } else { |
| foreach ($identifiants as $id_personne) { |
| try { |
| // Vérification de la liaison avec d'autres données et génération des messages d'erreur |
| if ($this->verifierPresencePersonne($id_personne) === false) { |
| $params = array('cp_id_personne' => $id_personne); |
| $tables_a_modifier = $this->recupererTablesAModifier($params); |
| foreach ($tables_a_modifier as $table_id => $table) { |
| if ($this->avoirEnregistrement($table)) { |
| $resultat = $this->supprimer($table); |
| if ($resultat === true) { |
| // Historisation (Ajout des méta-données) |
| $cle = $this->recupererCle($table); |
| $this->historiser($table_id, $cle, 'NULL', $id_utilisateur, 3, $id_session); |
| } |
| } else { |
| $this->messages[] = "Aucun enregistrement correspondant dans la base de données."; |
| } |
| } |
| } |
| } catch (PDOException $e) { |
| $this->messages[] = sprintf($this->getTxt('sql_erreur'), $e->getFile(), $e->getLine(), $e->getMessage(), $requete); |
| } |
| } |
| } |
| } |
| } |
| // Envoie sur la sortie standard |
| $this->envoyer(); |
| } |
| private function verifierPresencePersonne($id_personne) { |
| $presence = false; |
| if ($presence = $this->verifierPresenceDansStructure($id_personne)) { |
| $this->messages[] = 'Cette personne ne peut être supprimée car elle est liée à une structure'; |
| } else if ($presence = $this->verifierPresenceDansCollection($id_personne)) { |
| $this->messages[] = 'Cette personne ne peut être supprimée car elle est liée à une collection'; |
| } else if ($presence = $this->verifierPresenceDansPublication($id_personne)) { |
| $this->messages[] = 'Cette personne ne peut être supprimée car elle est liée à une publication'; |
| } else if ($presence = $this->verifierPresenceDansRelation01($id_personne)) { |
| $this->messages[] = "Cette personne ne peut être supprimée car elle est le sujet d'une relation"; |
| } else if ($presence = $this->verifierPresenceDansRelation02($id_personne)) { |
| $this->messages[] = "Cette personne ne peut être supprimée car elle est l'objet d'une relation"; |
| } |
| return $presence; |
| } |
| private function verifierPresenceDansStructure($id_personne) { |
| $requete = 'SELECT COUNT(csap_id_personne) AS nbre '. |
| 'FROM coel_structure_a_personne '. |
| "WHERE csap_id_personne = '$id_personne' ". |
| 'GROUP BY csap_id_personne '; |
| return $this->contenirDonnees($requete); |
| } |
| private function verifierPresenceDansCollection($id_personne) { |
| $requete = 'SELECT COUNT(ccap_id_personne) AS nbre '. |
| 'FROM coel_collection_a_personne '. |
| "WHERE ccap_id_personne = '$id_personne' ". |
| 'GROUP BY ccap_id_personne '; |
| return $this->contenirDonnees($requete); |
| } |
| private function verifierPresenceDansPublication($id_personne) { |
| $requete = 'SELECT COUNT(cpuap_id_personne) AS nbre '. |
| 'FROM coel_publication_a_personne '. |
| "WHERE cpuap_id_personne = '$id_personne' ". |
| 'GROUP BY cpuap_id_personne '; |
| return $this->contenirDonnees($requete); |
| } |
| private function verifierPresenceDansRelation01($id_personne) { |
| $requete = 'SELECT COUNT(cpar_id_personne_01) AS nbre '. |
| 'FROM coel_personne_a_relation '. |
| "WHERE cpar_id_personne_01 = '$id_personne' ". |
| 'GROUP BY cpar_id_personne_01 '; |
| return $this->contenirDonnees($requete); |
| } |
| private function verifierPresenceDansRelation02($id_personne) { |
| $requete = 'SELECT COUNT(cpar_id_personne_02) AS nbre '. |
| 'FROM coel_personne_a_relation '. |
| "WHERE cpar_id_personne_02 = '$id_personne' ". |
| 'GROUP BY cpar_id_personne_02 '; |
| return $this->contenirDonnees($requete); |
| } |
| } |
| ?> |
| /branches/v1.11-okuzgozu/jrest/services/CoelCollection.php |
|---|
| New file |
| 0,0 → 1,334 |
| <?php |
| /** |
| * Service fournissant la liste des collections et leurs informations. |
| * Encodage en entrée : utf8 |
| * Encodage en sortie : utf8 |
| * |
| * @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 $Id$ |
| * @copyright 2009 |
| */ |
| class CoelCollection extends Coel { |
| protected $tables = array( 101 => array( |
| 'nom' => 'coel_collection', |
| 'prefixe' => 'cc', |
| 'id' => array('cc_id_collection')), |
| 106 => array( |
| 'nom' => 'coel_collection_botanique', |
| 'prefixe' => 'ccb', |
| 'id' => array('ccb_id_collection'))); |
| /** |
| * Méthode principale appelée avec une requête de type GET. |
| */ |
| public function getElement($param = array()) { |
| // Initialisation des variables |
| $info = array(); |
| // Nour recherchons le type de requête demandé |
| $type = $param[0]; |
| if ($type == '*' || is_numeric($type)) { |
| $info = $this->getElementParDefaut($param); |
| } else { |
| $methode = 'getElement'.$type; |
| if (method_exists($this, $methode)) { |
| array_shift($param); |
| $info = $this->$methode($param); |
| } else { |
| $this->messages[] = "Le type d'information demandé '$type' n'est pas disponible."; |
| } |
| } |
| // Envoie sur la sortie standard |
| $this->envoyer($info); |
| } |
| /** |
| * Méthode par défaut pour garder la compatibilité avec Coel. |
| * Appelée avec les paramêtres d'url suivant : |
| * /CoelCollection/_/_/_ |
| * ou les _ représentent dans l'ordre : id_collection ou nom |
| * Si un des paramêtres est abscent, il prendre la valeur * |
| */ |
| public function getElementParDefaut($param) { |
| // Initialisation des variables |
| $info = array(); |
| // Pré traitement des paramêtres |
| $p = $this->traiterParametresUrl(array('id_collection', 'recherche'), $param); |
| // Construction de la requête |
| $requete = (($this->distinct) ? 'SELECT DISTINCT' : 'SELECT').' c.*, cb.*, '. |
| ' cmhl_date_modification, cmhl_notes, cmhl_source, cmhl_ce_modifier_par, cmhl_ce_etat, cmhl_ip, '. |
| ' ccm.cc_nom AS _collection_mere_nom_, '. |
| ' cs_nom AS _structure_nom_, cs_ville AS _structure_ville_ '. |
| 'FROM coel_collection AS c'. |
| ' LEFT JOIN coel_meta_historique_ligne AS cmhl ON (c.cc_ce_meta = cmhl_id_historique_ligne) '. |
| ' LEFT JOIN coel_structure ON (c.cc_ce_structure = cs_id_structure) '. |
| ' LEFT JOIN coel_collection AS ccm ON (c.cc_ce_mere = ccm.cc_id_collection) '. |
| ' LEFT JOIN coel_collection_botanique AS cb ON (c.cc_id_collection = ccb_id_collection) '. |
| ((count($p) != 0) ? 'WHERE ' : ''). |
| ((isset($p['id_collection'])) ? "AND c.cc_id_collection = {$p['id_collection']} " : ''). |
| (isset($p['recherche']) ? $this->construireWhereRecherche($p['recherche']) : ''). |
| 'ORDER BY '.((!is_null($this->orderby)) ? $this->orderby : 'c.cc_nom ASC').' '; |
| $requete = str_replace('WHERE AND', 'WHERE', $requete); |
| $requeteCount = $requete; |
| $requete .= "LIMIT $this->start, $this->limit "; |
| // Récupération des résultats |
| try { |
| // SPÉCIAL : |
| // Lorsqu'on cherche une seule structure avec un id passé en paramêtre, nous devons renvoyer un objet |
| $donnees = (isset($p['id_collection'])) ? $this->bdd->query($requete)->fetch(PDO::FETCH_OBJ) : $this->bdd->query($requete)->fetchAll(PDO::FETCH_ASSOC); |
| if ($donnees === false) { |
| $this->messages[] = "La requête a retourné aucun résultat."; |
| } |
| $nbElements = $this->bdd->query($requeteCount)->rowCount(); |
| $info['nbElements'] = $nbElements; |
| $info['collections'] = $donnees; |
| } catch (PDOException $e) { |
| $this->messages[] = sprintf($this->getTxt('sql_erreur'), $e->getFile(), $e->getLine(), $e->getMessage()); |
| } |
| return $info; |
| } |
| private function construireWhereRecherche($recherche) { |
| $recherche = "AND ". |
| "(". |
| "c.cc_nom LIKE {$recherche} OR ". |
| "cs_ville LIKE {$recherche} ". |
| ")"; |
| return $recherche; |
| } |
| /* Méthode pour récupérer une liste de collection en fonction d'un id structure. |
| * Appelée avec les paramêtres d'url suivant : |
| * /CoelCollection/ParIdStructure/_ |
| * ou les _ représentent dans l'ordre : id_structure |
| * Si un des paramêtres est abscent, il prendre la valeur * |
| */ |
| public function getElementParIdStructure($param) { |
| // Initialisation des variables |
| $info = array(); |
| // Pré traitement des paramêtres |
| $p = $this->traiterParametresUrl(array('id_structure'), $param); |
| if (!isset($p['id_structure'])) { |
| $this->messages[] = "Il est obligatoire d'indiquer un id de structure pour utiliser ce service."; |
| } else { |
| // Construction de la requête |
| $requete = (($this->distinct) ? 'SELECT DISTINCT' : 'SELECT').' cc_nom, cc_id_collection '. |
| 'FROM coel_collection AS c '. |
| 'WHERE '. |
| " c.cc_ce_structure = {$p['id_structure']} ". |
| 'ORDER BY '.((!is_null($this->orderby)) ? $this->orderby : 'c.cc_nom ASC').' '. |
| "LIMIT $this->start, $this->limit "; |
| // Récupération des résultats |
| try { |
| // SPÉCIAL : |
| // Lorsqu'on cherche une seule structure avec un id passé en paramêtre, nous devons renvoyer un objet |
| $donnees = $this->bdd->query($requete)->fetchAll(PDO::FETCH_ASSOC); |
| if ($donnees === false) { |
| $this->messages[] = "La requête a retourné aucun résultat."; |
| } else { |
| $info = $donnees; |
| } |
| } catch (PDOException $e) { |
| $this->messages[] = sprintf($this->getTxt('sql_erreur'), $e->getFile(), $e->getLine(), $e->getMessage()); |
| } |
| } |
| return $info; |
| } |
| /* Méthode pour récupérer le nombre de collection en fonction d'un id structure. |
| * Appelée avec les paramêtres d'url suivant : |
| * /CoelCollection/NbreParIdStructure/_ |
| * ou les _ représentent dans l'ordre : id_structure |
| * Si un des paramêtres est abscent, il prendre la valeur * |
| */ |
| public function getElementNbreParIdStructure($param) { |
| // Initialisation des variables |
| $info = array(); |
| // Pré traitement des paramêtres |
| $p = $this->traiterParametresUrl(array('id_structure'), $param); |
| if (!isset($p['id_structure'])) { |
| $this->messages[] = "Il est obligatoire d'indiquer un id de structure pour utiliser ce service."; |
| } else { |
| // Construction de la requête |
| $requete = (($this->distinct) ? 'SELECT DISTINCT' : 'SELECT').' COUNT(cc_id_collection) AS nbre '. |
| 'FROM coel_collection AS c '. |
| 'WHERE '. |
| " c.cc_ce_structure = {$p['id_structure']} ". |
| 'ORDER BY '.((!is_null($this->orderby)) ? $this->orderby : 'c.cc_nom ASC'); |
| // Récupération des résultats |
| try { |
| // SPÉCIAL : |
| // Lorsqu'on cherche une seule structure avec un id passé en paramêtre, nous devons renvoyer un objet |
| $donnees = $this->bdd->query($requete)->fetch(PDO::FETCH_ASSOC); |
| if ($donnees === false) { |
| $this->messages[] = "La requête a retourné aucun résultat."; |
| } else { |
| $info = $donnees['nbre']; |
| } |
| } catch (PDOException $e) { |
| $this->messages[] = sprintf($this->getTxt('sql_erreur'), $e->getFile(), $e->getLine(), $e->getMessage()); |
| } |
| } |
| return $info; |
| } |
| /** |
| * Méthode appelée pour ajouter un élément. |
| */ |
| public function createElement($params) { |
| // Identification de l'utilisateur |
| list($id_utilisateur, $id_session) = $this->getIdentification($params); |
| // Contrôle du non détournement de l'utilisateur |
| if ($this->etreAutorise($id_utilisateur)) { |
| try { |
| // Vérification des tables à vraiment mettre à jour en fonction des données passées. |
| $tables_a_modifier = $this->recupererTablesAModifier($params); |
| reset($tables_a_modifier); |
| $id_collection = null; |
| while (list($table_id, $table) = each($tables_a_modifier)) { |
| if (!is_null($table['champs'])) { |
| if (!$this->avoirCleComplete($table)) { |
| // Ajout des données à la table des données |
| $id_collection = $this->ajouter($table); |
| if ($id_collection !== false) { |
| $table['champs_valeurs_id']['cc_id_collection'] = $id_collection; |
| $table['champs_valeurs_brut']['cc_id_collection'] = $id_collection; |
| $tables_a_modifier[106]['champs_valeurs_id']['ccb_id_collection'] = $id_collection; |
| $tables_a_modifier[106]['champs_valeurs_brut']['ccb_id_collection'] = $id_collection; |
| $tables_a_modifier[106]['champs_valeurs_protege']['ccb_id_collection'] = $this->bdd->quote($id_collection); |
| // Historisation (Ajout des méta-données) |
| $etat = 1; // Ajout |
| $cle = $this->recupererCle($table); |
| $info = $this->creerXmlHisto($table['champs_valeurs_brut']); |
| $id_meta = $this->historiser($table_id, $cle, $info, $id_utilisateur, $etat, $id_session); |
| // Liaison de la table des données à ses méta-données |
| $champ_meta = "{$table['prefixe']}_ce_meta"; |
| $table['champs_valeurs_protege'] = array($champ_meta => $id_meta); |
| $this->modifier($table); |
| } |
| } else { |
| $this->mettreAJourAvecCle($id_utilisateur, $id_session, $table_id, $table); |
| } |
| } |
| } |
| if(!isset($params['cpr_abreviation'])) { |
| $params['cpr_abreviation'] = ''; |
| } |
| $this->ajouterGuid($params['cpr_abreviation'], $id_collection); |
| } catch (PDOException $e) { |
| $this->messages[] = sprintf($this->getTxt('sql_erreur'), $e->getFile(), $e->getLine(), $e->getMessage(), $requete); |
| } |
| } |
| $this->envoyer($id_collection); |
| } |
| /** |
| * Méthode appelée pour mettre à jour un élément |
| */ |
| public function updateElement($uid, $params) { |
| // Vérification de la présence des id passés par l'url |
| if (!isset($uid[0])) { |
| $this->messages[] = "Identifiant de collection manquant. Vous ne devriez pas avoir accès à ce service."; |
| } else { |
| // Identification de l'utilisateur |
| list($id_utilisateur, $id_session) = $this->getIdentification($params); |
| // Contrôle du non détournement de l'utilisateur |
| if ($this->etreAutorise($id_utilisateur)) { |
| try { |
| // Vérification des tables à vraiment mettre à jour en fonction des données passées. |
| $tables_a_modifier = $this->recupererTablesAModifier($params); |
| // Pour chaque table du module nous lançons si nécessaire l'historisation puis la mise à jour |
| foreach ($tables_a_modifier as $table_id => $table) { |
| $this->mettreAJourAvecCle($id_utilisateur, $id_session, $table_id, $table); |
| } |
| } catch (PDOException $e) { |
| $this->messages[] = sprintf($this->getTxt('sql_erreur'), $e->getFile(), $e->getLine(), $e->getMessage(), $requete); |
| } |
| } |
| } |
| // Envoie sur la sortie standard |
| $this->envoyer(); |
| } |
| /** |
| * Méthode appelée pour supprimer un élément |
| */ |
| public function deleteElement($uid) { |
| // Vérification de la présence des id passés par l'url |
| if (!isset($uid[0]) || !isset($uid[1])) { |
| $this->messages[] = "Identifiant de collection ou d'utilisateur manquant. Vous ne devriez pas avoir accès à ce service."; |
| } else { |
| // Identification de l'utilisateur |
| list($id_utilisateur, $id_session) = $this->getIdentification($uid[0]); |
| // Contrôle du non détournement de l'utilisateur |
| if ($this->etreAutorise($id_utilisateur)) { |
| // Récupération des id passés par l'url |
| $identifiants = explode(',', rtrim($uid[1], ',')); |
| try { |
| if (count($identifiants) == 0) { |
| $this->messages[] = "Aucun enregistrement n'a été supprimé."; |
| } else { |
| foreach ($identifiants as $id_collection) { |
| // Vérification que la structure ne possède pas de collections liées |
| $params = array('cc_id_collection' => $id_collection, 'ccb_id_collection' => $id_collection); |
| $tables_a_modifier = $this->recupererTablesAModifier($params); |
| foreach ($tables_a_modifier as $table_id => $table) { |
| if ($this->avoirEnregistrement($table)) { |
| $resultat = $this->supprimer($table); |
| if ($resultat === true) { |
| // Historisation (Ajout des méta-données) |
| $cle = $this->recupererCle($table); |
| $this->historiser($table_id, $cle, 'NULL', $id_utilisateur, 3, $id_session); |
| } |
| } |
| } |
| } |
| } |
| } catch (PDOException $e) { |
| $this->messages[] = sprintf($this->getTxt('sql_erreur'), $e->getFile(), $e->getLine(), $e->getMessage(), $requete); |
| } |
| } |
| } |
| // Envoie sur la sortie standard |
| $this->envoyer(); |
| } |
| private function ajouterGuid($id_collection) { |
| if ($id_collection !== false) { |
| $table_guid = $this->tables[101]; |
| $table_guid['champs_valeurs_id']['cc_id_collection'] = $id_collection; |
| $table_guid['champs_valeurs_protege']['cc_guid'] = $this->bdd->quote(sprintf($this->config['coel']['guid'], 'coll'.$id_collection)); |
| $this->modifier($table_guid); |
| } |
| } |
| } |
| ?> |
| /branches/v1.11-okuzgozu/jrest/services/CoelValeurListe.php |
|---|
| New file |
| 0,0 → 1,161 |
| <?php |
| /** |
| * Service fournissant une liste de valeurs. |
| * Encodage en entrée : utf8 |
| * Encodage en sortie : utf8 |
| * |
| * Cas d'utilisation : |
| * /CoelValeurListe/id/1001 : retourne les valeurs de la liste d'identifiant 1001 |
| * /CoelValeurListe/ab/12 : retourne les valeurs de la liste dont l'abréviation vaut "12" |
| * /CoelValeurListe/abv/FR.__ : retourne les valeurs dont l'abréviation équivaut (= LIKE) "FR.__" |
| * * /CoelValeurListe/abv/FR.__/1078 : retourne les valeurs dont l'abréviation équivaut (= LIKE) "FR.__" pour la liste d'identifiant 1078. |
| * |
| * @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 $Id$ |
| * @copyright 2009 |
| */ |
| Class CoelValeurListe extends Coel { |
| /** |
| * Méthode appelée avec une requête de type GET. |
| */ |
| function getElement($param = array()) { |
| // Initialisation des variables |
| $info = array();// Tableau associatif des paramêtres |
| $requete = null; |
| $requete_compte = null; |
| // Pré traitement des paramêtres |
| $p = $this->traiterParametresUrl(array('type', 'ceParent', 'abreviation', 'idValeur', "nom"), $param); |
| // Construction de la requête |
| if (!isset($p['idValeur'])) { |
| $p['idValeur'] = "'%'"; |
| } |
| if (!isset($p['abreviation'])) { |
| $p['abreviation'] = "'%'"; |
| } |
| $p['type'] = trim($p['type'], "'"); |
| switch ($p['type']) { |
| case 'identifiant' : |
| // Nous avons un identifiant de liste, nous récupérons seulement les valeurs de cette liste |
| $requete = (($this->distinct) ? 'SELECT DISTINCT' : 'SELECT').' * '. |
| 'FROM coel_meta_liste_valeur '. |
| "WHERE cmlv_id_valeur = {$p['idValeur']} ". |
| 'ORDER BY '.((!is_null($this->orderby)) ? $this->orderby : 'cmlv_id_valeur ASC').' '; |
| $requete_compte = $requete; |
| break; |
| case 'id' : |
| // Nous avons un identifiant de liste, nous récupérons seulement les valeurs de cette liste |
| $requete = (($this->distinct) ? 'SELECT DISTINCT' : 'SELECT').' * '. |
| 'FROM coel_meta_liste_valeur '. |
| "WHERE cmlv_ce_parent = {$p['ceParent']} ". |
| "AND cmlv_id_valeur LIKE {$p['idValeur']} ". |
| 'ORDER BY '.((!is_null($this->orderby)) ? $this->orderby : 'cmlv_id_valeur ASC').' '; |
| $requete_compte = $requete; |
| $requete .= "LIMIT $this->start,$this->limit "; |
| break; |
| case 'idv' : |
| // Nous avons un ou plusieurs identifiants de valeurs, nous les récupérons |
| $p = $this->traiterParametresUrl(array('type', 'idValeur'), $param); |
| $requete = (($this->distinct) ? 'SELECT DISTINCT' : 'SELECT').' * '. |
| 'FROM coel_meta_liste_valeur '. |
| 'WHERE cmlv_id_valeur IN ('.$this->traiterBddClauseIn($p['idValeur']).') '. |
| 'ORDER BY '.((!is_null($this->orderby)) ? $this->orderby : 'cmlv_id_valeur ASC').' '. |
| "LIMIT $this->start,$this->limit "; |
| break; |
| case 'ab' : |
| // Nous avons une abréviation de liste, nous récupérons seulement les valeurs de cette liste |
| $requete = (($this->distinct) ? 'SELECT DISTINCT' : 'SELECT').' v.* '. |
| 'FROM coel_meta_liste_valeur AS l LEFT JOIN coel_meta_liste_valeur AS v ON (l.cmlv_id_valeur = v.cmlv_ce_parent) '. |
| 'WHERE l.cmlv_ce_parent = 0 '. |
| "AND l.cmlv_abreviation LIKE {$p['abreviation']} ". |
| 'ORDER BY '.((!is_null($this->orderby)) ? $this->orderby : 'v.cmlv_id_valeur ASC').' '; |
| $requete_compte = $requete; |
| $requete .= "LIMIT $this->start,$this->limit "; |
| break; |
| case 'abv' : |
| // Nous avons une abréviation de valeur, nous récupérons toutes les valeurs correspondantes |
| $requete = (($this->distinct) ? 'SELECT DISTINCT' : 'SELECT').' * '. |
| 'FROM coel_meta_liste_valeur '. |
| "WHERE "; |
| // spécial outre-mer française |
| if($p['abreviation'] == "'FR%'" && $p['ceParent'] == "'1078'") { |
| $requete .= "cmlv_abreviation REGEXP '^(FR|RE|YT|GP|MQ|GF|NC)...$' "; |
| } else { |
| $requete .= "cmlv_abreviation LIKE {$p['abreviation']} "; |
| } |
| $requete .= isset($p['ceParent']) ? " AND cmlv_ce_parent = {$p['ceParent']} " : ''. |
| " AND cmlv_id_valeur LIKE {$p['idValeur']}". |
| ' ORDER BY '.((!is_null($this->orderby)) ? $this->orderby : 'cmlv_id_valeur ASC').' '; |
| $requete_compte = $requete; |
| $requete .= "LIMIT $this->start,$this->limit "; |
| break; |
| case 'nom' : |
| // Nous avons une abréviation de valeur, nous récupérons toutes les valeurs correspondantes |
| $requete = (($this->distinct) ? 'SELECT DISTINCT' : 'SELECT').' * '. |
| 'FROM coel_meta_liste_valeur '. |
| 'WHERE '; |
| if (isset($p['nom']) && $p['nom'] != "") $requete .= "cmlv_nom LIKE {$p['nom']} AND "; |
| if (isset($p['ceParent'])) $requete .= " cmlv_ce_parent = {$p['ceParent']} AND "; |
| $requete .= " cmlv_id_valeur LIKE {$p['idValeur']} ". |
| 'ORDER BY '.((!is_null($this->orderby)) ? $this->orderby : 'cmlv_id_valeur ASC').' '; |
| $requete_compte = $requete; |
| $requete .= "LIMIT $this->start,$this->limit "; |
| break; |
| default : |
| $this->messages[] = sprintf("Valeur '%s' pour le paramêtre 'type' inconnue (valeurs disponibles : id, ab, abv)!", $p['type']); |
| } |
| if (!is_null($requete)) { |
| // Exécution de la requêtre SQL et test d'éventuelles erreurs |
| try { |
| $resultat = $this->bdd->query($requete)->fetchAll(PDO::FETCH_ASSOC); |
| if ($resultat === false || count($resultat) == 0) { |
| $this->messages[] = "La requête a retourné aucun résultat."; |
| } else { |
| // Traitement des données |
| if ($p['type'] == 'id') { |
| $info['id'] = trim($p['ceParent'], "'"); |
| } else if ($p['type'] == 'identifiant') { |
| $info['id'] = trim($p['idValeur'], "'"); |
| } else { |
| $info['id'] = $resultat[0]['cmlv_ce_parent']; |
| } |
| $info['valeurs'] = $resultat; |
| // gestion des abreviations |
| if (isset($p['abreviation']) && ($p['abreviation'] != "'%'")) { |
| $info['abreviation'] = $p['abreviation']; |
| } |
| // si on a le nombre maximum de resultats on doit charger la page suivante |
| if (count($resultat) == $this->limit) { |
| $info['getNextPage'] = true; |
| } else { |
| $info['getNextPage'] = false; |
| } |
| //Sélection du nombre total |
| if (!is_null($requete_compte)) { |
| $nbElements = $this->bdd->query($requete_compte)->rowCount(); |
| $info['nbElements'] = $nbElements; |
| } |
| } |
| } catch (PDOException $e) { |
| $this->messages[] = sprintf($this->getTxt('sql_erreur'), $e->getFile(), $e->getLine(), $e->getMessage()); |
| } |
| } |
| // Envoie sur la sortie standard |
| $this->envoyer($info); |
| } |
| } |
| ?> |
| /branches/v1.11-okuzgozu/jrest/services/CoelStructure.php |
|---|
| New file |
| 0,0 → 1,409 |
| <?php |
| /** |
| * Service fournissant la liste des structures et leurs informations. |
| * |
| * @author Raphaël Droz <raphael@tela-botanica.org> |
| * @author Jean-Pascal MILCENT <jpm@tela-botanica.org> |
| * @Copyright (c) 2009, 2013 Tela Botanica (accueil@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> |
| */ |
| class CoelStructure extends Coel { |
| static $optional_bool_fields = array( |
| 'cs_nbre_personne', |
| 'csc_mark_formation', 'csc_mark_formation_interet', |
| 'csc_mark_collection_commune', 'csc_mark_acces_controle', 'csc_mark_restauration', 'csc_mark_traitement', |
| 'csc_mark_acquisition_collection', 'csc_mark_acquisition_echantillon', |
| 'csv_mark_action', 'csv_mark_action_future', 'csv_mark_recherche', 'csv_mark_acces_ss_motif', 'csv_mark_visite_avec_motif', |
| 'cs_latitude', 'cs_longitude', |
| ); |
| // ATTENTION : tjrs garder la table principale en premier, puis mettre les tables spécialisées. |
| protected $tables = array( 120 => array( |
| 'nom' => 'coel_structure', |
| 'prefixe' => 'cs', |
| 'id' => array('cs_id_structure')), |
| 122 => array( |
| 'nom' => 'coel_structure_conservation', |
| 'prefixe' => 'csc', |
| 'id' => array('csc_id_structure')), |
| 123 => array( |
| 'nom' => 'coel_structure_valorisation', |
| 'prefixe' => 'csv', |
| 'id' => array('csv_id_structure'))); |
| /** |
| * Méthode principale appelée avec une requête de type GET. |
| */ |
| public function getElement($param = array()) { |
| // Initialisation des variables |
| $info = array(); |
| // Nour recherchons le type de requête demandé |
| $type = $param[0]; |
| if ($type == '*' || is_numeric($type)) { |
| // Pré traitement des paramêtres |
| $p = $this->traiterParametresUrl(array('id_structure', 'recherche'), $param); |
| $info = $this->getElementParDefaut($p); |
| } else { |
| $methode = 'getElement'.$type; |
| if (method_exists($this, $methode)) { |
| array_shift($param); |
| $info = $this->$methode($param); |
| } else { |
| $this->messages[] = "Le type d'information demandé '$type' n'est pas disponible."; |
| } |
| } |
| // Envoie sur la sortie standard |
| $this->envoyer($info); |
| } |
| /** |
| * Méthode par défaut pour garder la compatibilité avec Coel. |
| * Appelée avec les paramêtres d'url suivant : |
| * /CoelStructure/_/_/_ |
| * ou les _ représentent dans l'ordre : id_structure et nom |
| * Si un des paramêtres est abscent, il prendre la valeur * |
| */ |
| public function getElementParDefaut($p) { |
| // Initialisation des variables |
| $info = array(); |
| $whereClause = array(); |
| if(isset($p['id_structure'])) $whereClause[] = "cs_id_structure = {$p['id_structure']}"; |
| if(isset($p['recherche'])) { |
| if(@$this->searchCity && trim($this->searchCity) == 'true') { |
| $whereClause[] = "(" . implode(" OR ", array("cs_nom LIKE {$p['recherche']}", "cs_ville LIKE {$p['recherche']}")) . ")"; |
| } else { |
| $whereClause[] = "cs_nom LIKE {$p['recherche']}"; |
| } |
| } |
| // Construction de la requête |
| $requete = sprintf( |
| 'SELECT SQL_CALC_FOUND_ROWS %s cs.*, csc.*, csv.*, cmhl_date_modification, cmhl_notes, cmhl_source, cmhl_ce_modifier_par, cmhl_ce_etat, cmhl_ip ' |
| . ' FROM coel_structure AS cs ' |
| . ' LEFT JOIN coel_meta_historique_ligne ON (cs_ce_meta = cmhl_id_historique_ligne) ' |
| . ' LEFT JOIN coel_structure_conservation AS csc ON (cs_id_structure = csc_id_structure) ' |
| . ' LEFT JOIN coel_structure_valorisation AS csv ON (cs_id_structure = csv_id_structure) ' |
| . ' WHERE %s ORDER BY %s LIMIT %d, %d -- %s:%d', |
| $this->distinct ? 'DISTINCT' : '', |
| $whereClause ? implode(" AND ", $whereClause) : TRUE, |
| is_null($this->orderby) ? 'cs.cs_nom ASC' : $this->orderby, |
| $this->start, $this->limit, |
| __FILE__, __LINE__); |
| // Récupération des résultats |
| try { |
| // SPÉCIAL : |
| // Lorsqu'on cherche une seule structure avec un id passé en paramêtre, nous devons renvoyer un objet |
| $donnees = ($this->formatRetour == 'objet' && isset($p['id_structure'])) ? $this->bdd->query($requete)->fetch(PDO::FETCH_OBJ) : $this->bdd->query($requete)->fetchAll(PDO::FETCH_ASSOC); |
| if ($donnees === false) { |
| $this->messages[] = "La requête a retourné aucun résultat."; |
| } |
| // l'UI java n'aime pas les NULL |
| if(!is_array($donnees)) { |
| // $donnees est un objet PHP |
| array_walk($donnees, create_function('&$val', '$val = is_null($val) ? "" : $val;')); |
| } |
| else { |
| // $donnees est un tableau d'objets PHP |
| foreach($donnees as &$structure) { |
| array_walk($structure, create_function('&$val', '$val = is_null($val) ? "" : $val;')); |
| } |
| } |
| $elements_nbre = $this->bdd->query("SELECT FOUND_ROWS() AS c")->fetch(PDO::FETCH_ASSOC); |
| $info['nbElements'] = intval($elements_nbre['c']); |
| $info['structures'] = $donnees; |
| } catch (PDOException $e) { |
| $this->messages[] = sprintf($this->getTxt('sql_erreur'), $e->getFile(), $e->getLine(), $e->getMessage()); |
| } |
| return $info; |
| } |
| /* Méthode pour récupérer le nombre de structure par zone géographique. |
| * Appelée avec les paramêtres d'url suivant : |
| * /CoelStructure/ParZoneGeo/_ |
| * ou les _ représentent dans l'ordre : type. |
| * ou type peut valoir: FRD (= département français) |
| * Si un des paramêtres est abscent, il prendre la valeur * |
| */ |
| public function getElementParZoneGeo($param) { |
| // Pré traitement des paramêtres |
| $p = $this->traiterParametresUrl(array('type'), $param); |
| if (!isset($p['type'])) { |
| $this->messages[] = "Il est obligatoire d'indiquer type de recherche pour utiliser ce service."; |
| return array(); |
| } |
| // Construction de la requête |
| $requete = (($this->distinct) ? 'SELECT DISTINCT' : 'SELECT').' '. |
| ' IF ( SUBSTRING( cs_code_postal FROM 1 FOR 2 ) >= 96, '. |
| ' SUBSTRING( cs_code_postal FROM 1 FOR 3 ), '. |
| ' SUBSTRING( cs_code_postal FROM 1 FOR 2 ) ) AS id, '. |
| ' COUNT( cs_id_structure ) AS nbre '. |
| 'FROM coel_structure '. |
| 'WHERE cs_ce_truk_pays = 2654 '. |
| 'GROUP BY IF ( SUBSTRING( cs_code_postal FROM 1 FOR 2 ) >= 96, '. |
| ' SUBSTRING( cs_code_postal FROM 1 FOR 3 ), '. |
| ' SUBSTRING( cs_code_postal FROM 1 FOR 2 ) ) '. |
| 'ORDER BY '.((!is_null($this->orderby)) ? $this->orderby : 'id ASC').' '; |
| // Récupération des résultats |
| try { |
| $donnees = $this->bdd->query($requete)->fetchAll(PDO::FETCH_ASSOC); |
| } catch (PDOException $e) { |
| $this->messages[] = sprintf($this->getTxt('sql_erreur'), $e->getFile(), $e->getLine(), $e->getMessage()); |
| } |
| if ($donnees === false) { |
| $this->messages[] = "La requête a retourné aucun résultat."; |
| return array(); |
| } |
| $info = array(); |
| foreach ($donnees as $donnee) { |
| $info[$donnee['id']] = $donnee['nbre']; |
| } |
| return $info; |
| } |
| static function NULLifNotNum(&$params, $keys_to_null) { |
| foreach($keys_to_null as $v) { |
| if(! array_key_exists($v, $params)) continue; |
| if(!is_numeric($params[$v]) && ! preg_match('/^-?\d+,\d*$/', $params[$v])) { |
| $params[$v] = NULL; |
| } |
| else { |
| $params[$v] = str_replace(',', '.', $params[$v]); |
| } |
| } |
| } |
| /** |
| * Méthode appelée pour ajouter un élément. |
| */ |
| public function createElement($params) { |
| // Identification de l'utilisateur |
| list($id_utilisateur, $id_session) = $this->getIdentification($params); |
| // Contrôle du non détournement de l'utilisateur |
| if (!$this->etreAutorise($id_utilisateur)) { |
| $this->envoyer(); |
| return; |
| } |
| try { |
| $form_needs_refresh = self::callNominatim($params, $this->bdd); |
| self::NULLifNotNum($params, self::$optional_bool_fields); |
| // Vérification des tables à vraiment mettre à jour en fonction des données passées. |
| $tables_a_modifier = $this->recupererTablesAModifier($params); |
| reset($tables_a_modifier); |
| $id_structure = null; |
| while (list($table_id, $table) = each($tables_a_modifier)) { |
| if (is_null($table['champs'])) continue; |
| if ($this->avoirCleComplete($table)) { |
| $this->mettreAJourAvecCle($id_utilisateur, $id_session, $table_id, $table); |
| continue; |
| } |
| // Ajout des données à la table des données |
| $id_structure = $this->ajouter($table); |
| if ($id_structure === false) continue; |
| $table['champs_valeurs_id']['cs_id_structure'] = $id_structure; |
| $table['champs_valeurs_brut']['cs_id_structure'] = $id_structure; |
| $tables_a_modifier[122]['champs_valeurs_id']['csc_id_structure'] = $id_structure; |
| $tables_a_modifier[122]['champs_valeurs_brut']['csc_id_structure'] = $id_structure; |
| $tables_a_modifier[122]['champs_valeurs_protege']['csc_id_structure'] = $this->bdd->quote($id_structure); |
| $tables_a_modifier[123]['champs_valeurs_id']['csv_id_structure'] = $id_structure; |
| $tables_a_modifier[123]['champs_valeurs_brut']['csv_id_structure'] = $id_structure; |
| $tables_a_modifier[123]['champs_valeurs_protege']['csv_id_structure'] = $this->bdd->quote($id_structure); |
| // Historisation (Ajout des méta-données) |
| $etat = 1; // Ajout |
| $cle = $this->recupererCle($table); |
| $info = $this->creerXmlHisto($table['champs_valeurs_brut']); |
| $id_meta = $this->historiser($table_id, $cle, $info, $id_utilisateur, $etat, $id_session); |
| // Liaison de la table des données à ses méta-données |
| $champ_meta = "{$table['prefixe']}_ce_meta"; |
| $table['champs_valeurs_protege'] = array($champ_meta => $id_meta); |
| $this->modifier($table); |
| } |
| if(isset($params['cpr_abreviation']) && !empty($params['cpr_abreviation'])) { |
| $this->ajouterGuid($params['cpr_abreviation'], $id_structure); |
| } |
| } catch (PDOException $e) { |
| $this->messages[] = sprintf($this->getTxt('sql_erreur'), $e->getFile(), $e->getLine(), $e->getMessage(), $requete); |
| } |
| if($form_needs_refresh) { // coordonnées mises à jour en DB: en informer le formulaire |
| $this->envoyer($this->getElementParDefaut(array('id_structure' => $id_structure))); |
| exit; |
| } |
| $this->envoyer($id_structure); |
| } |
| /** |
| * Méthode appelée pour mettre à jour un élément |
| */ |
| public function updateElement($uid, $params) { |
| // Vérification de la présence des id passés par l'url |
| if (!isset($uid[0])) { |
| $this->messages[] = "Identifiant de structure manquant. Vous ne devriez pas avoir accès à ce service."; |
| $this->envoyer(); |
| return; |
| } |
| // Identification de l'utilisateur |
| list($id_utilisateur, $id_session) = $this->getIdentification($params); |
| // Contrôle du non détournement de l'utilisateur |
| if (!$this->etreAutorise($id_utilisateur)) { |
| $this->envoyer(); |
| return; |
| } |
| try { |
| $form_needs_refresh = self::callNominatim($params, $this->bdd); |
| self::NULLifNotNum($params, self::$optional_bool_fields); |
| // Vérification des tables à vraiment mettre à jour en fonction des données passées. |
| $tables_a_modifier = $this->recupererTablesAModifier($params); |
| // Pour chaque table du module nous lançons si nécessaire l'historisation puis la mise à jour |
| foreach ($tables_a_modifier as $table_id => $table) { |
| if(@$table['nom'] == 'coel_structure' && !$this->avoirCleComplete($table)) { |
| error_log("tentative d'UPDATE sans contrainte de WHERE, \$table = " . print_r($table, TRUE)); |
| continue; // ne pas mettre à jour sans contrainte de WHERE |
| } |
| $this->mettreAJourAvecCle($id_utilisateur, $id_session, $table_id, $table); |
| } |
| } catch (PDOException $e) { |
| $this->messages[] = sprintf($this->getTxt('sql_erreur'), $e->getFile(), $e->getLine(), $e->getMessage()); |
| } |
| // Envoie sur la sortie standard |
| if($form_needs_refresh) { // coordonnées mises à jour en DB: en informer le formulaire (si resté ouvert) |
| $this->envoyer($this->getElementParDefaut(array('id_structure' => $uid[0]))); |
| exit; |
| } |
| $this->envoyer(); // OK par défaut |
| } |
| /** |
| * Méthode appelée pour supprimer un élément |
| */ |
| public function deleteElement($uid) { |
| // NOTES : une structure ne peut pas être supprimée si elle possède des collections liées. |
| // Vérification de la présence des id passés par l'url |
| if (!isset($uid[0]) || !isset($uid[1])) { |
| $this->messages[] = "Identifiant de structure ou d'utilisateur manquant. Vous ne devriez pas avoir accès à ce service."; |
| $this->envoyer(); |
| return; |
| } |
| // Identification de l'utilisateur |
| list($id_utilisateur, $id_session) = $this->getIdentification($uid[0]); |
| // Contrôle du non détournement de l'utilisateur |
| if (! $this->etreAutorise($id_utilisateur)) { |
| $this->envoyer(); |
| return; |
| } |
| // Récupération des id passés par l'url |
| $identifiants = explode(',', rtrim($uid[1], ',')); |
| if (count($identifiants) == 0) { |
| $this->messages[] = "Aucun enregistrement n'a été supprimé."; |
| $this->envoyer(); |
| return; |
| } |
| try { |
| foreach ($identifiants as $id_structure) { |
| // Vérification que la structure ne possède pas de collections liées |
| if (self::verifierPresenceCollection($this->bdd, $id_structure)) { |
| $this->messages[] = "La structure '$id_structure' ne peut pas être supprimée car elle possède des collections liées."; |
| continue; |
| } |
| $params = array('cs_id_structure' => $id_structure, 'csc_id_structure' => $id_structure, 'csv_id_structure' => $id_structure); |
| $tables_a_modifier = $this->recupererTablesAModifier($params); |
| foreach ($tables_a_modifier as $table_id => $table) { |
| if (! $this->avoirEnregistrement($table)) continue; |
| if ($this->supprimer($table) === true) { |
| // Historisation (Ajout des méta-données) |
| $cle = $this->recupererCle($table); |
| $this->historiser($table_id, $cle, 'NULL', $id_utilisateur, 3, $id_session); |
| } |
| } |
| } |
| } catch (PDOException $e) { |
| $this->messages[] = sprintf($this->getTxt('sql_erreur'), $e->getFile(), $e->getLine(), $e->getMessage(), $requete); |
| } |
| // Envoie sur la sortie standard |
| $this->envoyer(); |
| } |
| static function verifierPresenceCollection($db, $id_structure) { |
| // Vérification que la structure ne possède pas de collections liées |
| return ($db->query(sprintf( |
| 'SELECT COUNT(cc_id_collection) AS nbre_collection FROM coel_collection ' . |
| ' WHERE cc_ce_structure = %d GROUP BY cc_ce_structure ', |
| $id_structure))->fetchColumn() != 0); |
| } |
| static function callNominatim(&$params, $db = NULL) { |
| // lon/lat déjà saisies ? |
| if (@$params['cs_latitude'] && @$params['cs_longitude']) return FALSE; |
| // ni adresse, ni CP, ni ville ? rien n'est possible |
| if (!@$params['cs_adresse_01'] && !@$params['cs_code_postal'] && !@$params['cs_ville']) return FALSE; |
| $lonlat = array(); |
| if(Coel::coordGuess(Coel::addrReStruct($params, $db), $lonlat)) { |
| $params['cs_latitude'] = $lonlat['lat']; |
| $params['cs_longitude'] = $lonlat['lon']; |
| return TRUE; |
| } |
| // second guess, sans code postal |
| if(@$params['cs_code_postal']) { |
| $params2 = $params; |
| unset($params2['cs_code_postal']); |
| if(Coel::coordGuess(Coel::addrReStruct($params2, $db), $lonlat)) { |
| $params['cs_latitude'] = $lonlat['lat']; |
| $params['cs_longitude'] = $lonlat['lon']; |
| return TRUE; |
| } |
| } |
| return FALSE; |
| } |
| private function ajouterGuid($id_structure) { |
| if ($id_structure !== false) { |
| $table_guid = $this->tables[120]; |
| $table_guid['champs_valeurs_id']['cs_id_structure'] = $id_structure; |
| $table_guid['champs_valeurs_protege']['cs_guid'] = $this->bdd->quote(sprintf($this->config['coel']['guid'], 'str'.$id_structure)); |
| $this->modifier($table_guid); |
| } |
| } |
| } |
| /branches/v1.11-okuzgozu/jrest/services/CoelAide.php |
|---|
| New file |
| 0,0 → 1,135 |
| <?php |
| /** |
| * Service fournissant le contenu d'une page d'aide de l'application COEL. |
| * Encodage en entrée : utf8 |
| * Encodage en sortie : utf8 |
| * |
| * Cas d'utilisation : |
| * /CoelAide/MaPageWikini : retourne le contenu HTML de la page nommée MaPagaWikini dans le wikini d'aide |
| * |
| * @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 $Id$ |
| * @copyright 2009 |
| */ |
| class CoelAide { |
| private $rawAideBaseUrlTpl = null; |
| private $pageAideBaseUrlTpl = null; |
| private $pageAideBaseUrl = null; |
| private $serviceBaseUrl = null; |
| private $sommaire = array(); |
| public function __construct($config) { |
| $this->rawAideBaseUrlTpl = $config['coel']['aideBaseUrlTpl'].'%s/raw_html'; |
| $this->pageAideBaseUrlTpl = $config['coel']['aideBaseUrlTpl'].'%s'; |
| $this->pageAideBaseUrl = $config['coel']['aideBaseUrlTpl']; |
| $this->serviceBaseUrl = $config['coel']['urlBaseJrest'].'CoelAide/'; |
| header('Content-Type: text/html; charset=utf-8'); |
| } |
| /** |
| * Méthode appelée quand on récupère au moins un élément |
| */ |
| public function getElement($param) { |
| $sortie = "Contenu de la page introuvable"; |
| if (isset($param[0])) { |
| $aide_url = sprintf($this->rawAideBaseUrlTpl, $param[0]); |
| $html = file_get_contents($aide_url); |
| // Encodage en UTF-8 |
| $html = mb_convert_encoding($html, 'UTF-8', 'ISO-8859-1'); |
| // Remplacement des URLs |
| $sortie = $this->remplacerUrl($html); |
| } |
| if (isset($param[1])) { |
| if ('sommaire' == $param[1]) { |
| $this->construireSommaireDepuisHtml($html); |
| $sortie = json_encode($this->sommaire); |
| } |
| } |
| // Envoie sur la sortie standard |
| print($sortie); |
| } |
| private function construireSommaireDepuisHtml($html) { |
| $parser = new WdHTMLParser(); |
| $tree = $parser->parse($html); |
| foreach ($tree as $node) { |
| $info = array(); |
| if (!is_array($node)) { |
| $this->sommaire['txt'] = $node; |
| } else { |
| if (isset($node['name'])) { |
| if ($this->estListeHtml($node['name'])) { |
| $this->sommaire[]['liste'] = $this->extraireSommaireDepuisListeHtml($node['children']); |
| } else { |
| $info = $this->extraireCodeEtTxt($node); |
| if (count($info) != 0) { |
| $this->sommaire[] = $info; |
| } |
| } |
| } |
| } |
| } |
| //echo '<pre>' . print_r($this->sommaire, true) . '</pre>'; |
| //echo '<pre>' . print_r($tree, true) . '</pre>'; |
| } |
| private function extraireSommaireDepuisListeHtml($liste) { |
| $sommaire = array(); |
| foreach ($liste as $node) { |
| if (!is_array($node)) { |
| $sommaire['txt'] = $node; |
| } else { |
| if ($this->estListeHtml($node['name'])) { |
| $sommaire['liste'] = $this->extraireSommaireDepuisListeHtml($node['children']); |
| } else if ($node['name'] == 'li') { |
| $sommaire[] = $this->extraireSommaireDepuisListeHtml($node['children']); |
| } else { |
| $sommaire = array_merge($this->extraireCodeEtTxt($node), $sommaire); |
| } |
| } |
| } |
| return $sommaire; |
| } |
| private function estListeHtml($valeur_a_tester) { |
| $est_liste = false; |
| if ($valeur_a_tester == 'ul' || $valeur_a_tester == 'ol') { |
| $est_liste = true; |
| } |
| return $est_liste; |
| } |
| private function extraireCodeEtTxt($node) { |
| $info = array(); |
| if ($node['name'] == 'a') { |
| if (preg_match('/wiki=([a-zA-Z0-9]+)(?:\/|\?|$)/', $node['args']['href'], $match)) { |
| $info['code'] = $match[1]; |
| if ($node['children'][0] != '?') { |
| $info['txt'] = $node['children'][0]; |
| } |
| } |
| } else if ($node['name'] == 'span' && $node['args']['class'] == 'missingpage') { |
| $info['txt'] = $node['children'][0]; |
| } else if (preg_match('/^h[1-6]$/i', $node['name'])) { |
| $info['txt'] = $node['children'][0]; |
| } |
| return $info; |
| } |
| private function remplacerUrl($txt) { |
| // Remplacement des caractères posant problèmes dans les expressions régulières |
| $caracteres = array('.' => '\.', '/' => '\/', '?' => '\?'); |
| $regexp_pageAideBaseUrl = strtr($this->pageAideBaseUrl, $caracteres); |
| // Remplace des urls par celle du service |
| $txt = preg_replace('/'.$regexp_pageAideBaseUrl.'([^"])/', "{$this->serviceBaseUrl}$1", $txt); |
| return $txt; |
| } |
| } |
| ?> |
| /branches/v1.11-okuzgozu/jrest/services/CoelCommentaire.php |
|---|
| New file |
| 0,0 → 1,224 |
| <?php |
| /** |
| * Service fournissant la liste des commentaires et leurs informations. |
| * Encodage en entrée : utf8 |
| * Encodage en sortie : utf8 |
| * |
| * @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 $Id$ |
| * @copyright 2009 |
| */ |
| class CoelCommentaire extends Coel { |
| protected $tables = array(107 => array( 'nom' => 'coel_commentaire', |
| 'prefixe' => 'ccm', |
| 'id' => array('ccm_id_commentaire'))); |
| /** Méthode appelée avec une requête de type GET. |
| */ |
| public function getElement($param = array()) { |
| // Initialisation des variables |
| $info = array(); |
| // Pré traitement des paramêtres |
| $p = $this->traiterParametresUrl(array('id_commentaire', 'recherche'), $param); |
| // Construction de la requête |
| $requete = (($this->distinct) ? 'SELECT DISTINCT' : 'SELECT').' ccm.*, '. |
| ' ccac.*, '. |
| ' cc_id_collection, cc_nom '. |
| 'FROM coel_commentaire AS ccm'. |
| ' LEFT JOIN coel_meta_historique_ligne ON (ccm_ce_meta = cmhl_id_historique_ligne) '. |
| ' LEFT JOIN coel_collection_a_commentaire AS ccac ON (ccm_id_commentaire = ccac_id_commentaire) '. |
| ' LEFT JOIN coel_collection ON (ccac_id_collection = cc_id_collection) '. |
| ((count($p) != 0) ? 'WHERE ' : ''). |
| (isset($p['id_commentaire']) ? "AND ccm_id_commentaire = {$p['id_commentaire']} " : ''). |
| (isset($p['recherche']) ? $this->construireWhereRecherche($p['recherche']) : ''). |
| 'ORDER BY '.((!is_null($this->orderby)) ? $this->orderby : 'ccm_id_commentaire ASC').' '; |
| $requete = str_replace('WHERE AND', 'WHERE', $requete); |
| $requeteCount = $requete; |
| $requete .= "LIMIT $this->start, $this->limit "; |
| // Récupération des résultats |
| try { |
| // SPÉCIAL : |
| // Lorsqu'on cherche une seule structure avec un id passé en paramêtre, nous devons renvoyer un objet |
| $donnees = (isset($p['id_commentaire'])) ? $this->bdd->query($requete)->fetch(PDO::FETCH_OBJ) : $this->bdd->query($requete)->fetchAll(PDO::FETCH_ASSOC); |
| if ($donnees === false) { |
| $this->messages[] = "La requête a retourné aucun résultat."; |
| } |
| $nbElements = $this->bdd->query($requeteCount)->rowCount(); |
| $info['nbElements'] = $nbElements; |
| $info['commentaires'] = $donnees; |
| } catch (PDOException $e) { |
| $this->messages[] = sprintf($this->getTxt('sql_erreur'), $e->getFile(), $e->getLine(), $e->getMessage()); |
| } |
| // Envoie sur la sortie standard |
| $this->envoyer($info); |
| } |
| private function construireWhereRecherche($recherche) { |
| $recherche_public = null; |
| if(strstr(strtolower($recherche),'public')) { |
| $recherche_public = 1; |
| } |
| if(strstr(strtolower($recherche),'prive') || strstr(strtolower($recherche),'privé')) { |
| $recherche_public = 0; |
| } |
| $sous_requete_type = 'SELECT cmlv_id_valeur '. |
| 'FROM coel_meta_liste_valeur '. |
| 'WHERE cmlv_nom LIKE '.$recherche.' '. |
| 'AND cmlv_ce_parent = 1068'; |
| $types = $this->bdd->query($sous_requete_type)->fetchAll(PDO::FETCH_ASSOC); |
| $str_types = ""; |
| foreach($types as $type) { |
| $str_types .= "ccac_truk_type LIKE ".$this->bdd->quote("%".$type['cmlv_id_valeur'].'%')." OR "; |
| } |
| $recherche = "AND ". |
| "(". |
| $str_types. |
| "ccm_titre LIKE {$recherche} OR ". |
| "ccm_ponderation LIKE {$recherche} ". |
| ($recherche_public !== null ? ("OR ccm_mark_public LIKE {$recherche_public} ") : ""). |
| ")"; |
| return $recherche; |
| } |
| /** |
| * Méthode appelée pour ajouter un élément. |
| */ |
| public function createElement($params) { |
| // Identification de l'utilisateur |
| list($id_utilisateur, $id_session) = $this->getIdentification($params); |
| // Contrôle du non détournement de l'utilisateur |
| if ($this->etreAutorise($id_utilisateur)) { |
| try { |
| // Vérification des tables à vraiment mettre à jour en fonction des données passées. |
| $tables_a_modifier = $this->recupererTablesAModifier($params); |
| reset($tables_a_modifier); |
| $id_commentaire = null; |
| while (list($table_id, $table) = each($tables_a_modifier)) { |
| if (!is_null($table['champs'])) { |
| if (!$this->avoirCleComplete($table)) { |
| // Ajout des données à la table des données |
| $id_commentaire = $this->ajouter($table); |
| if ($id_commentaire !== false) { |
| $table['champs_valeurs_id']['ccm_id_commentaire'] = $id_commentaire; |
| $table['champs_valeurs_brut']['ccm_id_commentaire'] = $id_commentaire; |
| // Historisation (Ajout des méta-données) |
| $etat = 1; // Ajout |
| $cle = $this->recupererCle($table); |
| $id_commentaire = $cle; |
| $info = $this->creerXmlHisto($table['champs_valeurs_brut']); |
| $id_meta = $this->historiser($table_id, $cle, $info, $id_utilisateur, $etat, $id_session); |
| // Liaison de la table des données à ses méta-données |
| $champ_meta = "{$table['prefixe']}_ce_meta"; |
| $table['champs_valeurs_protege'] = array($champ_meta => $id_meta); |
| $this->modifier($table); |
| } |
| } else { |
| $this->mettreAJourAvecCle($id_utilisateur, $id_session, $table_id, $table); |
| } |
| } |
| } |
| } catch (PDOException $e) { |
| $this->messages[] = sprintf($this->getTxt('sql_erreur'), $e->getFile(), $e->getLine(), $e->getMessage(), $requete); |
| } |
| } else { |
| $this->messages[] = "Il faut être identifié pour accéder à ce service"; |
| } |
| $this->envoyer((string) $id_commentaire); |
| } |
| /** |
| * Méthode appelée pour mettre à jour un élément |
| */ |
| public function updateElement($uid, $params) { |
| // Vérification de la présence des id passés par l'url |
| $id_commentaire = "0"; |
| if (!isset($uid[0])) { |
| $this->messages[] = "Identifiant de commentaire manquant. Vous ne devriez pas avoir accès à ce service."; |
| } else { |
| // Identification de l'utilisateur |
| list($id_utilisateur, $id_session) = $this->getIdentification($params); |
| // Contrôle du non détournement de l'utilisateur |
| if ($this->etreAutorise($id_utilisateur)) { |
| try { |
| // Vérification des tables à vraiment mettre à jour en fonction des données passées. |
| $tables_a_modifier = $this->recupererTablesAModifier($params); |
| // Pour chaque table du module nous lançons si nécessaire l'historisation puis la mise à jour |
| foreach ($tables_a_modifier as $table_id => $table) { |
| $this->mettreAJourAvecCle($id_utilisateur, $id_session, $table_id, $table); |
| } |
| } catch (PDOException $e) { |
| $this->messages[] = sprintf($this->getTxt('sql_erreur'), $e->getFile(), $e->getLine(), $e->getMessage(), $requete); |
| } |
| $id_commentaire = $params['ccm_id_commentaire'] ; |
| } |
| } |
| // Envoie sur la sortie standard |
| $this->envoyer(); |
| } |
| /** |
| * Méthode appelée pour supprimer un ou plusieurs éléments |
| */ |
| public function deleteElement($uid) { |
| // Vérification de la présence des id passés par l'url |
| if (!isset($uid[0]) || !isset($uid[1])) { |
| $this->messages[] = "Identifiant de commentaire ou d'utilisateur manquant. Vous ne devriez pas avoir accès à ce service."; |
| } else { |
| // Identification de l'utilisateur |
| list($id_utilisateur, $id_session) = $this->getIdentification($uid[0]); |
| // Contrôle du non détournement de l'utilisateur |
| if ($this->etreAutorise($id_utilisateur)) { |
| // Récupération des id passés par l'url |
| $identifiants = explode(',', rtrim($uid[1], ',')); |
| try { |
| if (count($identifiants) == 0) { |
| $this->messages[] = "Aucun enregistrement n'a été supprimé."; |
| } else { |
| foreach ($identifiants as $id_commentaire) { |
| $params = array('ccm_id_commentaire' => $id_commentaire); |
| $tables_a_modifier = $this->recupererTablesAModifier($params); |
| foreach ($tables_a_modifier as $table_id => $table) { |
| if ($this->avoirEnregistrement($table)) { |
| $resultat = $this->supprimer($table); |
| if ($resultat === true) { |
| // Historisation (Ajout des méta-données) |
| $cle = $this->recupererCle($table); |
| $this->historiser($table_id, $cle, 'NULL', $id_utilisateur, Coel::ETAT_SUPPRIMER, $id_session); |
| } |
| } |
| } |
| } |
| } |
| } catch (PDOException $e) { |
| $this->messages[] = sprintf($this->getTxt('sql_erreur'), $e->getFile(), $e->getLine(), $e->getMessage(), $requete); |
| } |
| } |
| } |
| // Envoie sur la sortie standard |
| $this->envoyer(); |
| } |
| } |
| ?> |
| /branches/v1.11-okuzgozu/jrest/services/squelettes/rss1.tpl.xml |
|---|
| New file |
| 0,0 → 1,45 |
| <?php echo '<?xml version="1.0" encoding="UTF-8"?>'."\n";?> |
| <!DOCTYPE rdf:RDF [ |
| <!ENTITY % HTMLlat1 PUBLIC |
| "-//W3C//ENTITIES Latin 1 for XHTML//EN" |
| "http://www.w3.org/TR/xhtml1/DTD/xhtml-lat1.ent"> |
| %HTMLlat1; |
| ]> |
| <rdf:RDF |
| xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" |
| xmlns:dc="http://purl.org/dc/elements/1.1/" |
| xmlns="http://purl.org/rss/1.0/"> |
| <channel rdf:about="<?=$guid?>"> |
| <title><?=$titre?></title> |
| <link><?=$lien_coel?></link> |
| <description><?=$description?></description> |
| <dc:publisher><?=$editeur?></dc:publisher> |
| <dc:date><?=$date_maj_W3C?></dc:date> |
| <?php if (isset($items)) : ?> |
| <items> |
| <rdf:Seq> |
| <?php foreach ($items as $item) : ?> |
| <rdf:li resource="<?=$item['guid']?>" /> |
| <?php endforeach; ?> |
| </rdf:Seq> |
| </items> |
| <?php endif; ?> |
| </channel> |
| <?php if (isset($items)) : ?> |
| <?php foreach ($items as $item) : ?> |
| <item rdf:about="<?=$item['guid']?>"> |
| <title><?=$item['titre']?></title> |
| <link><?=$item['lien']?></link> |
| <description><?=$item['description_encodee']?></description> |
| <dc:date><?=$item['date_maj_W3C']?></dc:date> |
| </item> |
| <?php endforeach; ?> |
| <?php endif; ?> |
| </rdf:RDF> |
| /branches/v1.11-okuzgozu/jrest/services/squelettes/rss2.tpl.xml |
|---|
| New file |
| 0,0 → 1,22 |
| <?php echo '<?xml version="1.0" encoding="UTF-8"?>'."\n";?> |
| <rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"> |
| <channel> |
| <title><?=$titre?></title> |
| <link><?=$lien_coel?></link> |
| <atom:link href="<?=$lien_service?>" rel="self" type="application/rss+xml" /> |
| <description><?=$description?></description> |
| <?php if (isset($items)) : ?> |
| <?php foreach ($items as $item) : ?> |
| <item> |
| <guid><?=$item['guid']?></guid> |
| <title><?=$item['titre']?></title> |
| <link><?=$item['lien']?></link> |
| <description><?=$item['description_encodee']?></description> |
| <pubDate><?=$item['date_maj_RSS']?></pubDate> |
| </item> |
| <?php endforeach; ?> |
| <?php endif; ?> |
| </channel> |
| </rss> |
| /branches/v1.11-okuzgozu/jrest/services/squelettes/diff.tpl.html |
|---|
| New file |
| 0,0 → 1,36 |
| <table style="border:1px solid black;border-collapse:collapse;" summary="Différences entre les données du <?=$date_ancienne?> et du <?=$date_nouvelle?>."> |
| <caption style="text-align:left;font-weight:bold;">Différences</caption> |
| <thead style="border:1px solid black;"> |
| <tr> |
| <th rowspan="2" style="border:1px dotted;">Champ</th> |
| <th rowspan="2" style="border:1px dotted;">Type</th> |
| <th <?=(($etat == 'M') ? 'colspan="2"' : '');?> style="border:1px dotted;">Valeur</th> |
| </tr> |
| <tr> |
| <?php if ($etat == 'M') : ?> |
| <th style="border:1px dotted;">Ancienne (<?=$date_ancienne?>)</th> |
| <?php endif; ?> |
| <th style="border:1px dotted;">Nouvelle (<?=$date_nouvelle?>)</th> |
| </tr> |
| </thead> |
| <tbody> |
| <?php foreach ($differences as $champ => $diff) : ?> |
| <?php if ($diff['type'] == 'A') : |
| $couleur = 'CFC'; |
| elseif ($diff['type'] == 'M') : |
| $couleur = 'FFC'; |
| elseif ($diff['type'] == 'S') : |
| $couleur = 'F99'; |
| endif; ?> |
| <tr style="background-color:#<?=$couleur?>;"> |
| <td style="border:1px dotted;"><?=$champ?></td> |
| <td style="text-align:center;border:1px dotted;"><?=$diff['type_txt']?></td> |
| <?php if ($etat == 'M') : ?> |
| <td style="border:1px dotted;"><?=$diff['ancien']?></td> |
| <?php endif; ?> |
| <td style="border:1px dotted;"><?=$diff['nouveau']?></td> |
| </tr> |
| <?php endforeach; ?> |
| </tbody> |
| </table> |
| /branches/v1.11-okuzgozu/jrest/services/squelettes/export_collection_expertise.tpl.csv |
|---|
| New file |
| 0,0 → 1,4 |
| "<?=implode('","', $champs)?>" |
| <?php foreach ($collections as $collection) : ?> |
| "<?=implode('","', $collection)?>" |
| <?php endforeach; ?> |
| /branches/v1.11-okuzgozu/jrest/services/squelettes/atom.tpl.xml |
|---|
| New file |
| 0,0 → 1,33 |
| <?php echo '<?xml version="1.0" encoding="UTF-8"?>'."\n";?> |
| <feed xmlns="http://www.w3.org/2005/Atom"> |
| <title><?=$titre?></title> |
| <link href="<?=$lien_coel?>" rel="alternate" type="text/html" hreflang="fr" /> |
| <link href="<?=$lien_service?>" rel="self" type="application/atom+xml"/> |
| <updated><?=$date_maj_ATOM?></updated> |
| <author> |
| <name><?=$editeur?></name> |
| </author> |
| <id><?=$guid?></id> |
| <rights>Copyright (c) <?=$annee_courante?>, <?=$editeur?></rights> |
| <generator uri="<?=$lien_coel?>" version="<?=$generateur_version?>"><?=$generateur?></generator> |
| <?php if (isset($items)) : ?> |
| <?php foreach ($items as $item) : ?> |
| <entry> |
| <id><?=$item['lien']?></id> |
| <title><?=$item['titre']?></title> |
| <link href="<?=$item['lien']?>"/> |
| <updated><?=$item['date_maj_ATOM']?></updated> |
| <author><name><?=$item['modifier_par']?></name></author> |
| <content type="xhtml" xml:lang="fr"> |
| <div xmlns="http://www.w3.org/1999/xhtml"> |
| <?=$item['description'];?> |
| </div> |
| </content> |
| </entry> |
| <?php endforeach; ?> |
| <?php endif; ?> |
| </feed> |
| /branches/v1.11-okuzgozu/jrest/services/squelettes/export_structure_expertise.tpl.csv |
|---|
| New file |
| 0,0 → 1,4 |
| "id","nom","description","adresse","code_postal","ville","telephone","courriel","url","type","stockage_parametres","stockage_parametres_nbre","collection_nbre" |
| <?php foreach ($structures as $id => $structure) : ?> |
| "<?=$id?>","<?=$structure['nom']?>","<?=$structure['description']?>","<?=$structure['adresse']?>","<?=$structure['code_postal']?>","<?=$structure['ville']?>","<?=$structure['telephone']?>","<?=$structure['courriel']?>","<?=$structure['url']?>","<?=$structure['type']?>","<?=$structure['stockage_params']?>","<?=$structure['stockage_params_nbre']?>","<?=$structure['collection_nbre']?>" |
| <?php endforeach; ?> |
| /branches/v1.11-okuzgozu/jrest/services/CoelCollectionAPersonne.php |
|---|
| New file |
| 0,0 → 1,189 |
| <?php |
| /** |
| * Service fournissant la liste des relations "structure à personne". |
| * Encodage en entrée : utf8 |
| * Encodage en sortie : utf8 |
| * |
| * @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 $Id$ |
| * @copyright 2009 |
| */ |
| class CoelCollectionAPersonne extends Coel { |
| /** Contient les infos sur les tables gérées par ce service. |
| * Bien respecter l'ordre avec en premier les tables liées et en dernier la table établissant la relation. */ |
| protected $tables = array( 103 => array( 'nom' => 'coel_collection_a_personne', |
| 'prefixe' => 'ccap', |
| 'id' => array('ccap_id_collection', 'ccap_id_personne', 'ccap_id_role'))); |
| /** |
| * Méthode appelée avec une requête de type GET. |
| */ |
| public function getElement($param = array()) { |
| // Initialisation des variables |
| $info = array(); |
| // Pré traitement des paramêtres |
| $p = $this->traiterParametresUrl(array('id_collection', 'id_role', 'id_personne'), $param); |
| // Construction de la requête |
| $requete = (($this->distinct) ? 'SELECT DISTINCT ' : 'SELECT '). |
| ' ccap.*, '. |
| (isset($p['id_personne']) ? ' cc_nom, ' : ''). |
| ' cp_fmt_nom_complet, cp_prenom, cp_nom, cp_naissance_date, cp_naissance_lieu, cp_ce_deces, cp_deces_date, cp_deces_lieu '. |
| 'FROM coel_collection_a_personne AS ccap '. |
| ' LEFT JOIN coel_meta_historique_ligne ON (ccap_ce_meta = cmhl_id_historique_ligne) '. |
| ' LEFT JOIN coel_personne ON (ccap_id_personne = cp_id_personne) '. |
| (isset($p['id_personne']) ? ' LEFT JOIN coel_collection ON (ccap_id_collection = cc_id_collection) ' : ''). |
| ((count($p) != 0) ? 'WHERE ' : ''). |
| (isset($p['id_collection']) ? "AND ccap_id_collection = {$p['id_collection']} " : ''). |
| (isset($p['id_role']) ? "AND ccap_id_role = {$p['id_role']} " : ''). |
| (isset($p['id_personne']) ? "AND ccap_id_personne = {$p['id_personne']} " : ''). |
| 'ORDER BY '.((!is_null($this->orderby)) ? $this->orderby : 'ccap_ce_meta DESC').' '; |
| $requete = str_replace('WHERE AND', 'WHERE', $requete); |
| $requeteCount = $requete; |
| $requete .= "LIMIT $this->start, $this->limit "; |
| // Récupération des résultats |
| try { |
| $nbElements = 0; |
| $donnees = $this->bdd->query($requete)->fetchAll(PDO::FETCH_ASSOC); |
| if ($donnees === false) { |
| $this->messages[] = "La requête a retourné aucun résultat."; |
| } else { |
| $nbElements = $this->bdd->query($requeteCount)->rowCount(); |
| } |
| $info['nbElements'] = $nbElements; |
| $info['collectionsAPersonne'] = $donnees; |
| } catch (PDOException $e) { |
| $this->messages[] = sprintf($this->getTxt('sql_erreur'), $e->getFile(), $e->getLine(), $e->getMessage()); |
| } |
| // Envoie sur la sortie standard |
| $this->envoyer($info); |
| } |
| /** |
| * Méthode appelée pour ajouter un élément. |
| */ |
| public function createElement($params) { |
| // Identification de l'utilisateur |
| list($id_utilisateur, $id_session) = $this->getIdentification($params); |
| // Contrôle du non détournement de l'utilisateur |
| if ($this->etreAutorise($id_utilisateur)) { |
| // Vérification des tables à vraiment mettre à jour en fonction des données passées. |
| $tables_a_modifier = $this->recupererTablesAModifier($params); |
| try { |
| // Pour chaque table du module nous lançons si nécessaire l'historisation puis la mise à jour |
| // Nous ne pouvons pas utiliser foreach car il travaille sur une copie du tableau or nous le modifions dynamiquement dans la boucle |
| reset($tables_a_modifier); |
| while (list($table_id, $table) = each($tables_a_modifier)) { |
| if (!is_null($table['champs'])) { |
| if (!$this->avoirCleComplete($table)) { |
| $this->messages[] = 'Il est nécessaire de fournir toutes les clés à ce service.'; |
| } else { |
| $this->mettreAJourAvecCle($id_utilisateur, $id_session, $table_id, $table); |
| } |
| } |
| } |
| } catch (PDOException $e) { |
| $this->messages[] = sprintf($this->getTxt('sql_erreur'), $e->getFile(), $e->getLine(), $e->getMessage()); |
| } |
| } |
| // Envoie sur la sortie standard |
| $this->envoyer(); |
| } |
| /** |
| * Méthode appelée pour mettre à jour un élément |
| */ |
| public function updateElement($uid, $params) { |
| // Vérification de la présence des id passés par l'url |
| if (!isset($uid[0]) && !isset($uid[1]) && !isset($uid[2])) { |
| $this->messages[] = 'Aucun identifiant de collection, personne et role a été passé. Vous ne devriez pas avoir accès à ce service.'; |
| } else { |
| // Identification de l'utilisateur |
| list($id_utilisateur, $id_session) = $this->getIdentification($params); |
| // Contrôle du non détournement de l'utilisateur |
| if ($this->etreAutorise($id_utilisateur)) { |
| // Vérification des tables à vraiment mettre à jour en fonction des données passées. |
| $tables_a_modifier = $this->recupererTablesAModifier($params); |
| try { |
| // Pour chaque table du module nous lançons si nécessaire l'historisation puis la mise à jour |
| foreach ($tables_a_modifier as $table_id => $table) { |
| $this->mettreAJourAvecCle($id_utilisateur, $id_session, $table_id, $table); |
| } |
| } catch (PDOException $e) { |
| $this->messages[] = sprintf($this->getTxt('sql_erreur'), $e->getFile(), $e->getLine(), $e->getMessage(), $requete); |
| } |
| } |
| } |
| // Envoie sur la sortie standard |
| $this->envoyer(); |
| } |
| /** |
| * Méthode appelée pour supprimer un ou plusieurs éléments |
| */ |
| public function deleteElement($uid) { |
| // NOTES : la suppression ne supprime pas les personnes mais seulements les relations |
| // Vérification de la présence des id passés par l'url |
| if (!isset($uid[0]) || !isset($uid[1])) { |
| $this->messages[] = "Identifiant de relations ou d'utilisateur manquant. Vous ne devriez pas avoir accès à ce service."; |
| } else { |
| // Identification de l'utilisateur |
| list($id_utilisateur, $id_session) = $this->getIdentification($uid[0]); |
| // Contrôle du non détournement de l'utilisateur |
| if ($this->etreAutorise($id_utilisateur)) { |
| // Récupération des identifiant à supprimer |
| $identifiants = array(); |
| $identifiants_agreges = explode(',', rtrim($uid[1], ',')); |
| foreach ($identifiants_agreges as $identifiant) { |
| $identifiants[] = explode('-', $identifiant); |
| } |
| if (count($identifiants) == 0) { |
| $this->messages[] = "Aucun enregistrement n'a été supprimé."; |
| } else { |
| try { |
| foreach ($identifiants as $id) { |
| if (count($id) == 1) { // Seulement des id de collection |
| $params = array('ccap_id_collection' => $id[0]); |
| } else if (count($id) == 3) { // Tous les id... |
| $params = array('ccap_id_collection' => $id[0], 'ccap_id_personne' => $id[1], 'ccap_id_role' => $id[2]); |
| } |
| $tables_a_modifier = $this->recupererTablesAModifier($params); |
| $table = $tables_a_modifier[103]; |
| if ($this->avoirEnregistrement($table)) { |
| $resultat = $this->supprimer($table); |
| if ($resultat === true) { |
| // Historisation (Ajout des méta-données) |
| $cle = $this->recupererCle($table); |
| $this->historiser(103, $cle, 'NULL', $id_utilisateur, Coel::ETAT_SUPPRIMER, $id_session); |
| } |
| } |
| } |
| } catch (PDOException $e) { |
| $this->messages[] = sprintf($this->getTxt('sql_erreur'), $e->getFile(), $e->getLine(), $e->getMessage(), $requete); |
| } |
| } |
| } |
| } |
| // Envoie sur la sortie standard |
| $this->envoyer(); |
| } |
| } |
| ?> |
| /branches/v1.11-okuzgozu/jrest/services/CoelCorrection.php |
|---|
| New file |
| 0,0 → 1,115 |
| <?php |
| /** |
| * Service fournissant la liste des commentaires et leurs informations. |
| * Encodage en entrée : utf8 |
| * Encodage en sortie : utf8 |
| * |
| * @author Cyprien CLERC <cyprien@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 $Id$ |
| * @copyright 2009 |
| */ |
| class CoelCorrection extends Coel { |
| public function getElement($params = array()) { |
| // Identification de l'utilisateur |
| $login = $this->config['coel']['correctionLogin']; |
| $mdp = $this->config['coel']['correctionMdp']; |
| // Récupération des paramètres d'identification |
| $loginParam = $params[0]; |
| $mdpParam = $params[1]; |
| // Contrôle du non détournement de l'utilisateur |
| if ($login == $loginParam && $mdp == $mdpParam) { |
| $numeroCorrection = $params[2]; |
| switch($numeroCorrection) { |
| case 1 : $this->correction0001($numeroCorrection); |
| break; |
| default : $this->noCorrection(); |
| } |
| } else { |
| $this->messages[] = "[ERREUR] Il faut etre identifie pour acceder a ce service"; |
| } |
| } |
| public function noCorrection() { |
| $this->messages[] = "[ERREUR] Aucun numero de correction n'a ete fourni ou le numero fourni est invalide."; |
| } |
| /*-------------------------------------------------------------------*/ |
| //-----------// |
| // Correctif // |
| //-----------// |
| /* Le champ 'pays' de la table 'personne' contient le nom de la liste au lieu de son id, il faut remédier à ça ! */ |
| private function correction0001($numeroCorrection) { |
| $this->messages[] = "APPLICATION DE LA CORRECTION numero ".$numeroCorrection; |
| // recuperation des pays |
| $requete = ' |
| SELECT cmlv_id_valeur, cmlv_nom FROM coel_meta_liste_valeur |
| WHERE cmlv_ce_parent=1074 |
| '; |
| $pays = $this->bdd->query($requete)->fetchAll(PDO::FETCH_ASSOC); |
| $requete = ' |
| SELECT cp_id_personne, cp_truk_recolte |
| FROM coel_personne |
| '; |
| $resultat = $this->bdd->query($requete)->fetchAll(PDO::FETCH_ASSOC); |
| for($i=0; $i<count($resultat); $i++) { |
| if ($resultat[$i]['cp_truk_recolte'] != "") { |
| $tabValeurs = explode(";", $resultat[$i]['cp_truk_recolte']); |
| $nouvelleValeurChamp = ""; |
| for($j=0; $j<count($tabValeurs); $j++) { |
| $tabType = explode("##", $tabValeurs[$j]); |
| $type = trim($tabType[0]); |
| if ($type != "" && !is_numeric($type)) { |
| // recherche de l'id_valeur |
| $trouve = false; |
| $k=0; |
| while(!$trouve && $k<count($pays)) { |
| if ($pays[$k]['cmlv_nom'] == $tabType[0]) { |
| $trouve = true; |
| } |
| else $k++; |
| } |
| $id_valeur = $pays[$k]['cmlv_id_valeur']; |
| if ($trouve) $nouvelleValeurChamp .= str_replace($type, $id_valeur, $tabValeurs[$j]).";"; |
| } |
| } |
| $requeteUpdate = " |
| UPDATE coel_personne |
| SET cp_truk_recolte = '".$nouvelleValeurChamp."' |
| WHERE cp_id_personne = '".$resultat[$i]['cp_id_personne']."' |
| "; |
| if ($nouvelleValeurChamp != "") { |
| echo $requeteUpdate.";<br>"; |
| $resultatRequeteUpdate = $this->bdd->query($requeteUpdate); |
| if($resultatRequeteUpdate) $this->messages[] = "Correction effectuee.<br>"; |
| else $this->messages[] = "Echec lors de la correction."; |
| } |
| } |
| } |
| return true; |
| } |
| } |
| /branches/v1.11-okuzgozu/jrest/services/CoelPublication.php |
|---|
| New file |
| 0,0 → 1,254 |
| <?php |
| /** |
| * Service fournissant la liste des structures et leurs informations. |
| * Encodage en entrée : utf8 |
| * Encodage en sortie : utf8 |
| * |
| * @author Aurélien Peronnet <aurelien@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 $Id$ |
| * @copyright 2009 |
| */ |
| class CoelPublication extends Coel { |
| protected $tables = array(118 => array('nom' => 'coel_publication', |
| 'prefixe' => 'cpu', |
| 'id' => array('cpu_id_publication'))); |
| /** Méthode appelée avec une requête de type GET. |
| */ |
| public function getElement($param = array()) { |
| // Initialisation des variables |
| $info = array(); |
| // Pré traitement des paramêtres |
| $p = $this->traiterParametresUrl(array('id_publication', 'recherche'), $param); |
| // Construction de la requête |
| $requete = (($this->distinct) ? 'SELECT DISTINCT' : 'SELECT').' cp.*, cmhl.*, cs_nom '. |
| 'FROM coel_publication AS cp '. |
| ' LEFT JOIN coel_meta_historique_ligne AS cmhl ON (cpu_ce_meta = cmhl_id_historique_ligne) '. |
| ' LEFT JOIN coel_structure ON (cpu_ce_truk_editeur = cs_id_structure) '. |
| ((count($p) != 0) ? 'WHERE ' : ''). |
| (isset($p['id_publication']) ? "AND cpu_id_publication = {$p['id_publication']} " : ''). |
| (isset($p['recherche']) ? $this->construireWhereRecherche($p['recherche']) : ''). |
| 'ORDER BY '.((!is_null($this->orderby)) ? $this->orderby : 'cpu_id_publication ASC').' '; |
| $requete = str_replace('WHERE AND', 'WHERE', $requete); |
| $requeteCount = $requete; |
| $requete .= "LIMIT $this->start, $this->limit "; |
| // Récupération des résultats |
| try { |
| // SPÉCIAL : |
| // Lorsqu'on cherche une seule publication avec un id passé en paramêtre, nous devons renvoyer un objet |
| $donnees = (isset($p['id_publication'])) ? $this->bdd->query($requete)->fetch(PDO::FETCH_OBJ) : $this->bdd->query($requete)->fetchAll(PDO::FETCH_ASSOC); |
| if ($donnees === false) { |
| $this->messages[] = "La requête a retourné aucun résultat."; |
| } |
| $nbElements = $this->bdd->query($requeteCount)->rowCount(); |
| $info['nbElements'] = $nbElements; |
| $info['publications'] = $donnees; |
| } catch (PDOException $e) { |
| $this->messages[] = sprintf($this->getTxt('sql_erreur'), $e->getFile(), $e->getLine(), $e->getMessage()); |
| } |
| // Envoie sur la sortie standard |
| $this->envoyer($info); |
| } |
| private function construireWhereRecherche($recherche) { |
| $recherche = "AND ". |
| "(". |
| "cpu_fmt_nom_complet LIKE {$recherche} OR ". |
| "cpu_date_parution LIKE {$recherche} OR ". |
| "cpu_fascicule LIKE {$recherche} OR ". |
| "cpu_truk_pages LIKE {$recherche} ". |
| ")"; |
| return $recherche; |
| } |
| /** |
| * Méthode appelée pour ajouter un élément. |
| */ |
| public function createElement($params) { |
| // Identification de l'utilisateur |
| list($id_utilisateur, $id_session) = $this->getIdentification($params); |
| // Contrôle du non détournement de l'utilisateur |
| if ($this->etreAutorise($id_utilisateur)) { |
| try { |
| // Vérification des tables à vraiment mettre à jour en fonction des données passées. |
| $tables_a_modifier = $this->recupererTablesAModifier($params); |
| reset($tables_a_modifier); |
| $id_publication = null; |
| while (list($table_id, $table) = each($tables_a_modifier)) { |
| if (!is_null($table['champs'])) { |
| if (!$this->avoirCleComplete($table)) { |
| // Ajout des données à la table des données |
| $id_publication = $this->ajouter($table); |
| if ($id_publication !== false) { |
| $table['champs_valeurs_id']['cpu_id_publication'] = $id_publication; |
| $table['champs_valeurs_brut']['cpu_id_publication'] = $id_publication; |
| // Historisation (Ajout des méta-données) |
| $etat = 1; // Ajout |
| $cle = $this->recupererCle($table); |
| $id_publication = $cle; |
| $info = $this->creerXmlHisto($table['champs_valeurs_brut']); |
| $id_meta = $this->historiser($table_id, $cle, $info, $id_utilisateur, $etat, $id_session); |
| // Liaison de la table des données à ses méta-données |
| $champ_meta = "{$table['prefixe']}_ce_meta"; |
| $table['champs_valeurs_protege'] = array($champ_meta => $id_meta); |
| $this->modifier($table); |
| } |
| } else { |
| $this->mettreAJourAvecCle($id_utilisateur, $id_session, $table_id, $table); |
| } |
| } |
| } |
| } catch (PDOException $e) { |
| $this->messages[] = sprintf($this->getTxt('sql_erreur'), $e->getFile(), $e->getLine(), $e->getMessage(), $requete); |
| } |
| } else { |
| $this->messages[] = "Il faut être identifié pour accéder à ce service"; |
| } |
| $this->envoyer((string) $id_publication); |
| } |
| /** |
| * Méthode appelée pour mettre à jour un élément |
| */ |
| public function updateElement($uid, $params) { |
| // Vérification de la présence des id passés par l'url |
| $id_publication = "0"; |
| if (!isset($uid[0])) { |
| $this->messages[] = "Identifiant de publication manquant. Vous ne devriez pas avoir accès à ce service."; |
| } else { |
| // Identification de l'utilisateur |
| list($id_utilisateur, $id_session) = $this->getIdentification($params); |
| // Contrôle du non détournement de l'utilisateur |
| if ($this->etreAutorise($id_utilisateur)) { |
| try { |
| // Vérification des tables à vraiment mettre à jour en fonction des données passées. |
| $tables_a_modifier = $this->recupererTablesAModifier($params); |
| // Pour chaque table du module nous lançons si nécessaire l'historisation puis la mise à jour |
| foreach ($tables_a_modifier as $table_id => $table) { |
| $this->mettreAJourAvecCle($id_utilisateur, $id_session, $table_id, $table); |
| } |
| } catch (PDOException $e) { |
| $this->messages[] = sprintf($this->getTxt('sql_erreur'), $e->getFile(), $e->getLine(), $e->getMessage(), $requete); |
| } |
| $id_publication = $params['cpu_id_publication'] ; |
| } |
| } |
| // Envoie sur la sortie standard |
| $this->envoyer(); |
| } |
| /** |
| * Méthode appelée pour supprimer un élément |
| */ |
| public function deleteElement($params_url) { |
| // Vérification de la présence des id passés par l'url |
| if (!isset($params_url[0]) || !isset($params_url[1])) { |
| $this->messages[] = "Identifiant de publication ou d'utilisateur manquant. Vous ne devriez pas avoir accès à ce service."; |
| } else { |
| // Identification de l'utilisateur |
| list($id_utilisateur, $id_session) = $this->getIdentification($params_url[0]); |
| // Contrôle du non détournement de l'utilisateur |
| if ($this->etreAutorise($id_utilisateur)) { |
| // Récupération des id passés par l'url |
| $identifiants = explode(',', rtrim($params_url[1], ',')); |
| try { |
| if (count($identifiants) == 0) { |
| $this->messages[] = "Aucun enregistrement n'a été supprimé."; |
| } else { |
| foreach ($identifiants as $id_publication) { |
| // Vérification de la liaison avec d'autres données et génération des messages d'erreur |
| $params = array('cpu_id_publication' => $id_publication); |
| $tables_a_modifier = $this->recupererTablesAModifier($params); |
| foreach ($tables_a_modifier as $table_id => $table) { |
| if ($this->avoirEnregistrement($table)) { |
| $resultat = $this->supprimer($table); |
| if ($resultat === true) { |
| // Historisation (Ajout des méta-données) |
| $cle = $this->recupererCle($table); |
| $this->historiser($table_id, $cle, 'NULL', $id_utilisateur, 3, $id_session); |
| } |
| } |
| } |
| $this->supprimerAssociationsAPersonne($id_publication); |
| $this->supprimerAssociationsACollection($id_publication); |
| } |
| } |
| } catch (PDOException $e) { |
| $this->messages[] = sprintf($this->getTxt('sql_erreur'), $e->getFile(), $e->getLine(), $e->getMessage(), $requete); |
| } |
| } |
| } |
| // Envoie sur la sortie standard |
| $this->envoyer(); |
| } |
| private function verifierPresencePublication($id_publication) { |
| $presence = false; |
| $id_publication = $this->bdd->quote($id_publication); |
| if ($presence = $this->verifierPresenceDansPersonne($id_publication)) { |
| $this->messages[] = 'Cette publication ne peut être supprimée car elle est au moins liée à une personne'; |
| } else if ($presence = $this->verifierPresenceDansCollection($id_publication)) { |
| $this->messages[] = 'Cette publication ne peut être supprimée car elle est au moins liée à une collection'; |
| } |
| return $presence; |
| } |
| private function verifierPresenceDansPersonne($id_publication) { |
| $requete = 'SELECT COUNT(cpuap_id_publication) AS nbre '. |
| 'FROM coel_publication_a_personne '. |
| "WHERE cpuap_id_publication = $id_publication ". |
| ' AND cpuap_id_role != 2360 '.// Auteur |
| 'GROUP BY cpuap_id_publication '; |
| return $this->contenirDonnees($requete); |
| } |
| private function verifierPresenceDansCollection($id_publication) { |
| $requete = 'SELECT COUNT(ccapu_id_publication) AS nbre '. |
| 'FROM coel_collection_a_publication '. |
| "WHERE ccapu_id_publication = $id_publication ". |
| 'GROUP BY ccapu_id_publication '; |
| return $this->contenirDonnees($requete); |
| } |
| private function supprimerAssociationsAPersonne($id_publication) { |
| $requete = 'DELETE FROM coel_publication_a_personne '. |
| "WHERE cpuap_id_publication = $id_publication "; |
| $succes = $this->bdd->exec($requete); |
| if ($succes === false) { |
| $this->messages[] = 'Erreur lors de la suppression de la liaison aux personnes'; |
| } |
| } |
| private function supprimerAssociationsACollection($id_publication) { |
| $requete = 'DELETE FROM coel_collection_a_publication '. |
| "WHERE ccapu_id_publication = $id_publication "; |
| $succes = $this->bdd->exec($requete); |
| if ($succes === false) { |
| $this->messages[] = 'Erreur lors de la suppression de la liaison aux collections'; |
| } |
| } |
| } |
| ?> |
| /branches/v1.11-okuzgozu/jrest/services/CoelImport.php |
|---|
| New file |
| 0,0 → 1,120 |
| <?php |
| /** |
| * Service important des informations concernant COEL au format CSV. |
| * Encodage en entrée : utf8 |
| * Encodage en sortie : utf8 |
| * |
| * @author Aurélien PERONNET <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 $Id$ |
| * @copyright 2014 |
| */ |
| class CoelImport extends Coel { |
| private $chemin_script = null; |
| private $dossier_import_tmp = null; |
| /** |
| * Méthode appelée avec une requête de type GET. |
| */ |
| public function getElement($params = array()) { |
| if(!empty($_SESSION['coel']['import_stat'])) { |
| header('Content-type : application/json'); |
| echo json_encode($_SESSION['coel']['import_stat']); |
| exit; |
| } |
| } |
| /** |
| * Méthode appelée pour ajouter un élément. |
| */ |
| public function createElement($params) { |
| $this->chemin_script = $this->config['coel']['chemin_script_import']; |
| $this->dossier_import_tmp = $this->config['coel']['dossier_import_tmp']; |
| $erreurs = $this->verifierConditionsImport(); |
| if(!empty($erreurs)) { |
| header('Content-type : application/json'); |
| echo json_encode($erreurs); |
| exit; |
| } |
| // Normalement si on arrive ici, c'est que le fichier contient quelque chose |
| $fichier = array_pop($_FILES); |
| $nom_fichier = $fichier['name']; |
| $type = $params['type']; |
| // on peut imaginer d'autres types d'import que les publications |
| switch($type) { |
| case 'publication': |
| $retour = $this->importerPublications($nom_fichier); |
| break; |
| default: |
| $retour = false; |
| } |
| // Suppression du fichier importé |
| unlink($this->dossier_import_tmp.$fichier['name']); |
| $retour_import = array("succes_import" => "1", "erreurs" => array(), "nb_elements_importes" => "0") ; |
| // Les fonctions d'imports produisent le nombre de lignes importées |
| // ou bien une ou des erreurs |
| if(is_numeric($retour)) { |
| $retour_import['nb_elements_importes'] = $retour; |
| } else { |
| $retour_import['succes_import'] = "0"; |
| $retour_import['erreurs'] = $retour; |
| } |
| // Mise en session des résultats d'import |
| // afin de pouvoir appeler le service en lecture pour obtenir les stats |
| $_SESSION['coel']['import_stat'] = $retour_import; |
| header('Content-type : application/json'); |
| echo json_encode($retour_import); |
| exit; |
| } |
| private function verifierConditionsImport() { |
| $erreurs = false; |
| if(empty($_FILES)) { |
| $erreurs[] = "Ce service requiert un fichier à uploader"; |
| } |
| $fichier = reset($_FILES); |
| if($fichier['error'] != UPLOAD_ERR_OK) { |
| $erreurs[] = "Des erreurs sont survenues durant l'upload du fichier"; |
| } |
| if($fichier['size'] == 0) { |
| $erreurs[] = "Le fichier envoyé est vide"; |
| } |
| $deplacement = move_uploaded_file($fichier['tmp_name'], $this->dossier_import_tmp.$fichier['name']); |
| if(!$deplacement) { |
| $erreurs[] = "Erreur du déplacement du fichier sur le serveur"; |
| } |
| return $erreurs; |
| } |
| private function importerPublications($nom_fichier) { |
| $utilisateur = array('id' => '', 'session' => session_id(), 'ip' => $_SERVER['REMOTE_ADDR']); |
| if(!empty($utilisateur_connecte = $this->getUtilisateur())) { |
| $utilisateur['id'] = $utilisateur_connecte['id']; |
| } |
| $retour = false; |
| $script = sprintf($this->chemin_script, $nom_fichier, "'".json_encode($utilisateur)."'"); |
| exec($script, $retour); |
| return array_pop($retour); |
| } |
| } |
| /branches/v1.11-okuzgozu/jrest/services/CoelUtilisateur.php |
|---|
| New file |
| 0,0 → 1,507 |
| <?php |
| /** |
| * Service d'itentification d'un utilisateur. |
| * Modifié pour fonctionner avec le SSO. |
| * |
| * Encodage en entrée : utf8 |
| * Encodage en sortie : utf8 |
| * |
| * Cas d'utilisation : |
| * Le service reçoit un jeton SSO (ou pas) dans le header "Authorization", le fait |
| * vérifier par l'annuaire; s'il est valide, le décode puis retourne le profil utilisateur |
| * associé; sinon retourne un profil anonyme. |
| * |
| * 1: Aucun jeton ou jeton invalide transmis |
| * 1: L'application retourne l'identifiant de session en cours (mode anonyme) |
| * |
| * 2: Jeton valide transmis |
| * 1 : Passe ou reste dans l'état "connecté"; le profil actif est retourné |
| * |
| * En résumé, utilisation des URLs : |
| * /CoelUtilisateur/identite : retour identifiant de session si jamais connecté, sinon retour de l'id (+ login et mot de passe) |
| * |
| * @author Jean-Pascal MILCENT <jpm@tela-botanica.org> |
| * @author David DELON <david.delon@clapas.net> |
| * @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 $Id$ |
| * @copyright 2009 |
| */ |
| class CoelUtilisateur extends Coel { |
| protected $licence_acceptee = false; |
| /** |
| * Point d'entrée GET sans paramètres |
| */ |
| public function getRessource() { |
| // par défaut, mode anonyme |
| $infos = $this->getUtilisateurAnonyme(); |
| // recherche d'un utilisateur identifié en fonction du jeton SSO |
| $infosIdentifie = $this->getUtilisateurSSO(); |
| if ($infosIdentifie != null) { |
| $infos = $infosIdentifie; |
| } |
| // et vlan, passe-moi l'éponge |
| $this->envoyer($infos); |
| } |
| /** |
| * Point d'entrée GET avec paramètres |
| */ |
| public function getElement($ressources) { |
| switch($ressources[0]) { |
| case "setLicence" : |
| $this->setLicence($ressources[1]); |
| break; |
| default: |
| echo "action [" . $ressources[0] . "] inconnue"; |
| } |
| } |
| /** |
| * Renvoie un profil utilisateur CoeL anonyme |
| * (licence vide, id de session, non connecté) |
| */ |
| protected function getUtilisateurAnonyme() { |
| $info = array("", session_id(), false); |
| return $info; |
| } |
| /** |
| * Recherche un jeton SSO dans l'entête HTTP "Authorization", vérifie ce |
| * jeton auprès de l'annuaire et en cas de succès charge les informations |
| * de l'utilisateur associé; si besoin, copie l'utilisateur dans la table |
| * Personnes de CoeL |
| * |
| * @return Array un profil utilisateur ou null |
| */ |
| protected function getUtilisateurSSO() { |
| $utilisateur = null; |
| // lecture du jeton |
| $jeton = $this->lireJetonEntete(); |
| //echo "Jeton : "; var_dump($jeton); |
| if ($jeton != null) { |
| // validation par l'annuaire |
| $valide = $this->verifierJeton($jeton); |
| if ($valide === true) { |
| // décodage du courriel utilisateur depuis le jeton |
| $donneesJeton = $this->decoderJeton($jeton); |
| if ($donneesJeton != null && $donneesJeton["sub"] != "") { |
| // récupération de l'utilisateur |
| $courriel = $donneesJeton["sub"]; |
| // lecture des infos dans l'annuaire (relou mais nécessaire pour la copie dans la table Personnes de CoeL) |
| $infosAnnuaire = $this->obtenirInfosAnnuaire($courriel); |
| $this->setInfosAnnuaire($infosAnnuaire); |
| //echo "Infos Annu: "; var_dump($infosAnnuaire); |
| // lecture de l'utilisateur connu (ou pas) par CoeL (table Personnes) |
| $utilisateur_existant = $this->chargerUtilisateur($courriel); |
| //echo "UTIL EXIST: "; var_dump($utilisateur_existant); |
| // Vérification de la nécessité de mettre à jour l'utilisateur COEL vis à vis de l'annuaire de Tela Botanica |
| if (!is_null($infosAnnuaire) && $this->avoirBesoinMiseAJour($utilisateur_existant)) { |
| $this->debug[] = "Besoin d'une mise à jour"; |
| $presence_dans_coel = ($utilisateur_existant != false); // si on l'a trouvé juste au dessus |
| $this->debug[] = "Presence: $presence_dans_coel"; |
| $mot_de_passe_sha1 = $infosAnnuaire['pass']; |
| //echo "MDP: " .$mot_de_passe_sha1; |
| if ($presence_dans_coel) { |
| // Nécessite de faire une mise à jour |
| $this->debug[] = "Mise à jour de l'utilisateur {$infosAnnuaire['id']}"; |
| $this->mettreAJourUtilisateur($courriel, $mot_de_passe_sha1, $infosAnnuaire); |
| // ci-dessous : ne pas caster en int car GWT attend une String (le con !) |
| $utilisateur_existant['licence'] = $this->recupererLicenceUtilisateur($infosAnnuaire['id']); |
| } else { |
| // Nécessite d'ajouter le nouvel utilisateur |
| $this->debug[] = "Ajout d'une nouvel utilisateur"; |
| $this->ajouterUtilisateurACoel($infosAnnuaire, $mot_de_passe_sha1); |
| // rechargement après l'avoir ajouté (un peu nul) |
| $utilisateur_existant = $this->chargerUtilisateur($courriel); |
| } |
| } |
| // stockage de l'utilisateur en session |
| $this->setUtilisateur($utilisateur_existant); |
| // renvoi des infos |
| $utilisateur = array($utilisateur_existant['licence'], $infosAnnuaire['id'], true, $this->getUtilisateurNomComplet(), $this->getUtilisateurPrenom(), $this->getUtilisateurNom(), $this->getParametre()); |
| } |
| } |
| } |
| return $utilisateur; |
| } |
| protected function deconnecterUtilisateur() { |
| $_SESSION['coel_utilisateur'] = ''; |
| $_SESSION['coel_infosAnnuaire'] = ''; |
| } |
| /** |
| * Retourne true si le compte utilisateur a été modifié dans l'annuaire, et que les |
| * modifications ont besoin d'être répercutées dans la table Personnes de Coel |
| */ |
| protected function avoirBesoinMiseAJour($info_annuaire_coel) { |
| $necessite_maj = false; |
| if ($info_annuaire_coel == false) { |
| // Le login et/ou le mot de passe a pu changer |
| $necessite_maj = true; |
| } else { |
| $info_annuaire_distant = $this->getInfosAnnuaire(); |
| if ($this->comparerInfosAnnuairesDistantEtCoel($info_annuaire_distant, $info_annuaire_coel) == false) { |
| $necessite_maj = true; |
| } |
| } |
| return $necessite_maj; |
| } |
| protected function comparerInfosAnnuairesDistantEtCoel($annuaire_distant, $annuaire_coel) { |
| $identique = true; |
| $tableau_annuaire_distant = array('nom' => $annuaire_distant['nom'], |
| 'prenom' => $annuaire_distant['prenom'], |
| 'ville' => $annuaire_distant['ville'], |
| 'code_postal' => $annuaire_distant['code_postal']); |
| $tableau_annuaire_coel = array('nom' => $annuaire_coel['nom'], |
| 'prenom' => $annuaire_coel['prenom'], |
| 'ville' => $annuaire_coel['ville'], |
| 'code_postal' => $annuaire_coel['code_postal']); |
| foreach ($tableau_annuaire_distant as $cle => $valeur) { |
| if ($tableau_annuaire_coel[$cle] != $valeur) { |
| $identique = false; |
| break; |
| } |
| } |
| return $identique; |
| } |
| /** |
| * Vérifie si un utilisateur est présent dans la table Personnes de CoeL |
| */ |
| protected function verifierPresenceUtilisateur($id) { |
| $present = false; |
| $requete = 'SELECT COUNT(cp_id_personne) AS nbre '. |
| 'FROM coel_personne '. |
| "WHERE cp_ce_annuaire = {$this->bdd->quote($id)} ". |
| " AND cp_ce_annuaire = cp_id_personne "; |
| try { |
| $nbre = $this->bdd->query($requete)->fetchColumn(); |
| if (0 == $nbre) { |
| $this->debug[] = "Utilisateur NON présent dans l'annuaire de COEL."; |
| } else if (1 == $nbre) { |
| $this->debug[] = "Utilisateur présent dans l'annuaire de COEL."; |
| $present = true; |
| } else if (false === $nbre) { |
| $this->debug[] = "Erreur dans la requête de vérification de présence dans l'annuaire de COEL."; |
| } |
| } catch (PDOException $e) { |
| $this->messages[] = sprintf($this->getTxt('sql_erreur'), $e->getFile(), $e->getLine(), $e->getMessage()); |
| } |
| return $present; |
| } |
| /** |
| * Renvoie l'état d'acceptation de la licence pour un utilisateur donné : |
| * 0 (non acceptée) ou 1 (acceptée) |
| */ |
| protected function recupererLicenceUtilisateur($id) { |
| $requete = 'SELECT cp_mark_licence '. |
| 'FROM coel_personne '. |
| "WHERE cp_ce_annuaire = {$this->bdd->quote($id)} ". |
| " AND cp_ce_annuaire = cp_id_personne "; |
| try { |
| $licence = $this->bdd->query($requete)->fetchColumn(); |
| if ($licence === false) { |
| $this->debug[] = "La licence n'a pas pu être récupérée."; |
| return 0; |
| } else { |
| return $licence; |
| } |
| } catch (PDOException $e) { |
| $this->messages[] = sprintf($this->getTxt('sql_erreur'), $e->getFile(), $e->getLine(), $e->getMessage()); |
| } |
| } |
| /** |
| * Met à jour les données de l'utilisateur dans la table CoeL Personnes |
| */ |
| protected function mettreAJourUtilisateur($login, $mot_de_passe_sha1, $infos) { |
| try { |
| $cp_fmt_nom_complet = $infos['prenom'].' '.$infos['nom']; |
| $requete = '' |
| . 'UPDATE coel_personne' |
| . " SET cp_id_personne = '{$infos['id']}', " |
| . " cp_fmt_nom_complet = '$cp_fmt_nom_complet', cp_prenom = '{$infos['prenom']}', cp_nom = '{$infos['nom']}', " |
| . " cp_code_postal = '{$infos['code_postal']}', cp_ville = '{$infos['ville']}', cp_truk_courriel = '{$infos['courriel']}', " |
| . " cp_login = '{$infos['courriel']}', cp_mot_de_passe = '$mot_de_passe_sha1', cp_ce_annuaire = '{$infos['id']}' " |
| . " WHERE cp_login = '$login' " |
| //. " AND cp_mot_de_passe = '{$infos['mot_de_passe']}' " // WTF ? |
| ; |
| // Ajout des données |
| $resultat = $this->bdd->exec($requete); |
| if ($resultat === false) { |
| $this->messages[] = "L'utilisateur n'a pas été mis à jour car la requête a échouée."; |
| } |
| } catch (PDOException $e) { |
| $messages[] = sprintf($this->getTxt('sql_erreur'), $e->getFile(), $e->getLine(), $e->getMessage(), $requete); |
| } |
| } |
| /** |
| * Met à jour l'utilisateur d'id $idUtilisateur, et passe son acceptation de |
| * la licence à "1" |
| */ |
| protected function setLicence($idUtilisateur = null) { |
| if ($idUtilisateur == null) { |
| $messages[] = "Id utilisateur null"; |
| $this->envoyer(); |
| exit; |
| } |
| // Mise à jour de l'utilisateur |
| try { |
| $requete = 'UPDATE coel_personne '. |
| "SET cp_mark_licence = 1 ". |
| "WHERE cp_ce_annuaire = '$idUtilisateur' "; |
| // Ajout des données |
| $resultat = $this->bdd->exec($requete); |
| if ($resultat === false) { |
| $this->messages[] = "L'utilisateur n'a pas été mis à jour car la requête a échouée."; |
| } else { |
| // Confirmation attendue par l'interface |
| $this->envoyer(array("1")); |
| exit; |
| } |
| } catch (PDOException $e) { |
| $messages[] = sprintf($this->getTxt('sql_erreur'), $e->getFile(), $e->getLine(), $e->getMessage(), $requete); |
| $this->envoyer(); |
| } |
| } |
| /** |
| * Ajoute une copie de l'utilisateur dans la table CoeL Personnes |
| */ |
| protected function ajouterUtilisateurACoel($infos, $mot_de_passe_sha1) { |
| try { |
| // Construction de la requête d'ajout |
| // Notes : pour rester compatibles avec l'annuaire de Tela, les utilisateurs sont ajoutés directement avec l'id |
| // de l'annuaire Tela. Dans CoelPersonne, les personnes qui ne sont pas utilisateur sont ajoutés avec un id supérieur à 100 000 |
| $cp_fmt_nom_complet = $infos['prenom'].' '.$infos['nom']; |
| $cp_mark_licence = '0'; |
| // si un utilisateur a changé son email dans un compte TB existant, une ligne avec son ID existera déjà et /i |
| // => on fait un REPLACE (attention à la compatibilité !) |
| $requete = 'REPLACE INTO coel_personne '. |
| ' (cp_id_personne, cp_fmt_nom_complet, cp_prenom, cp_nom, cp_code_postal, '. |
| ' cp_ville, cp_truk_courriel, cp_login, cp_mot_de_passe, cp_ce_annuaire, cp_mark_licence) '. |
| "VALUES ('{$infos['id']}', '$cp_fmt_nom_complet', '{$infos['prenom']}', '{$infos['nom']}', ". |
| "'{$infos['code_postal']}', '{$infos['ville']}', '{$infos['courriel']}', '{$infos['courriel']}', '".$mot_de_passe_sha1."', ". |
| "'{$infos['id']}', $cp_mark_licence) "; |
| //$this->debug[] = $requete; |
| // Ajout des données |
| $resultat = $this->bdd->exec($requete); |
| if ($resultat === false) { |
| $this->debug[] = "Utilisateur NON ajouté dans coel_personne car la requête a échouée."; |
| } else { |
| $this->debug[] = "Utilisateur ajouté à coel_personne."; |
| } |
| } catch (PDOException $e) { |
| //$this->debug[] = "EREEUR SQL: " . sprintf($this->getTxt('sql_erreur'), $e->getFile(), $e->getLine(), $e->getMessage(), $requete); |
| $messages[] = sprintf($this->getTxt('sql_erreur'), $e->getFile(), $e->getLine(), $e->getMessage(), $requete); |
| } |
| } |
| /** |
| * Appelle l'annuaire pour connaître tous les détails de l'utilisateur de courriel $login |
| */ |
| protected function obtenirInfosAnnuaire($login) { |
| $url_annuaire = $this->config['coel']['urlAnnuaire']; |
| $login_annuaire = $this->config['coel']['loginAnnuaire']; |
| $mdp_annuaire = $this->config['coel']['mdpAnnuaire']; |
| $posds = strpos($url_annuaire, "//"); |
| $protocole = substr($url_annuaire, 0, $posds+2); |
| $reste_adresse = substr($url_annuaire, $posds+2); |
| // auth HTTP basic cracra |
| $url_annuaire = $protocole . $login_annuaire . ':' . $mdp_annuaire . "@" . $reste_adresse; |
| $url_annuaire .= '/' . $login; |
| $url_annuaire .= '/xml'; // @TODO un jour, faire en sorte que ça lise du JSON |
| $resultat_annuaire = file_get_contents($url_annuaire); |
| $tableau_annuaire = null; |
| if ($xml_utilisateur = simplexml_load_string($resultat_annuaire)) { |
| // La fonction a retourné un objet |
| foreach ($xml_utilisateur->children() as $key => $val) { |
| if ((string) $val != '') { |
| $tableau_annuaire[$key] = (String) $val; |
| } |
| } |
| } |
| return $tableau_annuaire; |
| } |
| /** |
| * Enregistre le fait que la personne de login $login a accepté la licence de CoeL |
| */ |
| protected function accepterLicence($login) { |
| $sortie = false; |
| try { |
| $requete = 'UPDATE coel_personne '. |
| 'SET cp_mark_licence = 1 '. |
| "WHERE cp_login = {$this->bdd->quote($login)} "; |
| $resultat = $this->bdd->exec($requete); |
| if ($resultat === false) { |
| $this->debug[] = "La table Personne n'a pas été mise à jour car la requête a échoué"; |
| } else { |
| $this->debug[] = "Création du cookie licence."; |
| $_SESSION['coel_utilisateur']['licence'] = '1'; |
| // @TODO CHANGER |
| //$this->setCookiePersistant('coel_licence', '1'); |
| $sortie = true; |
| } |
| } catch (PDOException $e) { |
| $messages[] = sprintf($this->getTxt('sql_erreur'), $e->getFile(), $e->getLine(), $e->getMessage(), $requete); |
| } |
| return $sortie; |
| } |
| /** |
| * Essaye de trouver un jeton JWT non vide dans l'entête HTTP "Authorization" |
| * |
| * @return String un jeton JWT ou null |
| */ |
| protected function lireJetonEntete() { |
| $jwt = null; |
| $headers = apache_request_headers(); |
| if (isset($headers["Authorization"]) && ($headers["Authorization"] != "")) { |
| $jwt = $headers["Authorization"]; |
| } |
| return $jwt; |
| } |
| /** |
| * Vérifie un jeton auprès de l'annuaire |
| * |
| * @param String $jeton un jeton JWT |
| * @return true si le jeton est vérifié, false sinon |
| */ |
| protected function verifierJeton($jeton) { |
| $urlServiceVerification =$this->config['coel']['urlServiceBaseAuth'] . "verifierjeton"; |
| $urlServiceVerification .= "?token=" . $jeton; |
| // file_get_contents râle si le certificat HTTPS est auto-signé |
| //$retour = file_get_contents($urlServiceVerification); |
| // curl avec les options suivantes ignore le pb de certificat (pour tester en local) |
| $ch = curl_init(); |
| $timeout = 5; |
| curl_setopt($ch, CURLOPT_URL, $urlServiceVerification); |
| curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1); |
| curl_setopt($ch, CURLOPT_CONNECTTIMEOUT, $timeout); |
| // équivalent de "-k" |
| curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, false); |
| curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false); |
| $data = curl_exec($ch); |
| curl_close($ch); |
| $retour = $data; |
| $retour = json_decode($retour, true); |
| return ($retour === true); |
| } |
| /** |
| * Décode un jeton JWT (SSO) précédemment validé et retourne les infos |
| * qu'il contient (payload / claims) |
| * @param String $jeton un jeton JWT précédemment validé |
| */ |
| protected function decoderJeton($jeton) { |
| $parts = explode('.', $jeton); |
| $payload = $parts[1]; |
| $payload = base64_decode($payload); |
| $payload = json_decode($payload, true); |
| return $payload; |
| } |
| // accesseurs à deux ronds |
| protected function getUtilisateurId() { |
| if ($utilisateur = $this->getUtilisateur()) { |
| return $utilisateur['id']; |
| } else { |
| return ''; |
| } |
| } |
| protected function getUtilisateurLogin() { |
| if ($utilisateur = $this->getUtilisateur()) { |
| return $utilisateur['login']; |
| } else { |
| return ''; |
| } |
| } |
| protected function getUtilisateurNomComplet() { |
| if ($utilisateur = $this->getUtilisateur()) { |
| return $utilisateur['nom_complet']; |
| } else { |
| return ''; |
| } |
| } |
| protected function getUtilisateurPrenom() { |
| if ($utilisateur = $this->getUtilisateur()) { |
| return $utilisateur['prenom']; |
| } else { |
| return ''; |
| } |
| } |
| protected function getUtilisateurNom() { |
| if ($utilisateur = $this->getUtilisateur()) { |
| return $utilisateur['nom']; |
| } else { |
| return ''; |
| } |
| } |
| protected function getParametre() { |
| if ($utilisateur = $this->getUtilisateur()) { |
| return $utilisateur['parametre']; |
| } else { |
| return ''; |
| } |
| } |
| protected function getLicence() { |
| if (!empty($_SESSION['coel_utilisateur'])) { |
| return (string) $_SESSION['coel_utilisateur']['licence']; |
| } else { |
| return ''; |
| } |
| } |
| protected function getInfosAnnuaire() { |
| if (!empty($_SESSION['coel_infosAnnuaire'])) { |
| return $_SESSION['coel_infosAnnuaire']; |
| } else { |
| return ''; |
| } |
| } |
| protected function setInfosAnnuaire($infosAnnuaire) { |
| $_SESSION['coel_infosAnnuaire'] = $infosAnnuaire; |
| } |
| } |
| /** |
| * Compatibilité avec nginx - merci http://php.net/manual/fr/function.getallheaders.php |
| */ |
| if (! function_exists('apache_request_headers')) { |
| function apache_request_headers() { |
| $headers = ''; |
| foreach ($_SERVER as $name => $value) { |
| if (substr($name, 0, 5) == 'HTTP_') { |
| $headers[str_replace(' ', '-', ucwords(strtolower(str_replace('_', ' ', substr($name, 5)))))] = $value; |
| } |
| } |
| return $headers; |
| } |
| } |
| ?> |
| /branches/v1.11-okuzgozu/jrest/services/CoelStructureAPersonne.php |
|---|
| New file |
| 0,0 → 1,212 |
| <?php |
| /** |
| * Service fournissant la liste des relations "structure à personne". |
| * Encodage en entrée : utf8 |
| * Encodage en sortie : utf8 |
| * |
| * @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 $Id$ |
| * @copyright 2009 |
| */ |
| class CoelStructureAPersonne extends Coel { |
| /** Contient les infos sur les tables gérées par ce service. |
| * Bien respecter l'ordre avec en premier les tables liées et en dernier la table établissant la relation. */ |
| protected $tables = array( 113 => array( 'nom' => 'coel_personne', |
| 'prefixe' => 'cp', |
| 'id' => array('cp_id_personne')), |
| 121 => array( 'nom' => 'coel_structure_a_personne', |
| 'prefixe' => 'csap', |
| 'id' => array('csap_id_personne', 'csap_id_role', 'csap_id_structure'))); |
| /** |
| * Méthode appelée avec une requête de type GET. |
| */ |
| public function getElement($param = array()) { |
| // Initialisation des variables |
| $info = array(); |
| // Pré traitement des paramêtres |
| $p = $this->traiterParametresUrl(array('id_structure', 'id_role', 'id_personne'), $param); |
| // Construction de la requête |
| $requete = (($this->distinct) ? 'SELECT DISTINCT ' : 'SELECT '). |
| ' csap.*, '. |
| (isset($p['id_personne']) ? ' cs_nom, ' : ''). |
| ' cp_fmt_nom_complet, cp_prenom, cp_nom, cp_truk_telephone, cp_truk_courriel, cp_ce_truk_specialite '. |
| 'FROM coel_structure_a_personne AS csap '. |
| ' LEFT JOIN coel_meta_historique_ligne ON (csap_ce_meta = cmhl_id_historique_ligne) '. |
| ' LEFT JOIN coel_personne ON (csap_id_personne = cp_id_personne) '. |
| (isset($p['id_personne']) ? ' LEFT JOIN coel_structure ON (csap_id_structure = cs_id_structure) ' : ''). |
| ((count($p) != 0) ? 'WHERE ' : ''). |
| (isset($p['id_structure']) ? "AND csap_id_structure = {$p['id_structure']} " : ''). |
| (isset($p['id_role']) ? "AND csap_id_role = {$p['id_role']} " : ''). |
| (isset($p['id_personne']) ? "AND csap_id_personne = {$p['id_personne']} " : ''). |
| 'ORDER BY '.((!is_null($this->orderby)) ? $this->orderby : 'csap_ce_meta DESC').' '; |
| $requete = str_replace('WHERE AND', 'WHERE', $requete); |
| $requeteCount = $requete; |
| $requete .= "LIMIT $this->start, $this->limit "; |
| $this->debug[] = $requete; |
| // Récupération des résultats |
| try { |
| $nbElements = 0; |
| $donnees = $this->bdd->query($requete)->fetchAll(PDO::FETCH_ASSOC); |
| if ($donnees === false) { |
| $this->messages[] = "La requête a retourné aucun résultat."; |
| } else { |
| $nbElements = $this->bdd->query($requeteCount)->rowCount(); |
| } |
| $info['nbElements'] = $nbElements; |
| $info['structuresAPersonne'] = $donnees; |
| } catch (PDOException $e) { |
| $this->messages[] = sprintf($this->getTxt('sql_erreur'), $e->getFile(), $e->getLine(), $e->getMessage()); |
| } |
| // Envoie sur la sortie standard |
| $this->envoyer($info); |
| } |
| /** |
| * Méthode appelée pour ajouter un élément. |
| */ |
| public function createElement($params) { |
| // Identification de l'utilisateur |
| list($id_utilisateur, $id_session) = $this->getIdentification($params); |
| // Contrôle du non détournement de l'utilisateur |
| if ($this->etreAutorise($id_utilisateur)) { |
| // Vérification des tables à vraiment mettre à jour en fonction des données passées. |
| $tables_a_modifier = $this->recupererTablesAModifier($params); |
| try { |
| // Pour chaque table du module nous lançons si nécessaire l'historisation puis la mise à jour |
| // Nous ne pouvons pas utiliser foreach car il travaille sur une copie du tableau or nous le modifions dynamiquement dans la boucle |
| reset($tables_a_modifier); |
| while (list($table_id, $table) = each($tables_a_modifier)) { |
| if (!is_null($table['champs'])) { |
| if (!$this->avoirCleComplete($table)) { |
| // Ajout des données à la table des données |
| $id = $this->ajouter($table); |
| if ($id !== false) { |
| $table['champs_valeurs_id']['cp_id_personne'] = $id; |
| $table['champs_valeurs_brut']['cp_id_personne'] = $id; |
| $tables_a_modifier[121]['champs_valeurs_id']['csap_id_personne'] = $id; |
| $tables_a_modifier[121]['champs_valeurs_brut']['csap_id_personne'] = $id; |
| $tables_a_modifier[121]['champs_valeurs_protege']['csap_id_personne'] = $this->bdd->quote($id); |
| // Historisation (Ajout des méta-données) |
| $etat = 1; // Ajout |
| $cle = $this->recupererCle($table); |
| $info = $this->creerXmlHisto($table['champs_valeurs_brut']); |
| $id_meta = $this->historiser($table_id, $cle, $info, $id_utilisateur, $etat, $id_session); |
| // Liaison de la table des données à ses méta-données |
| $champ_meta = "{$table['prefixe']}_ce_meta"; |
| $table['champs_valeurs_protege'] = array($champ_meta => $id_meta); |
| $this->modifier($table); |
| } |
| } else { |
| $this->mettreAJourAvecCle($id_utilisateur, $id_session, $table_id, $table); |
| } |
| } |
| } |
| } catch (PDOException $e) { |
| $this->messages[] = sprintf($this->getTxt('sql_erreur'), $e->getFile(), $e->getLine(), $e->getMessage()); |
| } |
| } |
| // Envoie sur la sortie standard |
| $this->envoyer(); |
| } |
| /** |
| * Méthode appelée pour mettre à jour un élément |
| */ |
| public function updateElement($uid, $params) { |
| // Vérification de la présence des id passés par l'url |
| if (!isset($uid[0]) && !isset($uid[1]) && !isset($uid[2])) { |
| $this->messages[] = 'Aucun identifiant de structure, personne et role a été passé. Vous ne devriez pas avoir accès à ce service.'; |
| } else { |
| // Identification de l'utilisateur |
| list($id_utilisateur, $id_session) = $this->getIdentification($params); |
| // Contrôle du non détournement de l'utilisateur |
| if ($this->etreAutorise($id_utilisateur)) { |
| // Vérification des tables à vraiment mettre à jour en fonction des données passées. |
| $tables_a_modifier = $this->recupererTablesAModifier($params); |
| try { |
| // Pour chaque table du module nous lançons si nécessaire l'historisation puis la mise à jour |
| foreach ($tables_a_modifier as $table_id => $table) { |
| $this->mettreAJourAvecCle($id_utilisateur, $id_session, $table_id, $table); |
| } |
| } catch (PDOException $e) { |
| $this->messages[] = sprintf($this->getTxt('sql_erreur'), $e->getFile(), $e->getLine(), $e->getMessage(), $requete); |
| } |
| } |
| } |
| // Envoie sur la sortie standard |
| $this->envoyer(); |
| } |
| /** |
| * Méthode appelée pour supprimer un élément |
| */ |
| public function deleteElement($uid) { |
| // NOTES : la suppression ne supprime pas les personnes mais seulements les relations |
| // Vérification de la présence des id passés par l'url |
| if (!isset($uid[0]) || !isset($uid[1])) { |
| $this->messages[] = "Identifiant de relations ou d'utilisateur manquant. Vous ne devriez pas avoir accès à ce service."; |
| } else { |
| // Identification de l'utilisateur |
| list($id_utilisateur, $id_session) = $this->getIdentification($uid[0]); |
| // Contrôle du non détournement de l'utilisateur |
| if ($this->etreAutorise($id_utilisateur)) { |
| // Récupération des identifiant à supprimer |
| $identifiants = array(); |
| $identifiants_agreges = explode(',', rtrim($uid[1], ',')); |
| foreach ($identifiants_agreges as $identifiant) { |
| $identifiants[] = explode('-', $identifiant); |
| } |
| if (count($identifiants) == 0) { |
| $this->messages[] = "Aucun enregistrement n'a été supprimé."; |
| } else { |
| try { |
| foreach ($identifiants as $id) { |
| if (count($id) == 1) { // Seulement des id de structure |
| $params = array('csap_id_structure' => $id[0]); |
| } else if (count($id) == 3) { // Tous les id... |
| $params = array('csap_id_personne' => $id[1], 'csap_id_role' => $id[2], 'csap_id_structure' => $id[0]); |
| } |
| $tables_a_modifier = $this->recupererTablesAModifier($params); |
| $table = $tables_a_modifier[121]; |
| if ($this->avoirEnregistrement($table)) { |
| $resultat = $this->supprimer($table); |
| if ($resultat === true) { |
| // Historisation (Ajout des méta-données) |
| $cle = $this->recupererCle($table); |
| $this->historiser(121, $cle, 'NULL', $id_utilisateur, 3, $id_session); |
| } |
| } |
| } |
| } catch (PDOException $e) { |
| $this->messages[] = sprintf($this->getTxt('sql_erreur'), $e->getFile(), $e->getLine(), $e->getMessage(), $requete); |
| } |
| } |
| } |
| } |
| // Envoie sur la sortie standard |
| $this->envoyer(); |
| } |
| } |
| ?> |
| /branches/v1.11-okuzgozu/jrest/services/Coel.php |
|---|
| New file |
| 0,0 → 1,771 |
| <?php |
| /** Paramêtres indiquant que l'on est en français pour permettre l'affichage des dates en français. */ |
| setlocale(LC_TIME, 'fr_FR.UTF-8'); |
| /** Définition de l'encodage interne des fichiers. */ |
| mb_internal_encoding('UTF-8'); |
| /** |
| * Classe mère abstraite contenant les méthodes génériques des services. |
| * Encodage en entrée : utf8 |
| * Encodage en sortie : utf8 |
| * |
| * @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 $Id$ |
| * @copyright 2009 |
| */ |
| abstract class Coel { |
| const ETAT_AJOUTER = 1; |
| const ETAT_MODIFIER = 2; |
| const ETAT_SUPPRIMER = 3; |
| protected $sessionName = 'CoelSession'; |
| protected $sessionExpireTime = 8640000;// 60*60*24*100 = 100 jours |
| protected static $cookieChemin = ''; |
| public $config; |
| protected $bdd; |
| protected $log = array(); |
| protected $messages = array(); |
| protected $debug = array(); |
| protected $distinct = false; |
| protected $orderby = null; |
| protected $formatRetour = 'objet'; |
| protected $start = 0; |
| protected $limit = 150; |
| public function __construct($config, $demarrer_session = true) { |
| // Tableau contenant la config de Jrest |
| $this->config = $config; |
| // Connection à la base de données |
| $this->bdd = $this->connecterPDO($this->config, 'coel'); |
| $this->gererSession($demarrer_session); |
| $this->gererIdentificationPermanente(); |
| if(isset($_GET['start'])) $this->start = intval($_GET['start']); |
| if(isset($_GET['limit'])) $this->limit = intval($_GET['limit']); |
| // Nettoyage du $_GET (non-sécurisé) |
| if (isset($_GET)) { |
| $get_params = array('orderby', 'distinct', 'formatRetour', 'searchCity'); |
| foreach ($get_params as $get) { |
| $verifier = array('NULL', "\n", "\r", "\\", "'", '"', "\x00", "\x1a", ';'); |
| if (isset($_GET[$get]) && $_GET[$get] != '') { |
| $_GET[$get] = str_replace($verifier, '', $_GET[$get]); |
| $this->$get = $_GET[$get]; |
| } else { |
| $_GET[$get] = null; |
| } |
| } |
| } |
| } |
| /** |
| * Méthode appelée quand aucun paramètre n'est passé dans l'url et avec une requête de type GET. |
| */ |
| public function getRessource() { |
| $this->getElement(array()); |
| } |
| protected function creerXmlHisto($donnees) { |
| // Création du xml de l'enregistrement à historiser |
| $info = null; |
| $xml_tpl = '<?xml version="1.0" encoding="UTF-8" ?>'."\n<resultset>\n<row>\n%s</row>\n</resultset>"; |
| $xml = null; |
| foreach ($donnees as $cle => $valeur) { |
| if (!is_null($valeur) && $valeur != '') { |
| $xml .= "<$cle>$valeur</$cle>\n"; |
| } |
| } |
| if ($xml !== null) { |
| $info = sprintf($xml_tpl, $xml); |
| $info = $this->bdd->quote($info); |
| } |
| return $info; |
| } |
| protected function getTableauDepuisXmlHisto($xml) { |
| // Création du xml de l'enregistrement à historiser |
| $info = array(); |
| if (!empty($xml) && preg_match_all('|<([^>]+)>(.*)</[^>]+>|U', $xml, $matches, PREG_SET_ORDER)) { |
| foreach ($matches as $val) { |
| $info[$val[1]] = $val[2]; |
| } |
| } |
| return $info; |
| } |
| protected function historiser($table_id, $ligne_cle, $info, $id_utilisateur, $etat, $id_session) { |
| date_default_timezone_set('Europe/Paris'); |
| // Pré-traitement des variables |
| $info = (is_null($info)) ? 'NULL' : $info; |
| // Historisation (Ajout des méta-données) |
| $requete = 'INSERT INTO coel_meta_historique_ligne '. |
| ' (cmhl_ce_table, cmhl_cle_ligne, cmhl_enregistrement, cmhl_date_modification, cmhl_ce_modifier_par, cmhl_ce_etat, cmhl_ip, cmhl_session_id) '. |
| 'VALUES ('. |
| " $table_id, ". |
| ' "'.$ligne_cle.'", '. |
| " $info, ". |
| ' "'.date('Y-m-d H:i:s', time()).'", '. |
| " $id_utilisateur, ". |
| " $etat, ". |
| ' "'.$_SERVER['REMOTE_ADDR'].'", '. |
| ' "'.$id_session.'") '; |
| // Exécution de la requêtre SQL et test d'éventuelles erreurs |
| $resultat = $this->bdd->exec($requete); |
| if ($resultat === false ) { |
| $this->log[] = "Des données de la table '$table_id' (enrg. $ligne_cle) n'ont pas été historisées car la requête a échouée."; |
| } |
| return $this->bdd->lastInsertId(); |
| } |
| protected function envoyer($donnees = null, $mime = 'application/json', $encodage = 'utf-8', $json = true) { |
| // Traitements des messages d'erreurs et données |
| if (count($this->messages) != 0) { |
| header('HTTP/1.1 500 Internal Server Error'); |
| $mime = 'text/html'; |
| $encodage = 'utf-8'; |
| $json = true; |
| $sortie = $this->messages; |
| } else { |
| $sortie = $donnees; |
| if (is_null($donnees)) { |
| $sortie = 'OK'; |
| } |
| } |
| // Gestion de l'envoie du déboguage |
| $this->envoyerDebogage(); |
| // Encodage au format et JSON et envoie sur la sortie standard |
| $contenu = $json ? json_encode($sortie) : $sortie; |
| $this->envoyerContenu($encodage, $mime, $contenu); |
| } |
| protected function envoyerHTML($donnees = null) { |
| // Traitements des messages d'erreurs et données |
| $contenu = ''; |
| if (count($this->messages) > 0) { |
| $contenu = '<p>'.implode('<br />', $this->messages).'</p>'; |
| } else { |
| $contenu = $donnees; |
| if (is_null($donnees)) { |
| $contenu = 'OK'; |
| } |
| } |
| // Gestion de l'envoie du déboguage |
| $this->envoyerDebogage(); |
| // Envoie sur la sortie standard |
| $this->envoyerContenu(null, null, $contenu); |
| } |
| protected function envoyerEnteteMessage() { |
| if (!is_array($this->messages)) { |
| $this->messages[] = $this->messages; |
| } |
| if (count($this->messages) != 0) { |
| foreach ($this->messages as $cle => $val) { |
| if (is_array($val)) { |
| $this->messages[$cle] = print_r($val, true); |
| } |
| } |
| header('X-MessageJrest-Data: '.json_encode($this->messages)); |
| } |
| } |
| protected function envoyerDebogage() { |
| $this->envoyerEnteteDebogage(); |
| } |
| protected function envoyerEnteteDebogage() { |
| if (!is_array($this->debug)) { |
| $this->debug[] = $this->debug; |
| } |
| if (count($this->debug) != 0) { |
| foreach ($this->debug as $cle => $val) { |
| if (is_array($val)) { |
| $this->debug[$cle] = print_r($val, true); |
| } |
| } |
| header('X-DebugJrest-Data: '.json_encode($this->debug)); |
| } |
| } |
| protected function envoyerContenu($encodage, $mime, $contenu) { |
| if (!is_null($mime) && !is_null($encodage)) { |
| header("Content-Type: $mime; charset=$encodage"); |
| } else if (!is_null($mime) && is_null($encodage)) { |
| header("Content-Type: $mime"); |
| } |
| print $contenu; |
| } |
| private function connecterPDO($config, $base = 'database') { |
| $cfg = $config[$base]; |
| $dsn = $cfg['phptype'].':dbname='.$cfg['database'].';host='.$cfg['hostspec']; |
| try { |
| $PDO = new PDO($dsn, $cfg['username'], $cfg['password']); |
| } catch (PDOException $e) { |
| echo 'La connexion à la base de donnée via PDO a échouée : ' . $e->getMessage(); |
| } |
| // Passe en UTF-8 la connexion à la BDD |
| $PDO->exec("SET NAMES 'utf8'"); |
| // Affiche les erreurs détectées par PDO (sinon mode silencieux => aucune erreur affiché) |
| $PDO->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION); |
| return $PDO; |
| } |
| protected function getTxt($id) { |
| $sortie = ''; |
| switch ($id) { |
| case 'sql_erreur' : $sortie = 'Requête echec. Fichier : "%s". Ligne : "%s". Message : %s'; break; |
| case 'sql_erreur_requete' : $sortie = "Requête echec.\nFichier : %s.\nLigne : %s.\nMessage : %s.\nRequête : %s"; break; |
| default : $sortie = $id; |
| } |
| return $sortie; |
| } |
| protected function concatenerChamps($champs, $prefixe = null) { |
| $chaine = ''; |
| foreach ($champs as $cle => $valeur) { |
| if (is_null($prefixe) || (!is_null($prefixe) && stristr($cle, $prefixe.'_'))) { |
| $chaine .= ", $cle = $valeur"; |
| } |
| } |
| return ltrim($chaine, ', '); |
| } |
| protected function separerChampsValeurs($donnees, $prefixe = null) { |
| $sortie = array('', ''); |
| // Concaténation des champs et des valeurs dans des chaines séparées |
| foreach ($donnees as $cle => $valeur) { |
| if (is_null($prefixe) || (!is_null($prefixe) && stristr($cle, $prefixe.'_'))) { |
| $sortie[0] .= "$cle, "; |
| $sortie[1] .= "$valeur, "; |
| } |
| } |
| // Suppression de la virgule finale |
| $sortie[0] = rtrim($sortie[0], ', '); |
| $sortie[1] = rtrim($sortie[1], ', '); |
| return $sortie; |
| } |
| protected function traiterParametresUrl($params_attendu, $params, $pourBDD = true) { |
| $sortie = array(); |
| foreach ($params_attendu as $num => $nom) { |
| if (isset($params[$num]) && $params[$num] != '*') { |
| if ($pourBDD) { |
| $params[$num] = $this->bdd->quote($params[$num]); |
| } |
| $sortie[$nom] = $params[$num]; |
| } |
| } |
| return $sortie; |
| } |
| protected function traiterBddClauseIn($chaine) { |
| $sortie = ''; |
| $chaine = trim($chaine, " '"); |
| if ($chaine != '') { |
| $valeurs = explode(',', $chaine); |
| foreach ($valeurs as $id => $valeur) { |
| $valeurs[$id] = $this->bdd->quote($valeur); |
| } |
| $sortie = implode(',', $valeurs); |
| } |
| return $sortie; |
| } |
| protected function traiterParametresPost($params) { |
| $sortie = array(); |
| foreach ($params as $cle => $valeur) { |
| $sortie[$cle] = $this->bdd->quote($valeur); |
| } |
| return $sortie; |
| } |
| protected function getIdentification(&$params) { |
| // Initialisation des variables |
| $utilisateur = array(0, session_id()); |
| // L'id utilisateur est soit passé par le POST soit dans l'url |
| if (is_array($params) && isset($params['cmhl_ce_modifier_par'])) { |
| $utilisateur[0] = $params['cmhl_ce_modifier_par']; |
| unset($params['cmhl_ce_modifier_par']); |
| } else if (is_string($params)) { |
| $utilisateur[0] = $params; |
| } |
| return $utilisateur; |
| } |
| protected function etreAutorise($id_utilisateur) { |
| $autorisation = false; |
| if (!array_key_exists('coel_utilisateur', $_SESSION) || (($_SESSION['coel_utilisateur'] != '') && $_SESSION['coel_utilisateur']['id'] != $id_utilisateur)) { |
| $this->messages[] = 'Accès interdit.'; |
| } else if ($_SESSION['coel_utilisateur'] == '') { |
| $this->messages[] = 'Veuillez vous identifiez pour accéder à cette fonction.'; |
| } else { |
| $autorisation = true; |
| } |
| return $autorisation; |
| } |
| protected function recupererCle($table) { |
| $cle = null; |
| if (isset($table['champs_valeurs_id'])) { |
| $identifiants = array(); |
| // Trie des clés primaire pour avoir toujours le même ordre dans la table historique pour les clés multiples |
| ksort($table['champs_valeurs_id']); |
| foreach ($table['champs_valeurs_id'] as $id) { |
| $identifiants[] = $id; |
| } |
| $cle = implode('-', $identifiants); |
| } |
| return $cle; |
| } |
| protected function avoirCleComplete($table) { |
| $cle_complete = false; |
| if (isset($table['champs_valeurs_id'])) { |
| $ok = true; |
| foreach ($table['id'] as $id) { |
| if (!isset($table['champs_valeurs_id'][$id]) || $table['champs_valeurs_id'][$id] == '') { |
| $ok = false; |
| break; |
| } |
| } |
| $cle_complete = $ok; |
| } |
| return $cle_complete; |
| } |
| protected function recupererEtat($table) { |
| $etat = 1;// Ajout |
| if ($this->avoirEnregistrement($table) === true) { |
| $etat = 2;// Modification |
| } |
| return $etat; |
| } |
| protected function avoirEnregistrement($table) { |
| $avoir_enregistrement = false; |
| $requete = 'SELECT * '. |
| "FROM {$table['nom']} ". |
| "WHERE %s "; |
| $where = $this->construireWhere($table['champs_valeurs_id']); |
| $requete = sprintf($requete, $where); |
| // Exécution de la requêtre SQL et test d'éventuelles erreurs |
| $resultat = $this->bdd->query($requete, PDO::FETCH_ASSOC)->fetch(); |
| if ($resultat !== false) { |
| $avoir_enregistrement = true; |
| } |
| return $avoir_enregistrement; |
| } |
| protected function contenirDonnees($requete) { |
| $nbre = $this->bdd->query($requete)->fetchColumn(); |
| $presence = false; |
| if ($nbre != 0) { |
| $presence = true; |
| } |
| return $presence; |
| } |
| protected function construireWhere($table) { |
| $where = '1'; |
| if (is_array($table) && count($table) > 0) { |
| $table_where = array(); |
| foreach ($table as $chp => $id) { |
| $table_where[] = "$chp = '$id'"; |
| } |
| $where = implode(' AND ', $table_where); |
| } |
| return $where; |
| } |
| protected function recupererTablesAModifier($parametres) { |
| $tables_a_modifier = $this->tables; |
| foreach ($this->tables as $table_id => $table) { |
| $tables_a_modifier[$table_id]['champs'] = null; |
| foreach ($parametres as $cle => $valeur) { |
| if (preg_match('/^'.$table['prefixe'].'_/', $cle)) { |
| // Contient les noms des champs seulements |
| $tables_a_modifier[$table_id]['champs'][] = $cle; |
| // Contient un tableau de résultats protégé pour l'inclusion en bdd |
| $tables_a_modifier[$table_id]['champs_valeurs_protege'][$cle] = is_null($valeur) ? 'NULL' : $this->bdd->quote($valeur); |
| // Contient un tableau de résultats non protégé |
| $tables_a_modifier[$table_id]['champs_valeurs_brut'][$cle] = $valeur; |
| if (preg_match('/_id_/', $cle)) { |
| $tables_a_modifier[$table_id]['champs_valeurs_id'][$cle] = $valeur; |
| } |
| } |
| } |
| } |
| return $tables_a_modifier; |
| } |
| protected function mettreAJourAvecCle($id_utilisateur, $id_session, $table_id, $table) { |
| if (!is_null($table['champs'])) { |
| // Historisation (Ajout des méta-données) |
| $cle = $this->recupererCle($table); |
| $etat = $this->recupererEtat($table); |
| $info = $this->creerXmlHisto($table['champs_valeurs_brut']); |
| $id_meta = $this->historiser($table_id, $cle, $info, $id_utilisateur, $etat, $id_session); |
| $champ_meta = "{$table['prefixe']}_ce_meta"; |
| $table['champs_valeurs_protege'][$champ_meta] = $this->bdd->quote($id_meta); |
| // Mise à jour des données ou ajout en fonction de l'état |
| if ($etat == 1) { // Ajout |
| $this->ajouter($table); |
| } else if ($etat == 2) { // Modif |
| $this->modifier($table); |
| } |
| } |
| } |
| protected function ajouter($table) { |
| $requete = "INSERT INTO {$table['nom']} ". |
| ' (%s) '. |
| ' VALUES (%s) '; |
| $champs = $valeurs = ''; |
| foreach ($table['champs_valeurs_protege'] as $chp => $val) { |
| $champs .= "$chp, "; |
| $valeurs .= "$val, "; |
| } |
| $requete = sprintf($requete, rtrim($champs, ', '), rtrim($valeurs, ', ')); |
| $resultat = $this->bdd->exec($requete); |
| $dernier_id = false; |
| if ($resultat === false) { |
| $cle = $this->recupererCle($table); |
| $this->log[] = "L'enregistrement '$cle' de la table {$table['nom']} n'a pas été ajouté car la requête a échouée."; |
| } else { |
| $dernier_id = $this->bdd->lastInsertId(); |
| } |
| return $dernier_id; |
| } |
| protected function modifier($table) { |
| // nous ne voulons pas qu'une requête malheureuse affecte toute la base de données. Par exemple: |
| // POST "/jrest/CoelStructure/1"<<<"var=val&" // écraserait tous les enregistrements |
| // car on ne peut garantir que tout le code existant wrap'era ses appels dans un if(avoirCleComplete()) |
| if(!array_key_exists('champs_valeurs_id', $table)) die('erreur: ' . __FILE__ . ':' . __LINE__); |
| $requete = "UPDATE {$table['nom']} ". |
| 'SET %s '. |
| 'WHERE %s '; |
| $champs_requete = ''; |
| foreach ($table['champs_valeurs_protege'] as $chp => $val) { |
| $champs_requete .= "$chp = $val, "; |
| } |
| $where = $this->construireWhere($table['champs_valeurs_id']); |
| $requete = sprintf($requete, rtrim($champs_requete, ', '), $where); |
| $resultat = $this->bdd->exec($requete); |
| if ($resultat === false) { |
| $cle = $this->recupererCle($table); |
| $this->log[] = "L'enregistrement '$cle' de la table {$table['nom']} n'a pas été mis à jour car la requête a échouée."; |
| } else { |
| $resultat = true; |
| } |
| return $resultat; |
| } |
| protected function supprimer($table) { |
| $requete = "DELETE FROM {$table['nom']} ". |
| 'WHERE %s '; |
| $where = $this->construireWhere($table['champs_valeurs_id']); |
| $requete = sprintf($requete, $where); |
| $resultat = $this->bdd->exec($requete); |
| if ($resultat === false) { |
| $cle = $this->recupererCle($table); |
| $this->messages[] = "L'enregistrement '$cle' de la table {$table['nom']} n'a pas été supprimé car la requête a échouée."; |
| } else { |
| $resultat = true; |
| } |
| return $resultat; |
| } |
| private function gererSession($demarrage) { |
| session_name($this->sessionName); |
| // Configuration du cookie de session |
| // Détermination du chemin pour les cookies nécessaire à Jrest |
| /// ATTENTION : comme les cookies sont passés à Jrest, il faut utiliser l'url de Jrest pour établir le chemin |
| $url_morceaux = parse_url($this->config['coel']['urlBaseJrest']); |
| self::$cookieChemin = $this->reparerCheminCookie($url_morceaux['path']); |
| unset($url_morceaux); |
| session_set_cookie_params($this->sessionExpireTime, self::$cookieChemin); |
| // Démarrage de la session |
| if ($demarrage) { |
| session_start(); |
| } |
| } |
| private function reparerCheminCookie($chemin) { |
| // dirname renvoit / si le chemin vaut seulement /dossier/, cela renvoit /dossier si le chemin vaut /dossier//. |
| $chemin = dirname($chemin.'/.'); |
| // Fixe la gestion des chemins pour les cookies sous les OS utilisant le \ comme séparteur de chemin |
| $chemin = str_replace('\\', '/', $chemin); |
| // Ajoute un '/' terminal sauf si on est à la racine web |
| $chemin = ($chemin != '/' ? $chemin.'/' : ''); |
| return $chemin; |
| } |
| private function gererIdentificationPermanente() { |
| // Pour maintenir l'utilisateur tjrs réellement identifié nous sommes obligé de recréer une SESSION et de le recharger depuis la bdd |
| if ($this->getUtilisateur() == '' |
| && isset($_COOKIE['coel_login']) |
| && ($utilisateur = $this->chargerUtilisateur($_COOKIE['coel_login'], $_COOKIE['coel_mot_de_passe']))) { |
| $this->setUtilisateur($utilisateur, $_COOKIE['coel_permanence']); |
| } |
| } |
| /*protected function rechargerCookieUtilisateur() { |
| $utilisateur = $this->chargerUtilisateur($_COOKIE['coel_login']); |
| $this->setUtilisateur($utilisateur, $_COOKIE['coel_permanence']); |
| }*/ |
| protected function getUtilisateur() { |
| return (isset($_SESSION['coel_utilisateur']) ? $_SESSION['coel_utilisateur'] : ''); |
| } |
| /** |
| * Tente de trouver un utilisateur dans la table Personnes de CoeL, en fonction de son |
| * courriel ($login); si le mot de passe est fournie, le vérifie, sinon l'ignore |
| */ |
| protected function chargerUtilisateur($login, $mot_de_passe = null) { |
| $sortie = false; |
| $requete = 'SELECT cp_id_personne AS id, cp_fmt_nom_complet AS nom_complet, cp_prenom AS prenom, '. |
| ' cp_nom AS nom, cp_login AS login, cp_mot_de_passe AS mot_de_passe, cp_parametre AS parametre, '. |
| ' cp_ville AS ville, cp_code_postal AS code_postal, '. |
| ' cp_mark_licence AS licence '. |
| 'FROM coel_personne '. |
| "WHERE cp_login = {$this->bdd->quote($login)} ". |
| ((!is_null($mot_de_passe)) ? "AND cp_mot_de_passe = {$this->bdd->quote($mot_de_passe)} " : ''); |
| try { |
| $resultat = $this->bdd->query($requete)->fetch(); |
| if ($resultat === false) { |
| $this->debug[] = "L'utilisateur n'est pas enregistré comme utilisateur de COEL."; |
| } else { |
| $sortie = array('id' => $resultat['id'], |
| 'login' => $login, |
| 'mot_de_passe' => $resultat['mot_de_passe'], |
| 'nom_complet' => $resultat['nom_complet'], |
| 'nom' => $resultat['nom'], |
| 'prenom' => $resultat['prenom'], |
| 'parametre' => $resultat['parametre'], |
| 'ville' => $resultat['ville'], |
| 'code_postal' => $resultat['code_postal'], |
| 'licence' => $resultat['licence']); |
| } |
| } catch (PDOException $e) { |
| $this->messages[] = sprintf($this->getTxt('sql_erreur'), $e->getFile(), $e->getLine(), $e->getMessage()); |
| } |
| return $sortie; |
| } |
| /** |
| * Définit un utilisateur comme "actif" en plaçant un objet Utilisateur dans la session; |
| * Ne pose plus de cookies depuis l'adaptation au SSO, sauf pour la licence (acceptée ou non) |
| * @param unknown $utilisateur |
| * @param number $permanence |
| */ |
| protected function setUtilisateur($utilisateur, $permanence = 1) { |
| $_SESSION['coel_utilisateur'] = $utilisateur; |
| //$this->setCookiePersistant('coel_licence', $utilisateur['licence'], $permanence); |
| } |
| protected function setCookiePersistant($cookie_nom, $valeur, $permanence = 1) { |
| setCookie($cookie_nom, $valeur, time() + ($permanence ? 100*24*60*60 : 60*60), self::$cookieChemin); |
| $_COOKIE[$cookie_nom] = $valeur; |
| } |
| protected function supprimerCookie($cookie_nom) { |
| setCookie($cookie_nom, '', 1, self::$cookieChemin); |
| $_COOKIE[$cookie_nom] = ''; |
| } |
| /** |
| * Méthode prenant en paramètre un chemin de fichier squelette et un tableau associatif de données, |
| * en extrait les variables, charge le squelette et retourne le résultat des deux combinés. |
| * |
| * @param String $fichier le chemin du fichier du squelette |
| * @param Array $donnees un tableau associatif contenant les variables a injecter dans le squelette. |
| * |
| * @return boolean false si le squelette n'existe pas, sinon la chaine résultat. |
| */ |
| public static function traiterSquelettePhp($fichier, Array $donnees = array()) { |
| $sortie = false; |
| if (file_exists($fichier)) { |
| // Extraction des variables du tableau de données |
| extract($donnees); |
| // Démarage de la bufferisation de sortie |
| ob_start(); |
| // Si les tags courts sont activés |
| if ((bool) @ini_get('short_open_tag') === true) { |
| // Simple inclusion du squelette |
| include $fichier; |
| } else { |
| // Sinon, remplacement des tags courts par la syntaxe classique avec echo |
| $html_et_code_php = self::traiterTagsCourts($fichier); |
| // Pour évaluer du php mélangé dans du html il est nécessaire de fermer la balise php ouverte par eval |
| $html_et_code_php = '?>'.$html_et_code_php; |
| // Interprétation du html et du php dans le buffer |
| echo eval($html_et_code_php); |
| } |
| // Récupèration du contenu du buffer |
| $sortie = ob_get_contents(); |
| // Suppression du buffer |
| @ob_end_clean(); |
| } else { |
| $msg = "Le fichier du squelette '$fichier' n'existe pas."; |
| trigger_error($msg, E_USER_WARNING); |
| } |
| // Retourne le contenu |
| return $sortie; |
| } |
| /** |
| * Fonction chargeant le contenu du squelette et remplaçant les tags court php (<?= ...) par un tag long avec echo. |
| * |
| * @param String $chemin_squelette le chemin du fichier du squelette |
| * |
| * @return string le contenu du fichier du squelette php avec les tags courts remplacés. |
| */ |
| private static function traiterTagsCourts($chemin_squelette) { |
| $contenu = file_get_contents($chemin_squelette); |
| // Remplacement de tags courts par un tag long avec echo |
| $contenu = str_replace('<?=', '<?php echo ', $contenu); |
| // Ajout systématique d'un point virgule avant la fermeture php |
| $contenu = preg_replace("/;*\s*\?>/", "; ?>", $contenu); |
| return $contenu; |
| } |
| public static function debug($var) { |
| echo '<pre>'.print_r($var, true).'</pre>'; |
| } |
| /* |
| * Retourne une paire de coordonnée depuis un tableau représentant une adresse |
| * ou une adresse partielle à l'aide du service Nominatim. |
| * (http://wiki.openstreetmap.org/wiki/Nominatim) |
| * |
| * @param in data: un tableau associatif doté de *toutes* les clefs suivantes: |
| * 'adresse', 'cp', 'ville', 'pays' |
| * @param out lonlat: un tableau associatif contenant 'lon' et 'lat' si elles ont été déterminées |
| * Celles-ci sont sous la forme de deux chaînes de caractères numériques représentant |
| * un FLOAT() dont le séparateur des décimales est le "." (point). |
| * @param in opts: un tableau associatif optionnel écrasant ou ajoutant des valeurs d'API |
| * @return boolean: selon que la fonction à réussi ou non |
| * |
| * opts['force-q']: force l'utilisation d'une requête en texte libre |
| * quelque soit le remplissage des composants individuels |
| * |
| * Note: le code postal est contre-productif pour Nominatim: |
| * https://lists.openstreetmap.org/pipermail/talk-fr/2013-April/057084.html |
| */ |
| static function coordGuess(Array $data, Array &$lonlat, Array $opts = NULL) { |
| if(!$data) return FALSE; |
| $common_query = array('accept_language' => 'fr', 'format' => 'json', 'limit' => 1); |
| if(! $data['adresse'] || (! $data['cp'] && ! $data['ville']) || @$opts['force-q']) { |
| unset($opts['force-q']); |
| $query = array_merge($common_query, |
| array('q' => implode(', ', array_filter($data))), |
| $opts ? $opts : array()); |
| } |
| else { |
| $query = array_merge($common_query, |
| array_filter(array('street' => $data['adresse'], |
| 'city' => $data['ville'], |
| 'postalcode' => $data['cp'], |
| 'country' => $data['pays'])), |
| $opts ? $opts : array()); |
| } |
| $fullquery = 'http://nominatim.openstreetmap.org/search.php?' . http_build_query($query); |
| $ctx = stream_context_create(array('http' => array( 'timeout' => '4' ))); |
| $r = json_decode(file_get_contents($fullquery, FALSE, $ctx)); |
| error_log(sprintf("COEL: Nominatim request returned %d result(s) [%s]", count($r), $fullquery)); |
| if($r && isset($r[0])) { |
| $lonlat['lon'] = $r[0]->lon; |
| $lonlat['lat'] = $r[0]->lat; |
| return TRUE; |
| } |
| return FALSE; |
| } |
| /* |
| * Retourne un tableau prêt à être utilisé par coordGuess(), c'est à dire initialisant toutes |
| * les clefs nécessaires (même si NULL) et disposant systématiquement d'un pays. |
| * Cela à partir d'un tableau au format de clefs prédéterminé. |
| * S'occupe du filtrage basique des éléments pour maximiser les chances de détection. |
| * |
| * @param in: un tableau associatif contenant les clefs telles que nommées à l'issue du |
| * du formulaire de saisie: 'cs_adresse_01', 'cs_code_postal', 'cs_ville' |
| * @param db: une db optionnelle, utilisée si nécessaire pour converir les code pays |
| * du formulaire de saisie: 'cs_adresse_01', 'cs_code_postal', 'cs_ville' |
| * @return un tableau associatif contenant une ou plusieurs des clefs suivantes: |
| * 'adresse', 'cp', 'ville', 'pays' |
| */ |
| static function addrReStruct(Array $in, $db = NULL) { |
| $pays = FALSE; |
| if(is_numeric(@$in['cs_ce_truk_pays'])) { |
| if($db) { |
| $pays= $db->query(sprintf( |
| "SELECT cmlv_nom FROM coel_meta_liste_valeur ". |
| "WHERE cmlv_ce_parent = 1074 AND cmlv_id_valeur = %d", |
| intval($in['cs_ce_truk_pays'])))->fetchColumn(); |
| } |
| } |
| else $pays = @trim($in['cs_ce_truk_pays']); |
| // pas de précision au n°, mais Nominatim peine avec des préfixes trop élaborés |
| // coupons jusqu'à un élément reconnaissable s'il existe |
| $adresse = @trim($in['cs_adresse_01']); |
| $adresse = substr($adresse, stripos($adresse, "ville de ")); |
| $adresse = substr($adresse, stripos($adresse, "impasse")); |
| $adresse = substr($adresse, stripos($adresse, "chemin")); |
| $adresse = substr($adresse, stripos($adresse, "route")); |
| $adresse = substr($adresse, stripos($adresse, "rue")); |
| $adresse = substr($adresse, stripos($adresse, "avenue")); |
| $adresse = substr($adresse, stripos($adresse, "boulevard")); |
| $adresse = substr($adresse, stripos($adresse, "place")); |
| $adresse = substr($adresse, stripos($adresse, "promenade")); |
| $adresse = substr($adresse, stripos($adresse, "allée")); |
| $adresse = substr($adresse, stripos($adresse, "cours")); |
| $adresse = preg_replace("/[\r\n].*/", "", $adresse); |
| $ville = preg_replace('/cedex.*/i', '', @trim($in['cs_ville'])); |
| return array( |
| 'adresse' => $adresse, |
| 'cp' => @trim($in['cs_code_postal']) ? $in['cs_code_postal'] : '', |
| 'ville' => $ville, |
| 'pays' => $pays !== FALSE ? $pays : 'France' |
| ); |
| } |
| } |
| ?> |
| /branches/v1.11-okuzgozu/jrest/services/CoelStatistique.php |
|---|
| New file |
| 0,0 → 1,791 |
| <?php |
| /** |
| * Service fournissant des urls vers des images de graphiques sur les statistiques de l'application COEL. |
| * Encodage en entrée : utf8 |
| * Encodage en sortie : utf8 |
| * |
| * Cas d'utilisation : |
| * /CoelStatistique/MonTypeDeStat : retourne la balise html image du graphique pour le type de statistique demandé |
| * ?html=non : ce paramètre ajouté en fin d'url, force le retour de l'url du graphique sans la balise html img |
| * |
| * @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 $Id$ |
| * @copyright 2009 |
| */ |
| class CoelStatistique extends Coel { |
| const META_CODE_FRANCE = 2654; |
| const META_LISTE_SIECLE = 1040;// Liste des siècles pour les collections naturalistes |
| const META_LISTE_TYPE_HERBIER = 1083;// Liste des types de collection botanique |
| private $parametres = array(); |
| private $url_serveur_graph_tpl = 'http://%schart.apis.google.com/chart'; |
| /** |
| * Méthode appelée avec une requête de type GET. |
| */ |
| public function getElement($param) { |
| $graph = null; |
| if (isset($param[0])) { |
| $service_demande = array_shift($param); |
| $this->parametres = $param; |
| $methode = 'get'.$service_demande; |
| if (method_exists($this, $methode)) { |
| $graph = $this->$methode(); |
| } |
| } else { |
| $this->messages[] = "Le service COEL Statistique nécessite un paramètre."; |
| } |
| if (!is_null($graph)) { |
| if ((!isset($_GET['html']) || $_GET['html'] == 'oui')) { |
| // Nous retournons une balise HTML img |
| $url = $this->construireUrlGraph($graph); |
| $html = '<img src="'.$url.'"/>'; |
| $this->envoyerHTML($html); |
| } else { |
| // Nous retournons une image |
| $contexte = stream_context_create( |
| array('http' => array( |
| 'method' => 'POST', |
| 'content' => http_build_query($graph)))); |
| $image = file_get_contents($this->getUrlServeurGraph(), false, $contexte); |
| $this->envoyer($image, 'image/png', null, false); |
| } |
| } else { |
| $info = 'Un problème est survenu : '.print_r($this->messages, true); |
| $this->envoyerHTML($info); |
| } |
| } |
| private function getUrlServeurGraphPrincipal() { |
| $url = sprintf($this->url_serveur_graph_tpl, ''); |
| return $url; |
| } |
| private function getUrlServeurGraph() { |
| $url = sprintf($this->url_serveur_graph_tpl, rand(0, 9).'.'); |
| return $url; |
| } |
| private function construireUrlGraph($graph) { |
| $graph = $this->protegerGraphPourUrl($graph); |
| $url_parametres = array(); |
| foreach ($graph as $cle => $valeur) { |
| $url_parametres[] = "$cle=$valeur"; |
| } |
| $url = $this->getUrlServeurGraphPrincipal().'?'.implode('&', $url_parametres); |
| return $url; |
| } |
| private function protegerGraphPourUrl($graph) { |
| if (isset($graph['chtt'])) { |
| $graph['chtt'] = str_replace(' ', '+', $graph['chtt']); |
| } |
| return $graph; |
| } |
| private function existerParametre($numero) { |
| $exister = (isset($this->parametres[$numero]) && $this->parametres[$numero] != '*') ? true : false; |
| return $exister; |
| } |
| private function getNombreDonnees() { |
| // Récupération des données |
| $types = array( array('Commentaires', 'commentaire', 'ccm'), |
| array('Publications', 'publication', 'cpu'), |
| array('Personnes', 'personne', 'cp'), |
| array('Collections', 'collection', 'cc'), |
| array('Structures', 'structure', 'cs')); |
| $donnees = array(); |
| foreach ($types as $info) { |
| list($type, $table, $champ) = $info; |
| $donnees[$type] = $this->executerRequeteNombre($table, $champ); |
| } |
| // Post traitement des données de la base de données |
| asort($donnees); |
| $valeurs = implode(',', $donnees); |
| arsort($donnees); |
| $etiquettes = implode('|', array_keys($donnees)); |
| // Paramètres du graphique |
| $graph = array( |
| 'cht' => 'bhs', |
| 'chs' => '290x210', |
| 'chco' => '264327|5D7E2D|84A435|B5CD75|DFF1B3',// Source : Broccoli par DandL : http://www.colourlovers.com/palette/1371426/Broccoli |
| 'chd' => "t:$valeurs", |
| 'chds' => '0,'.max($donnees), |
| 'chxt' => 'y', |
| 'chxl' => "0:|$etiquettes|", |
| 'chm' => 'N ** ,000000,0,-1,10', |
| 'chtt' => 'Nombre de données'); |
| return $graph; |
| } |
| private function executerRequeteNombre($entite, $abr) { |
| $table = 'coel_'.$entite; |
| $champ_id = $abr.'_id_'.$entite; |
| $requete = "SELECT COUNT($champ_id) AS nbre ". |
| "FROM $table "; |
| try { |
| $nbre = $this->bdd->query($requete)->fetchColumn(); |
| if ($nbre === false) { |
| $this->messages[] = "La requête a retourné aucun résultat."; |
| } |
| } catch (PDOException $e) { |
| $this->messages[] = sprintf($this->getTxt('sql_erreur'), $e->getFile(), $e->getLine(), $e->getMessage()); |
| } |
| return $nbre; |
| } |
| private function getMesDonnees() { |
| // Récupération des données |
| $types = array( 'Commentaires' => array('107', 'ccm'), |
| 'Publications' => array('118, 119', 'cpu,cpuap'), |
| 'Personnes' => array('113, 114', 'cp,cpar'), |
| 'Collections' => array('101, 102, 103, 104, 106', 'cc,ccac,ccap,ccapu,ccb'), |
| 'Structures' => array('120, 121, 122, 123', 'cs,csap,csc,csv')); |
| $etats = array(1 => 'Ajouts', |
| 2 => 'Modifications', |
| 3 => 'Suppressions'); |
| $donnees = array(); |
| foreach ($types as $type => $tables_parametres) { |
| $tables_infos['identifiants'] = $tables_parametres[0]; |
| $tables_infos['abreviations'] = $tables_parametres[1]; |
| foreach ($etats as $etat_id => $etat_type) { |
| $donnees[$etat_type][$type] = $this->executerRequeteNombreDansHistorique($tables_infos, $etat_id); |
| } |
| } |
| // Post traitement des données de la base de données |
| $max_global = array(); |
| $ensembles_donnees = array(); |
| foreach ($donnees as $ensemble_donnees) { |
| $ensembles_donnees[] = implode(',', array_reverse($ensemble_donnees)); |
| // Gestion de l'échelle |
| foreach ($ensemble_donnees as $type => $val) { |
| if (!isset($max_global[$type])) { |
| $max_global[$type] = 0; |
| } |
| $max_global[$type] += $val; |
| } |
| } |
| $maximum = max($max_global); |
| $moitier = round(($maximum / 2), 1); |
| $valeurs = implode('|', $ensembles_donnees); |
| $etiquettes = implode('|', array_keys($types)); |
| $legende = implode('|', $etats); |
| $etiquettes_x = "0|$moitier|$maximum"; |
| $titre = $this->existerParametre(0) ? 'Ma participation' : 'Participation'; |
| // Paramètres du graphique |
| $graph = array( |
| 'cht' => 'bhg', |
| 'chs' => '290x210', |
| 'chbh' => 'a,2,4', |
| 'chco' => '66B032,FABC02,FE2712', |
| 'chdl' => $legende, |
| 'chdlp' => 'r', |
| 'chd' => "t:$valeurs", |
| 'chds' => "0,$maximum", |
| 'chxt' => 'y,x', |
| 'chxl' => "0:|$etiquettes|1:|$etiquettes_x", |
| 'chm' => 'N,000000,0,-1,10,1|N,000000,1,-1,10,1|N,000000,2,-1,10,1', |
| 'chtt' => $titre); |
| return $graph; |
| } |
| private function executerRequeteNombreDansHistorique($tables_infos, $etat) { |
| // Récupération des paramêtres |
| $personne_id = (isset($this->parametres[0]) && $this->parametres[0] != '*') ? $this->bdd->quote($this->parametres[0]) : null; |
| // Récupération des données |
| $requete = "SELECT COUNT(cmhl_date_modification) AS nbre ". |
| "FROM coel_meta_historique_ligne ". |
| "WHERE cmhl_ce_table IN ({$tables_infos['identifiants']}) ". |
| " AND cmhl_ce_etat = $etat ". |
| (isset($personne_id) ? " AND cmhl_ce_modifier_par = $personne_id " : ''); |
| try { |
| $nbre = $this->bdd->query($requete)->fetchColumn(); |
| if ($nbre === false) { |
| $this->messages[] = "La requête a retourné aucun résultat."; |
| } |
| } catch (PDOException $e) { |
| $this->messages[] = sprintf($this->getTxt('sql_erreur_requete'), $e->getFile(), $e->getLine(), $e->getMessage(), $requete); |
| } |
| return $nbre; |
| } |
| private function getTypeDepot() { |
| // Récupération des données |
| $requete = 'SELECT cmlv_nom AS type, COUNT(cc_ce_type_depot) AS nbre '. |
| 'FROM coel_collection '. |
| ' LEFT JOIN coel_meta_liste_valeur ON (cc_ce_type_depot = cmlv_id_valeur) '. |
| 'GROUP BY cc_ce_type_depot'; |
| try { |
| $infos = $this->bdd->query($requete)->fetchAll(PDO::FETCH_ASSOC); |
| if ($infos === false) { |
| $this->messages[] = "La requête a retourné aucun résultat."; |
| } |
| } catch (PDOException $e) { |
| $this->messages[] = sprintf($this->getTxt('sql_erreur'), $e->getFile(), $e->getLine(), $e->getMessage()); |
| } |
| // Post traitement des données de la base de données |
| $donnees = array(); |
| foreach ($infos as $info) { |
| if ($info['type'] != '') { |
| $cle = $info['type']; |
| } else { |
| $cle = 'Non renseigné'; |
| } |
| $donnees[$cle] = $info['nbre']; |
| } |
| asort($donnees); |
| $valeurs = implode(',', $donnees); |
| arsort($donnees); |
| $etiquettes = implode('|', array_keys($donnees)); |
| // Paramètres du graphique |
| $graph = array( |
| 'cht' => 'bhs', |
| 'chs' => '290x210', |
| 'chco' => '264327|5D7E2D|84A435|B5CD75|DFF1B3', |
| 'chd' => "t:$valeurs", |
| 'chds' => '0,'.(max($donnees)+5), |
| 'chxt' => 'y', |
| 'chxl' => "0:|$etiquettes|", |
| 'chm' => 'N *,000000,0,-1,10', |
| 'chtt' => 'Type de dépôt|des collections', |
| 'chts' => '000000,12'); |
| return $graph; |
| } |
| private function getNombreCollectionParStructure() { |
| // Récupération des données |
| $requete = 'SELECT COUNT(cc_id_collection) AS nbre '. |
| 'FROM coel_collection '. |
| 'GROUP BY cc_ce_structure '; |
| try { |
| $infos = $this->bdd->query($requete)->fetchAll(PDO::FETCH_ASSOC); |
| if ($infos === false) { |
| $this->messages[] = "La requête a retourné aucun résultat."; |
| } else if (count($infos) == 0) { |
| $this->messages[] = "Aucune collection n'est référencée."; |
| } |
| } catch (PDOException $e) { |
| $this->messages[] = sprintf($this->getTxt('sql_erreur'), $e->getFile(), $e->getLine(), $e->getMessage()); |
| } |
| // Post traitement des données de la base de données |
| $donnees = array( '1 collection' => 0, |
| '2 collections' => 0, |
| 'Entre 3 et 10' => 0, |
| 'Entre 11 et 50' => 0, |
| 'Plus de 50' => 0); |
| foreach ($infos as $info) { |
| $nbre = $info['nbre']; |
| if ($nbre == 1) { |
| $donnees['1 collection']++; |
| } else if ($nbre == 2) { |
| $donnees['2 collections']++; |
| } else if ($nbre >= 3 && $nbre <= 10) { |
| $donnees['Entre 3 et 10']++; |
| } else if ($nbre >= 11 && $nbre <= 50) { |
| $donnees['Entre 11 et 50']++; |
| } else if ($nbre > 50) { |
| $donnees['Plus de 50']++; |
| } |
| } |
| $donnees_tmp = $donnees; |
| $donnees = array(); |
| foreach ($donnees_tmp as $cle => $valeur) { |
| $donnees[$cle.' ('.$valeur.')'] = $valeur; |
| } |
| asort($donnees); |
| $valeurs = implode(',', $donnees); |
| //arsort($donnees); |
| $etiquettes = implode('|', array_keys($donnees)); |
| //$legende = implode('|', array_keys($donnees)); |
| // Paramètres du graphique |
| $graph = array( |
| 'cht' => 'p3', |
| 'chs' => '400x225', |
| 'chco' => 'EDC951|DEB0DB|DEC9B0|B0DEB3|B0C4DE|B0B0DE|927CBA', |
| 'chd' => "t:$valeurs", |
| 'chds' => '0,'.max($donnees), |
| 'chdl' => $etiquettes, |
| 'chtt' => 'Nombre de collections|par institution', |
| 'chts' => '000000,12'); |
| return $graph; |
| } |
| private function getNombrePartParStructure() { |
| // Récupération des données |
| $requete = 'SELECT cc_ce_structure, ccb_truk_unite_base '. |
| 'FROM coel_collection_botanique '. |
| ' LEFT JOIN coel_collection ON (ccb_id_collection = cc_id_collection) '; |
| try { |
| $infos = $this->bdd->query($requete)->fetchAll(PDO::FETCH_ASSOC); |
| if ($infos === false) { |
| $this->messages[] = "La requête a retourné aucun résultat."; |
| } else if (count($infos) == 0) { |
| $this->messages[] = "Aucune collection n'est référencée."; |
| } |
| } catch (PDOException $e) { |
| $this->messages[] = sprintf($this->getTxt('sql_erreur'), $e->getFile(), $e->getLine(), $e->getMessage()); |
| } |
| // Post traitement des données de la base de données |
| // Extraction du nombre de part |
| $structures = array(); |
| foreach ($infos as $info) { |
| if (!isset($structures[$info['cc_ce_structure']])) { |
| $structures[$info['cc_ce_structure']] = 0; |
| } |
| $structures[$info['cc_ce_structure']] += UtilTruck::extraireNbrePart($info['ccb_truk_unite_base']); |
| } |
| // Triage par classe |
| $donnees = array( '0 part' => 0, |
| 'Entre 1 et 100' => 0, |
| 'Entre 101 et 1000' => 0, |
| 'Entre 1001 et 10.000' => 0, |
| 'Entre 10.001 et 100.000' => 0, |
| 'Entre 100.001 et 300.000' => 0, |
| 'Supérieur à 300.000' => 0); |
| foreach ($structures as $nbre) { |
| if ($nbre == 0) { |
| $donnees['0 part']++; |
| } else if ($nbre >= 1 && $nbre <= 100) { |
| $donnees['Entre 1 et 100']++; |
| } else if ($nbre >= 101 && $nbre <= 1000) { |
| $donnees['Entre 101 et 1000']++; |
| } else if ($nbre >= 1001 && $nbre <= 10000) { |
| $donnees['Entre 1001 et 10.000']++; |
| } else if ($nbre >= 10001 && $nbre <= 100000) { |
| $donnees['Entre 10.001 et 100.000']++; |
| } else if ($nbre >= 100001 && $nbre <= 300000) { |
| $donnees['Entre 100.001 et 300.000']++; |
| } else if ($nbre >= 300001) { |
| $donnees['Supérieur à 300.000']++; |
| } |
| } |
| $donnees_tmp = $donnees; |
| $donnees = array(); |
| foreach ($donnees_tmp as $cle => $valeur) { |
| $donnees[$cle.' ('.$valeur.')'] = $valeur; |
| } |
| $donnees = array_reverse($donnees, true); |
| $legende = implode('|', array_keys($donnees)); |
| $valeurs = implode(',', $donnees); |
| // Paramètres du graphique |
| $graph = array( |
| 'cht' => 'p3', |
| 'chs' => '400x225', |
| 'chco' => 'EDC951|DEB0DB|DEC9B0|B0DEB3|B0C4DE|B0B0DE|927CBA',//4D89F9 ou EDC951|DEB0DB|DEC9B0|B0DEB3|B0C4DE|B0B0DE|DEBAB0 ou B02B2C|D15600|C79810|73880A|6BBA70|3F4C6B|356AA0 |
| 'chd' => "t:$valeurs", |
| 'chds' => '0,'.max($donnees), |
| 'chdl' => $legende, |
| 'chdlp' => 'r,0,1,2,3,4,5', |
| 'chtt' => 'Nombre de parts conservées |par institution', |
| 'chts' => '000000,11.5', |
| 'chts' => '000000,12'); |
| return $graph; |
| } |
| private function getNombrePartParCollection() { |
| // Récupération des données |
| $requete = 'SELECT ccb_truk_unite_base '. |
| 'FROM coel_collection_botanique '; |
| try { |
| $infos = $this->bdd->query($requete)->fetchAll(PDO::FETCH_ASSOC); |
| if ($infos === false) { |
| $this->messages[] = "La requête a retourné aucun résultat."; |
| } else if (count($infos) == 0) { |
| $this->messages[] = "Aucune collection n'est référencée."; |
| $infos == false; |
| } |
| } catch (PDOException $e) { |
| $this->messages[] = sprintf($this->getTxt('sql_erreur'), $e->getFile(), $e->getLine(), $e->getMessage()); |
| } |
| $graph = null; |
| if ($infos !== false) { |
| // Post traitement des données de la base de données |
| // Extraction du nombre de part |
| $collections = array(); |
| foreach ($infos as $info) { |
| $collections[] = UtilTruck::extraireNbrePart($info['ccb_truk_unite_base']); |
| } |
| // Triage par classe |
| $donnees = array( '0 part' => 0, |
| 'Entre 1 et 100' => 0, |
| 'Entre 101 et 1000' => 0, |
| 'Entre 1001 et 10.000' => 0, |
| 'Entre 10.001 et 100.000' => 0, |
| 'Entre 100.001 et 300.000' => 0, |
| 'Supérieur à 300.000' => 0); |
| foreach ($collections as $nbre) { |
| if ($nbre == 0) { |
| $donnees['0 part']++; |
| } else if ($nbre >= 1 && $nbre <= 100) { |
| $donnees['Entre 1 et 100']++; |
| } else if ($nbre >= 101 && $nbre <= 1000) { |
| $donnees['Entre 101 et 1000']++; |
| } else if ($nbre >= 1001 && $nbre <= 10000) { |
| $donnees['Entre 1001 et 10.000']++; |
| } else if ($nbre >= 10001 && $nbre <= 100000) { |
| $donnees['Entre 10.001 et 100.000']++; |
| } else if ($nbre >= 100001 && $nbre <= 300000) { |
| $donnees['Entre 100.001 et 300.000']++; |
| } else if ($nbre >= 300001) { |
| $donnees['Supérieur à 300.000']++; |
| } |
| } |
| $donnees_tmp = $donnees; |
| $donnees = array(); |
| foreach ($donnees_tmp as $cle => $valeur) { |
| $donnees[$cle.' ('.$valeur.')'] = $valeur; |
| } |
| $donnees = array_reverse($donnees, true); |
| $legende = implode('|', array_keys($donnees)); |
| $valeurs = implode(',', $donnees); |
| // Paramètres du graphique |
| $graph = array( |
| 'cht' => 'p3', |
| 'chs' => '400x225', |
| 'chco' => 'EDC951|DEB0DB|DEC9B0|B0DEB3|B0C4DE|B0B0DE|927CBA', |
| 'chd' => "t:$valeurs", |
| 'chds' => '0,'.max($donnees), |
| 'chdl' => $legende, |
| 'chdlp' => 'r,0,1,2,3,4,5', |
| 'chtt' => 'Nombre de parts conservées |par collection', |
| 'chts' => '000000,11.5', |
| 'chts' => '000000,12'); |
| } |
| return $graph; |
| } |
| private function getNombreCollectionParDepartement() { |
| // Récupération des données |
| $requete = 'SELECT cs_code_postal '. |
| 'FROM coel_collection '. |
| ' LEFT JOIN coel_structure ON (cc_ce_structure = cs_id_structure) '. |
| 'WHERE cs_ce_truk_pays = '.self::META_CODE_FRANCE.' '; |
| try { |
| $infos = $this->bdd->query($requete)->fetchAll(PDO::FETCH_ASSOC); |
| if ($infos === false) { |
| $this->messages[] = "La requête a retourné aucun résultat."; |
| } else if (count($infos) == 0) { |
| $this->messages[] = "Aucune collection n'est référencée."; |
| $infos == false; |
| } |
| } catch (PDOException $e) { |
| $this->messages[] = sprintf($this->getTxt('sql_erreur'), $e->getFile(), $e->getLine(), $e->getMessage()); |
| } |
| $graph = null; |
| if ($infos !== false) { |
| // Post traitement des données de la base de données |
| // Extraction du nombre de part |
| $donnees = array(); |
| foreach ($infos as $info) { |
| if (preg_match('/^([0-8][0-9]|9[0-5]|97[1-4]|976)/', $info['cs_code_postal'], $match)) { |
| if (! isset($donnees[$match[1]])) { |
| $donnees[$match[1]] = 1; |
| } else { |
| $donnees[$match[1]]++; |
| } |
| } |
| } |
| $donnees_tmp = $donnees; |
| $donnees = array(); |
| foreach ($donnees_tmp as $cle => $valeur) { |
| $donnees[$cle.' ('.$valeur.' collections)'] = $valeur; |
| } |
| asort($donnees); |
| $valeurs = implode(',', $donnees); |
| $legende = implode('|', array_keys($donnees)); |
| // Paramètres du graphique |
| $graph = array( |
| 'cht' => 'p3', |
| 'chs' => '400x225', |
| 'chco' => 'EDC951|DEB0DB|DEC9B0|B0DEB3|B0C4DE|B0B0DE|927CBA', |
| 'chd' => "t:$valeurs", |
| 'chds' => '0,'.max($donnees), |
| 'chdl' => $legende, |
| 'chtt' => 'Nombre de collections conservées |par département', |
| 'chts' => '000000,11.5', |
| 'chts' => '000000,12'); |
| } |
| return $graph; |
| } |
| private function getNombreCollectionParTypeStructure() { |
| // Récupération des données |
| $requete = 'SELECT cmlv_prive.cmlv_nom AS type_prive, cmlv_public.cmlv_nom AS type_public '. |
| 'FROM coel_collection '. |
| ' LEFT JOIN coel_structure ON (cc_ce_structure = cs_id_structure) '. |
| ' LEFT JOIN coel_meta_liste_valeur AS cmlv_prive ON (cs_ce_truk_type_prive = cmlv_prive.cmlv_id_valeur) '. |
| ' LEFT JOIN coel_meta_liste_valeur AS cmlv_public ON (cs_ce_truk_type_public = cmlv_public.cmlv_id_valeur) '; |
| try { |
| $infos = $this->bdd->query($requete)->fetchAll(PDO::FETCH_ASSOC); |
| if ($infos === false) { |
| $this->messages[] = "La requête a retourné aucun résultat."; |
| } else if (count($infos) == 0) { |
| $this->messages[] = "Aucune collection n'est référencée."; |
| $infos == false; |
| } |
| } catch (PDOException $e) { |
| $this->messages[] = sprintf($this->getTxt('sql_erreur'), $e->getFile(), $e->getLine(), $e->getMessage()); |
| } |
| //Coel::debug($infos); |
| $graph = null; |
| if ($infos !== false) { |
| // Post traitement des données de la base de données |
| // Extraction du nombre de part |
| $donnees = array(); |
| foreach ($infos as $info) { |
| if ($info['type_prive'] != '') { |
| $cle = $info['type_prive'].' [privé]'; |
| } else if ($info['type_public'] != '') { |
| $cle = $info['type_public'].' [public]'; |
| } else { |
| $cle = 'Non renseignées'; |
| } |
| if (! isset($donnees[$cle])) { |
| $donnees[$cle] = 1; |
| } else { |
| $donnees[$cle]++; |
| } |
| } |
| $donnees_tmp = $donnees; |
| $donnees = array(); |
| foreach ($donnees_tmp as $cle => $valeur) { |
| $donnees[$cle.' ('.$valeur.')'] = $valeur; |
| } |
| asort($donnees); |
| $valeurs = implode(',', $donnees); |
| $legende = implode('|', array_keys($donnees)); |
| // Paramètres du graphique |
| $graph = array( |
| 'cht' => 'p3', |
| 'chs' => '400x225', |
| 'chco' => 'EDC951|DEB0DB|DEC9B0|B0DEB3|B0C4DE|B0B0DE|927CBA', |
| 'chd' => "t:$valeurs", |
| 'chds' => '0,'.max($donnees), |
| 'chdl' => $legende, |
| 'chtt' => "Collections conservées |par type d'institution", |
| 'chts' => '000000,11.5', |
| 'chts' => '000000,12'); |
| } |
| return $graph; |
| } |
| private function getNombreCollectionParPeriode() { |
| // Récupération des données |
| $requete = 'SELECT cc_truk_periode_constitution '. |
| 'FROM coel_collection '; |
| try { |
| $infos = $this->bdd->query($requete)->fetchAll(PDO::FETCH_ASSOC); |
| if ($infos === false) { |
| $this->messages[] = "La requête a retourné aucun résultat."; |
| } else if (count($infos) == 0) { |
| $this->messages[] = "Aucune collection n'est référencée."; |
| $infos == false; |
| } |
| } catch (PDOException $e) { |
| $this->messages[] = sprintf($this->getTxt('sql_erreur'), $e->getFile(), $e->getLine(), $e->getMessage()); |
| } |
| //Coel::debug($infos); |
| // Récupération des métadonnées nécessaires |
| $requete = 'SELECT cmlv_id_valeur, cmlv_nom, cmlv_abreviation '. |
| 'FROM coel_meta_liste_valeur '. |
| 'WHERE cmlv_ce_parent = '.self::META_LISTE_SIECLE.' '; |
| try { |
| $metadonnees = $this->bdd->query($requete)->fetchAll(PDO::FETCH_ASSOC); |
| if ($metadonnees === false) { |
| $this->messages[] = "La requête de recherche des métadonnées a retourné aucun résultat."; |
| } |
| } catch (PDOException $e) { |
| $this->messages[] = sprintf($this->getTxt('sql_erreur'), $e->getFile(), $e->getLine(), $e->getMessage()); |
| } |
| $graph = null; |
| if ($infos !== false) { |
| // Traitement des métadonées |
| $periodes = array(0 => array('nom' => 'Non renseigné', 'abr' => 0)); |
| foreach ($metadonnees as $meta) { |
| $periodes[$meta['cmlv_id_valeur']] = array('nom' => $meta['cmlv_nom'], 'abr' => $meta['cmlv_abreviation']); |
| } |
| // Post traitement des données de la base de données |
| $donnees = array(); |
| foreach ($infos as $info) { |
| // Récupération de la période de début de constitution |
| $truk_periodes = explode(';;', $info['cc_truk_periode_constitution']); |
| $periode_abr_mini = 10; |
| $periode_id_mini = 0; |
| foreach ($truk_periodes as $periode_id) { |
| if (! empty($periode_id)) { |
| if ($periode_abr_mini > $periodes[$periode_id]['abr']) { |
| $periode_abr_mini = $periodes[$periode_id]['abr']; |
| $periode_id_mini = $periode_id; |
| } |
| } |
| } |
| // Augmentation du nombre de collection par période |
| if (! isset($donnees[$periodes[$periode_id_mini]['nom']])) { |
| $donnees[$periodes[$periode_id_mini]['nom']] = 1; |
| } else { |
| $donnees[$periodes[$periode_id_mini]['nom']]++; |
| } |
| } |
| $donnees_tmp = $donnees; |
| $donnees = array(); |
| foreach ($donnees_tmp as $cle => $valeur) { |
| $donnees[$cle.' ('.$valeur.')'] = $valeur; |
| } |
| asort($donnees); |
| $valeurs = implode(',', $donnees); |
| $legende = implode('|', array_keys($donnees)); |
| // Paramètres du graphique |
| $graph = array( |
| 'cht' => 'p3', |
| 'chs' => '400x225', |
| 'chco' => 'EDC951|DEB0DB|DEC9B0|B0DEB3|B0C4DE|B0B0DE|927CBA', |
| 'chd' => "t:$valeurs", |
| 'chds' => '0,'.max($donnees), |
| 'chdl' => $legende, |
| 'chtt' => "Collections recensées par|siècle de constitution", |
| 'chts' => '000000,11.5', |
| 'chts' => '000000,12'); |
| } |
| return $graph; |
| } |
| private function getNombreHerbierParType() { |
| // Récupération des données |
| $requete = 'SELECT ccb_ce_truk_type '. |
| 'FROM coel_collection_botanique '; |
| try { |
| $infos = $this->bdd->query($requete)->fetchAll(PDO::FETCH_ASSOC); |
| if ($infos === false) { |
| $this->messages[] = "La requête a retourné aucun résultat."; |
| } else if (count($infos) == 0) { |
| $this->messages[] = "Aucune collection n'est référencée."; |
| $infos == false; |
| } |
| } catch (PDOException $e) { |
| $this->messages[] = sprintf($this->getTxt('sql_erreur'), $e->getFile(), $e->getLine(), $e->getMessage()); |
| } |
| //Coel::debug($infos); |
| // Récupération des métadonnées nécessaires |
| $requete = 'SELECT cmlv_id_valeur, cmlv_nom, cmlv_abreviation '. |
| 'FROM coel_meta_liste_valeur '. |
| 'WHERE cmlv_ce_parent = '.self::META_LISTE_TYPE_HERBIER.' '; |
| try { |
| $metadonnees = $this->bdd->query($requete)->fetchAll(PDO::FETCH_ASSOC); |
| if ($metadonnees === false) { |
| $this->messages[] = "La requête de recherche des métadonnées n'a retourné aucun résultat."; |
| } |
| } catch (PDOException $e) { |
| $this->messages[] = sprintf($this->getTxt('sql_erreur'), $e->getFile(), $e->getLine(), $e->getMessage()); |
| } |
| $graph = null; |
| if ($infos !== false) { |
| // Traitement des métadonées |
| $types = array(0 => array('nom' => 'Non renseigné', 'abr' => 'NR')); |
| foreach ($metadonnees as $meta) { |
| $types[$meta['cmlv_id_valeur']] = array('nom' => $meta['cmlv_nom'], 'abr' => $meta['cmlv_abreviation']); |
| } |
| // Post traitement des données de la base de données |
| $donnees = array(); |
| foreach ($infos as $info) { |
| // Récupération du type d'herbier |
| $type_id = ($info['ccb_ce_truk_type'] != '') ? $info['ccb_ce_truk_type'] : 0; |
| $type_nom = $types[$type_id]['nom']; |
| // Augmentation du nombre de collection par période |
| if (! isset($donnees[$type_nom])) { |
| $donnees[$type_nom] = 1; |
| } else { |
| $donnees[$type_nom]++; |
| } |
| } |
| $donnees_tmp = $donnees; |
| $donnees = array(); |
| foreach ($donnees_tmp as $cle => $valeur) { |
| if ($remplacement = preg_replace('/^([^(]+) \([^\)]+\)/', '$1', $cle)) { |
| $cle = $remplacement; |
| } |
| $legende = $cle.' ('.$valeur.')'; |
| $donnees[$legende] = $valeur; |
| } |
| asort($donnees); |
| $valeurs = implode(',', $donnees); |
| $legende = implode('|', array_keys($donnees)); |
| // Paramètres du graphique |
| $graph = array( |
| 'cht' => 'p3', |
| 'chs' => '400x225', |
| 'chco' => 'EDC951|DEB0DB|DEC9B0|B0DEB3|B0C4DE|B0B0DE|927CBA', |
| 'chd' => "t:$valeurs", |
| 'chds' => '0,'.max($donnees), |
| 'chdl' => $legende, |
| 'chdlp' => 'r', |
| 'chtt' => "Nombre d'herbier par type", |
| 'chts' => '000000,11.5', |
| 'chts' => '000000,12'); |
| } |
| return $graph; |
| } |
| } |
| /branches/v1.11-okuzgozu/jrest/services/. |
|---|
| New file |
| Property changes: |
| Added: svn:ignore |
| +ferrege |