| 4 | aurelien | 1 | <?php
 | 
        
           |  |  | 2 | // declare(encoding='UTF-8');
 | 
        
           |  |  | 3 | /**
 | 
        
           |  |  | 4 |  * Modèle d'accès à la base de données des listes
 | 
        
           |  |  | 5 |  * d'ontologies
 | 
        
           |  |  | 6 |  *
 | 
        
           |  |  | 7 |  * PHP Version 5
 | 
        
           |  |  | 8 |  *
 | 
        
           |  |  | 9 |  * @package   Framework
 | 
        
           |  |  | 10 |  * @category  Class
 | 
        
           |  |  | 11 |  * @author	aurelien <aurelien@tela-botanica.org>
 | 
        
           |  |  | 12 |  * @copyright 2009 Tela-Botanica
 | 
        
           |  |  | 13 |  * @license   http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt Licence CECILL
 | 
        
           |  |  | 14 |  * @license   http://www.gnu.org/licenses/gpl.html Licence GNU-GPL
 | 
        
           |  |  | 15 |  * @version   SVN: $$Id: ListeAdmin.php 128 2009-09-02 12:20:55Z aurelien $$
 | 
        
           |  |  | 16 |  * @link	  /doc/framework/
 | 
        
           |  |  | 17 |  *
 | 
        
           |  |  | 18 |  */
 | 
        
           |  |  | 19 | class MetadonneeModele extends Modele {
 | 
        
           |  |  | 20 |   | 
        
           |  |  | 21 | 	private $config = array();
 | 
        
           |  |  | 22 | 	// TODO: externaliser l'identifiant de la liste des types depuis le fichier de config
 | 
        
           |  |  | 23 | 	private $id_liste_liste = 0;
 | 
        
           |  |  | 24 | 	private $id_liste_type = 1002;
 | 
        
           |  |  | 25 | 	private $id_liste_champs = 30768;
 | 
        
           |  |  | 26 |   | 
        
           |  |  | 27 | 	/**
 | 
        
           |  |  | 28 | 	 * Charge la liste complète des champs de métadonnées associées à un annuaire en particulier
 | 
        
           |  |  | 29 | 	 * return array un tableau contenant des objets d'informations sur les listes
 | 
        
           |  |  | 30 | 	 * @return array un tableau d'objets contenant la liste des listes
 | 
        
           |  |  | 31 | 	 */
 | 
        
           |  |  | 32 |    	public function chargerListeMetadonneeAnnuaire($id_annuaire) {
 | 
        
           |  |  | 33 |   | 
        
           |  |  | 34 | 		$requete = 	'SELECT * '.
 | 
        
           |  |  | 35 | 					'FROM annu_meta_colonne '.
 | 
        
           |  |  | 36 | 					'WHERE amc_ce_annuaire = '.$id_annuaire ;
 | 
        
           |  |  | 37 |   | 
        
           |  |  | 38 | 		$resultat = $this->requeteTous($requete);
 | 
        
           |  |  | 39 | 		$annuaire = array();
 | 
        
           |  |  | 40 | 		foreach ($resultat as $ligne) {
 | 
        
           | 5 | aurelien | 41 | 			// On remplace l'identifiant du type d'affichage par son nom
 | 
        
           | 4 | aurelien | 42 | 			$type_affichage = $this->renvoyerCorrespondanceNomId($ligne['amc_ce_type_affichage'], $this->id_liste_champs);
 | 
        
           |  |  | 43 | 			$ligne['amc_ce_nom_type_affichage']  = $type_affichage['amo_nom'];
 | 
        
           | 37 | aurelien | 44 | 			$ligne['amc_ce_template_affichage'] = $type_affichage['amo_abreviation'];
 | 
        
           | 18 | aurelien | 45 | 			$annuaire[$ligne['amc_id_champ']] = $ligne;
 | 
        
           | 4 | aurelien | 46 | 		}
 | 
        
           |  |  | 47 |   | 
        
           |  |  | 48 | 		return $annuaire;
 | 
        
           |  |  | 49 | 	}
 | 
        
           |  |  | 50 |   | 
        
           | 5 | aurelien | 51 | 	/**
 | 
        
           |  |  | 52 | 	 * Charge les elements d'une liste d'ontologie donnée
 | 
        
           |  |  | 53 | 	 * @param int $id_liste	l'identifiant de la liste dont on veut les élements
 | 
        
           |  |  | 54 | 	 * @param Array un tableau contenant les élements de la liste
 | 
        
           |  |  | 55 | 	 */
 | 
        
           | 4 | aurelien | 56 | 	public function chargerInfosListe($id_liste) {
 | 
        
           |  |  | 57 | 		$requete = 'SELECT amo_nom, amo_id_ontologie '.
 | 
        
           |  |  | 58 | 					'FROM annu_meta_ontologie '.
 | 
        
           |  |  | 59 | 					'WHERE amo_ce_parent = '.$id_liste.' '.
 | 
        
           |  |  | 60 | 					'ORDER BY amo_nom';
 | 
        
           |  |  | 61 |   | 
        
           |  |  | 62 | 		$resultat = $this->requeteTous($requete);
 | 
        
           |  |  | 63 | 		$liste_types = array();
 | 
        
           |  |  | 64 | 		foreach ($resultat as $ligne) {
 | 
        
           |  |  | 65 | 			$liste_types[] = $ligne;
 | 
        
           |  |  | 66 | 		}
 | 
        
           |  |  | 67 |   | 
        
           |  |  | 68 | 		return $liste_types;
 | 
        
           |  |  | 69 | 	}
 | 
        
           |  |  | 70 |   | 
        
           |  |  | 71 | 	/**
 | 
        
           |  |  | 72 | 	 * Charge la liste complète des types de champ
 | 
        
           |  |  | 73 | 	 * return array un tableau contenant des objets d'informations sur les types de champ
 | 
        
           |  |  | 74 | 	 * @return array un tableau d'objets contenant la liste des types de champs
 | 
        
           |  |  | 75 | 	 */
 | 
        
           |  |  | 76 | 	public function chargerListeDesTypesDeChamps() {
 | 
        
           |  |  | 77 | 		return $this->chargerInfosListe($this->id_liste_champs);
 | 
        
           |  |  | 78 | 	}
 | 
        
           |  |  | 79 |   | 
        
           |  |  | 80 | 	/**
 | 
        
           |  |  | 81 | 	 * Charge la liste complète des types SQL
 | 
        
           |  |  | 82 | 	 * return array un tableau contenant des objets d'informations sur les types SQL
 | 
        
           |  |  | 83 | 	 * @return array un tableau d'objets contenant la liste types de métadonnées
 | 
        
           |  |  | 84 | 	 */
 | 
        
           |  |  | 85 | 	public function chargerListeDesTypesSQL() {
 | 
        
           |  |  | 86 | 		return $this->chargerInfosListe($this->id_liste_type);
 | 
        
           |  |  | 87 | 	}
 | 
        
           |  |  | 88 |   | 
        
           |  |  | 89 | 	/**
 | 
        
           |  |  | 90 | 	 * Charge la liste complète des listes de métadonnées que l'on peut associer à un annuaire
 | 
        
           |  |  | 91 | 	 * return array un tableau contenant des objets d'informations sur les types de métadonnées
 | 
        
           |  |  | 92 | 	 * @return array un tableau d'objets contenant la liste types de métadonnées
 | 
        
           |  |  | 93 | 	 */
 | 
        
           |  |  | 94 | 	public function chargerListeDesListes() {
 | 
        
           |  |  | 95 | 		return $this->chargerInfosListe($this->id_liste_liste);
 | 
        
           |  |  | 96 | 	}
 | 
        
           |  |  | 97 |   | 
        
           |  |  | 98 | 	/**
 | 
        
           |  |  | 99 | 	 * Charge les informations d'une metadonnee
 | 
        
           |  |  | 100 | 	 * @param int l'identifiant de cette metadonnee
 | 
        
           | 5 | aurelien | 101 | 	 * @return Array un tableau contenant les informations sur cette metadonnee
 | 
        
           | 4 | aurelien | 102 | 	 */
 | 
        
           |  |  | 103 | 	 public function chargerInformationsMetaDonnee($id) {
 | 
        
           |  |  | 104 | 	 	$requete = 'SELECT * '.
 | 
        
           |  |  | 105 | 	 				'FROM annu_meta_colonne '.
 | 
        
           |  |  | 106 | 	 				'WHERE amc_id_champ = '.$id;
 | 
        
           |  |  | 107 |   | 
        
           |  |  | 108 | 	 	return $this->requeteUn($requete);
 | 
        
           |  |  | 109 | 	 }
 | 
        
           |  |  | 110 |   | 
        
           | 5 | aurelien | 111 | 	/**
 | 
        
           |  |  | 112 | 	 * Ajoute une nouvelle méta colonne à un annuaire donné
 | 
        
           |  |  | 113 | 	 * @param Array $valeurs les valeurs à ajouter dans la base
 | 
        
           |  |  | 114 | 	 * @return boolean true si la requete a réussi, false sinon
 | 
        
           |  |  | 115 | 	 */
 | 
        
           | 4 | aurelien | 116 | 	public function ajouterNouvelleMetadonnee($valeurs) {
 | 
        
           |  |  | 117 |   | 
        
           |  |  | 118 | 		$ontologie_liee = $this->proteger($valeurs['amc_ce_ontologie']);
 | 
        
           |  |  | 119 | 		$annuaire_lie = $this->proteger($valeurs['amc_ce_annuaire']);
 | 
        
           |  |  | 120 | 		$type_sql = $this->renvoyerTypeSQLPourChamp($valeurs['amc_ce_type_affichage']);
 | 
        
           | 5 | aurelien | 121 | 		$longueur = $this->renvoyerLongueurPourChamp($valeurs['amc_ce_type_affichage']);
 | 
        
           | 4 | aurelien | 122 | 		$nom = $this->proteger($valeurs['amc_nom']);
 | 
        
           |  |  | 123 | 		$abreviation = $this->proteger($valeurs['amc_abreviation']);
 | 
        
           |  |  | 124 | 		$description = $this->proteger($valeurs['amc_description']);
 | 
        
           |  |  | 125 | 		$type_affichage = $this->proteger($valeurs['amc_ce_type_affichage']);
 | 
        
           |  |  | 126 |   | 
        
           |  |  | 127 | 		$requete = 'INSERT INTO annu_meta_colonne '.
 | 
        
           |  |  | 128 | 					'(amc_ce_ontologie, amc_ce_annuaire, amc_ce_type, amc_longueur, amc_nom, amc_abreviation, amc_description, amc_ce_type_affichage) '.
 | 
        
           |  |  | 129 | 					'VALUES ('.$ontologie_liee.', '.
 | 
        
           |  |  | 130 | 							$annuaire_lie.', '.
 | 
        
           |  |  | 131 | 							$type_sql.', '.
 | 
        
           |  |  | 132 | 							$longueur.', '.
 | 
        
           |  |  | 133 | 							$nom.','.
 | 
        
           |  |  | 134 | 							$abreviation.','.
 | 
        
           |  |  | 135 | 							$description.', '.
 | 
        
           |  |  | 136 | 							$type_affichage.')';
 | 
        
           |  |  | 137 |   | 
        
           |  |  | 138 | 		return $this->requete($requete);
 | 
        
           |  |  | 139 | 	}
 | 
        
           |  |  | 140 |   | 
        
           | 5 | aurelien | 141 | 	/**
 | 
        
           |  |  | 142 | 	 * Modifie une meta colonne liée à un annuaire, grâce aux valeurs passées en paramètre
 | 
        
           |  |  | 143 | 	 * @param Array $valeurs les valeurs à modifier
 | 
        
           |  |  | 144 | 	 * @return boolean true si la requete a réussi, false sinon
 | 
        
           |  |  | 145 | 	 */
 | 
        
           | 4 | aurelien | 146 | 	public function modifierMetadonnee($valeurs) {
 | 
        
           |  |  | 147 |   | 
        
           | 122 | aurelien | 148 | 		$ontologie_liee = $this->proteger($valeurs['amc_ce_ontologie']);
 | 
        
           | 4 | aurelien | 149 | 		$type_sql = $this->renvoyerTypeSQLPourChamp($valeurs['amc_ce_type_affichage']);
 | 
        
           | 5 | aurelien | 150 | 		$longueur = $this->renvoyerLongueurPourChamp($valeurs['amc_ce_type_affichage']);
 | 
        
           | 4 | aurelien | 151 | 		$nom = $this->proteger($valeurs['amc_nom']);
 | 
        
           |  |  | 152 | 		$abreviation = $this->proteger($valeurs['amc_abreviation']);
 | 
        
           |  |  | 153 | 		$description = $this->proteger($valeurs['amc_description']);
 | 
        
           |  |  | 154 | 		$type_affichage = $this->proteger($valeurs['amc_ce_type_affichage']);
 | 
        
           |  |  | 155 |   | 
        
           |  |  | 156 | 		$requete = 'UPDATE annu_meta_colonne '.
 | 
        
           |  |  | 157 | 					'SET '.
 | 
        
           | 122 | aurelien | 158 | 					'amc_ce_ontologie = '.$ontologie_liee.', '.
 | 
        
           | 4 | aurelien | 159 | 					'amc_ce_type_affichage = '.$type_sql.', '.
 | 
        
           |  |  | 160 | 					'amc_longueur = '.$longueur.', '.
 | 
        
           |  |  | 161 | 					'amc_nom = '.$nom.', '.
 | 
        
           |  |  | 162 | 					'amc_abreviation = '.$abreviation.', '.
 | 
        
           |  |  | 163 | 					'amc_description = '.$description.', '.
 | 
        
           |  |  | 164 | 					'amc_ce_type_affichage = '.$type_affichage.' '.
 | 
        
           |  |  | 165 | 					'WHERE amc_id_champ = '.$valeurs['amc_id_champ'];
 | 
        
           |  |  | 166 |   | 
        
           |  |  | 167 | 		return $this->requete($requete);
 | 
        
           |  |  | 168 | 	}
 | 
        
           |  |  | 169 |   | 
        
           | 5 | aurelien | 170 | 	/**
 | 
        
           |  |  | 171 | 	 * Supprime une metadonnée
 | 
        
           |  |  | 172 | 	 * @param int $id_metadonnee l'identifiant de l'enregistrement à supprimer
 | 
        
           |  |  | 173 | 	 */
 | 
        
           |  |  | 174 | 	public function supprimerMetadonneeParId($id_metadonnee) {
 | 
        
           | 7 | aurelien | 175 | 		$requete_suppression_metadonnee = 'DELETE FROM annu_meta_colonne '.
 | 
        
           | 5 | aurelien | 176 | 					'WHERE amc_id_champ = '.$id_metadonnee;
 | 
        
           | 4 | aurelien | 177 |   | 
        
           | 7 | aurelien | 178 | 		return $this->requete($requete_suppression_metadonnee);
 | 
        
           | 4 | aurelien | 179 | 	}
 | 
        
           |  |  | 180 |   | 
        
           | 5 | aurelien | 181 | 	/**
 | 
        
           |  |  | 182 | 	 * Renvoie l'identifiant du type sql associé à un identifiant de type de champ
 | 
        
           |  |  | 183 | 	 * exemple champ texte => VARCHAR, champ texte long => TEXT
 | 
        
           |  |  | 184 | 	 * @param int $id_type_champ l'identifiant du type de champ
 | 
        
           |  |  | 185 | 	 * @return int l'identifiant du type sql correspondant
 | 
        
           |  |  | 186 | 	 */
 | 
        
           | 4 | aurelien | 187 | 	private function renvoyerTypeSQLPourChamp($id_type_champ) {
 | 
        
           | 5 | aurelien | 188 | 		// TODO: faire une vraie fonction
 | 
        
           | 4 | aurelien | 189 | 		return 1002 ;
 | 
        
           |  |  | 190 | 	}
 | 
        
           |  |  | 191 |   | 
        
           | 5 | aurelien | 192 | 	/**
 | 
        
           |  |  | 193 | 	 * Renvoie la longueur associée à un identifiant de type de champ
 | 
        
           |  |  | 194 | 	 * exemple champ texte => 50, champ texte long => 1000
 | 
        
           |  |  | 195 | 	 * @param int $id_type_champ l'identifiant du type de champ
 | 
        
           |  |  | 196 | 	 * @return int la longueur du champ correspondante
 | 
        
           |  |  | 197 | 	 * @return int la longueur associée au champ
 | 
        
           |  |  | 198 | 	 */
 | 
        
           |  |  | 199 | 	private function renvoyerLongueurPourChamp($id_type_champ) {
 | 
        
           |  |  | 200 | 		// TODO: faire une vraie fonction
 | 
        
           |  |  | 201 | 		return 255 ;
 | 
        
           |  |  | 202 | 	}
 | 
        
           |  |  | 203 |   | 
        
           |  |  | 204 | 	/**
 | 
        
           |  |  | 205 | 	 * Renvoie le nom d'une valeur de liste d'ontologie grâce à son identifiant
 | 
        
           |  |  | 206 | 	 * @param int $id_ontologie l'identifiant de la valeur dont on veut le nom
 | 
        
           |  |  | 207 | 	 * @param int $id_parent l'identifiant de la liste parente
 | 
        
           |  |  | 208 | 	 * @return string le nom du champ, ou false sinon
 | 
        
           |  |  | 209 | 	 */
 | 
        
           | 4 | aurelien | 210 | 	private function renvoyerCorrespondanceNomId($id_ontologie,$id_parent) {
 | 
        
           | 37 | aurelien | 211 | 		$requete = 'SELECT amo_nom, amo_abreviation '.
 | 
        
           | 4 | aurelien | 212 | 					'FROM annu_meta_ontologie '.
 | 
        
           | 7 | aurelien | 213 | 					'WHERE amo_ce_parent = '.$this->proteger($id_parent).' '.
 | 
        
           |  |  | 214 | 					'AND amo_id_ontologie = '.$this->proteger($id_ontologie);
 | 
        
           | 4 | aurelien | 215 |   | 
        
           |  |  | 216 | 		return $this->requeteUn($requete);
 | 
        
           |  |  | 217 | 	}
 | 
        
           |  |  | 218 |   | 
        
           | 122 | aurelien | 219 | 	/**
 | 
        
           | 82 | aurelien | 220 | 	 * Renvoie le nom d'une valeur de liste d'ontologie grâce à son identifiant
 | 
        
           |  |  | 221 | 	 * @param int $id_ontologie l'identifiant de la valeur dont on veut l'abreviation
 | 
        
           |  |  | 222 | 	 * @return string l'abreviation, ou false sinon
 | 
        
           |  |  | 223 | 	 */
 | 
        
           |  |  | 224 | 	public function renvoyerCorrespondanceAbreviationId($id_ontologie) {
 | 
        
           |  |  | 225 | 		$requete = 'SELECT amo_abreviation '.
 | 
        
           |  |  | 226 | 					'FROM annu_meta_ontologie '.
 | 
        
           |  |  | 227 | 					'WHERE amo_id_ontologie = '.$this->proteger($id_ontologie);
 | 
        
           | 5 | aurelien | 228 |   | 
        
           | 82 | aurelien | 229 | 		$resultat = $this->requeteUn($requete);
 | 
        
           |  |  | 230 |   | 
        
           |  |  | 231 | 		if($resultat) {
 | 
        
           |  |  | 232 | 			return $resultat['amo_abreviation'];
 | 
        
           |  |  | 233 | 		} else {
 | 
        
           |  |  | 234 | 			return false;
 | 
        
           |  |  | 235 | 		}
 | 
        
           |  |  | 236 | 	}
 | 
        
           | 122 | aurelien | 237 |   | 
        
           |  |  | 238 | 	public function renvoyerCorrespondanceIdParAbreviation($abreviation, $id_parent) {
 | 
        
           |  |  | 239 | 		$requete = 'SELECT amo_id_ontologie '.
 | 
        
           |  |  | 240 | 					'FROM annu_meta_ontologie '.
 | 
        
           |  |  | 241 | 					'WHERE amo_ce_parent = '.$this->proteger($id_parent).' '.
 | 
        
           |  |  | 242 | 					'AND amo_abreviation = '.$this->proteger($abreviation);
 | 
        
           |  |  | 243 |   | 
        
           |  |  | 244 | 		$resultat = $this->requeteUn($requete);
 | 
        
           | 82 | aurelien | 245 |   | 
        
           | 122 | aurelien | 246 | 		if($resultat) {
 | 
        
           |  |  | 247 | 			return $resultat['amo_id_ontologie'];
 | 
        
           |  |  | 248 | 		} else {
 | 
        
           |  |  | 249 | 			return false;
 | 
        
           |  |  | 250 | 		}
 | 
        
           |  |  | 251 | 	}
 | 
        
           | 82 | aurelien | 252 |   | 
        
           | 122 | aurelien | 253 |   | 
        
           | 5 | aurelien | 254 | 	/**
 | 
        
           |  |  | 255 | 	 * Renvoie le nom du template associé à un champ grâce à son identifiant
 | 
        
           |  |  | 256 | 	 * @param int $id_ontologie l'identifiant du champ dont on veut le template
 | 
        
           |  |  | 257 | 	 * @return string le nom du template (qui est l'abreviation du champ), ou false sinon
 | 
        
           |  |  | 258 | 	 */
 | 
        
           | 18 | aurelien | 259 | 	public function renvoyerTypeAffichageParId($id_champ) {
 | 
        
           | 4 | aurelien | 260 |   | 
        
           |  |  | 261 | 		$requete = 'SELECT amo_abreviation '.
 | 
        
           |  |  | 262 | 			'FROM annu_meta_ontologie '.
 | 
        
           |  |  | 263 | 			'WHERE amo_ce_parent = '.$this->id_liste_champs.' '.
 | 
        
           |  |  | 264 | 			'AND amo_id_ontologie = '.$id_champ;
 | 
        
           |  |  | 265 |   | 
        
           |  |  | 266 | 		$resultat = $this->requeteUn($requete);
 | 
        
           |  |  | 267 |   | 
        
           |  |  | 268 | 		return $resultat['amo_abreviation'];
 | 
        
           |  |  | 269 | 	}
 | 
        
           |  |  | 270 |   | 
        
           | 5 | aurelien | 271 | 	/**
 | 
        
           | 18 | aurelien | 272 | 	 * Renvoie le nom du template associé à un champ grâce à son identifiant
 | 
        
           |  |  | 273 | 	 * @param int $id_ontologie l'identifiant du champ dont on veut le template
 | 
        
           |  |  | 274 | 	 * @return string le nom du template (qui est l'abreviation du champ), ou false sinon
 | 
        
           |  |  | 275 | 	 */
 | 
        
           |  |  | 276 | 	public function renvoyerTypeAffichagePourColonne($id_colonne) {
 | 
        
           |  |  | 277 |   | 
        
           |  |  | 278 | 		$requete = 'SELECT amo_abreviation '.
 | 
        
           |  |  | 279 | 			'FROM annu_meta_ontologie '.
 | 
        
           |  |  | 280 | 			'WHERE amo_ce_parent = '.$this->id_liste_champs.' '.
 | 
        
           |  |  | 281 | 			'AND amo_id_ontologie =
 | 
        
           |  |  | 282 | 			(SELECT amc_ce_type_affichage '.
 | 
        
           |  |  | 283 | 				'FROM annu_meta_colonne '.
 | 
        
           |  |  | 284 | 				'WHERE amc_id_champ = '.$id_colonne.')';
 | 
        
           |  |  | 285 |   | 
        
           |  |  | 286 | 		$resultat = $this->requeteUn($requete);
 | 
        
           |  |  | 287 |   | 
        
           |  |  | 288 | 		if($resultat) {
 | 
        
           |  |  | 289 | 			return $resultat['amo_abreviation'];
 | 
        
           |  |  | 290 | 		} else {
 | 
        
           |  |  | 291 | 			return false;
 | 
        
           |  |  | 292 | 		}
 | 
        
           |  |  | 293 | 	}
 | 
        
           |  |  | 294 |   | 
        
           |  |  | 295 | 	/**
 | 
        
           |  |  | 296 | 	 * Renvoie vrai si un utilisateur possède une valeur de metadonnées pour une colonne donnée
 | 
        
           |  |  | 297 | 	 */
 | 
        
           |  |  | 298 | 	public function valeurExiste($id_champ, $id_enregistrement_lie) {
 | 
        
           |  |  | 299 |   | 
        
           | 162 | aurelien | 300 | 		$requete_existence_valeur = 'SELECT COUNT(*) as valeur_existe '.
 | 
        
           | 18 | aurelien | 301 | 					'FROM annu_meta_valeurs '.
 | 
        
           |  |  | 302 | 					'WHERE amv_ce_colonne = '.$id_champ.' '.
 | 
        
           |  |  | 303 | 					'AND amv_cle_ligne ='.$id_enregistrement_lie;
 | 
        
           |  |  | 304 |   | 
        
           |  |  | 305 | 		$resultat = $this->requeteUn($requete_existence_valeur);
 | 
        
           |  |  | 306 |   | 
        
           | 37 | aurelien | 307 | 		return ($resultat['valeur_existe'] >= 1) ;
 | 
        
           | 18 | aurelien | 308 | 	}
 | 
        
           | 152 | aurelien | 309 |   | 
        
           |  |  | 310 |   | 
        
           |  |  | 311 | 	public function renvoyerIdChampMetadonneeParAbreviation($id_annuaire, $abreviation) {
 | 
        
           |  |  | 312 |   | 
        
           |  |  | 313 | 		$requete_id = 'SELECT amc_id_champ '.
 | 
        
           |  |  | 314 | 					'FROM annu_meta_colonne '.
 | 
        
           |  |  | 315 | 					'WHERE amc_abreviation = '.$this->proteger($abreviation).' '.
 | 
        
           |  |  | 316 | 					'AND amc_ce_annuaire ='.$id_annuaire;
 | 
        
           | 245 | aurelien | 317 |   | 
        
           | 152 | aurelien | 318 | 		$resultat = $this->requeteUn($requete_id);
 | 
        
           |  |  | 319 |   | 
        
           |  |  | 320 | 		return ($resultat['amc_id_champ']) ;
 | 
        
           |  |  | 321 | 	}
 | 
        
           |  |  | 322 |   | 
        
           | 18 | aurelien | 323 | 	/**
 | 
        
           | 5 | aurelien | 324 | 	 * Ajoute une nouvelle valeur à un champ de metadonnées pour une ligne dans un annuaire donné
 | 
        
           |  |  | 325 | 	 * @param int $id_champ l'identifiant du champ auquel on ajoute cette valeur
 | 
        
           |  |  | 326 | 	 * @param int $id_enregistrement_lie l'identifiant de l'enregistrement lié dans l'annuairé mappé
 | 
        
           |  |  | 327 | 	 * @param mixed $valeur la valeur à associer au champ (peut-être une valeur brute ou bien un identifiant de liste d'ontologie)
 | 
        
           |  |  | 328 | 	 * @return true ou false suivant le succès de la requête
 | 
        
           |  |  | 329 | 	 */
 | 
        
           | 4 | aurelien | 330 | 	public function ajouterNouvelleValeurMetadonnee($id_champ, $id_enregistrement_lie, $valeur) {
 | 
        
           |  |  | 331 |   | 
        
           |  |  | 332 | 		$valeur = $this->proteger($valeur);
 | 
        
           |  |  | 333 |   | 
        
           |  |  | 334 | 		$requete = 'INSERT INTO annu_meta_valeurs '.
 | 
        
           |  |  | 335 | 		'(amv_ce_colonne, amv_cle_ligne, amv_valeur) '.
 | 
        
           |  |  | 336 | 		'VALUES ('.$id_champ.','.$id_enregistrement_lie.','.$valeur.')';
 | 
        
           |  |  | 337 |   | 
        
           |  |  | 338 | 		return $this->requete($requete);
 | 
        
           |  |  | 339 | 	}
 | 
        
           |  |  | 340 |   | 
        
           | 5 | aurelien | 341 | 	/**
 | 
        
           |  |  | 342 | 	 * Modifie une valeur d'un champ de metadonnées pour une ligne dans un annuaire donné
 | 
        
           |  |  | 343 | 	 * @param int $id_champ l'identifiant du champ dont on modifie la valeur
 | 
        
           |  |  | 344 | 	 * @param mixed $valeur la nouvelle valeur à associer au champ (peut-être une valeur brute ou bien un identifiant de liste d'ontologie)
 | 
        
           |  |  | 345 | 	 * @return boolean true ou false suivant le succès de la requête
 | 
        
           |  |  | 346 | 	 */
 | 
        
           | 18 | aurelien | 347 | 	public function modifierValeurMetadonnee($id_champ, $id_enregistrement_lie, $valeur) {
 | 
        
           | 4 | aurelien | 348 |   | 
        
           | 5 | aurelien | 349 | 		$requete = 'UPDATE annu_meta_valeurs '.
 | 
        
           |  |  | 350 | 		'SET amv_valeur = '.$this->proteger($valeur).' '.
 | 
        
           | 18 | aurelien | 351 | 		'WHERE amv_cle_ligne = '.$id_enregistrement_lie.' '.
 | 
        
           |  |  | 352 | 		'AND amv_ce_colonne = '.$id_champ;
 | 
        
           | 5 | aurelien | 353 |   | 
        
           |  |  | 354 | 		return $this->requete($requete);
 | 
        
           |  |  | 355 | 	}
 | 
        
           |  |  | 356 |   | 
        
           |  |  | 357 | 	/**
 | 
        
           |  |  | 358 | 	 * Supprime une valeur de metadonnée par son identifiant
 | 
        
           |  |  | 359 | 	 * @param int $id_valeur_metadonnee l'identifiant de valeur à supprimer
 | 
        
           |  |  | 360 | 	 * @return true ou false suivant le succès de la requete
 | 
        
           |  |  | 361 | 	 */
 | 
        
           | 4 | aurelien | 362 | 	public function supprimerValeurMetadonnee($id_valeur_metadonnee) {
 | 
        
           |  |  | 363 |   | 
        
           |  |  | 364 | 		$requete = 'DELETE FROM annu_meta_valeurs '.
 | 
        
           |  |  | 365 | 		'WHERE amv_id_valeur = '.$id_valeur_metadonnee;
 | 
        
           |  |  | 366 |   | 
        
           |  |  | 367 | 		return $this->requete($requete);
 | 
        
           |  |  | 368 | 	}
 | 
        
           |  |  | 369 |   | 
        
           | 5 | aurelien | 370 | 	/**
 | 
        
           |  |  | 371 | 	 * Supprime les valeurs de metadonnées associés à un identifiant de ligne d'annuaire
 | 
        
           |  |  | 372 | 	 * @param int $id_enregistrement_lie l'identifiant de la ligne à laquelle sont associées les valeurs à supprimer
 | 
        
           |  |  | 373 | 	 */
 | 
        
           | 4 | aurelien | 374 | 	public function supprimerValeursMetadonneesParIdEnregistrementLie($id_enregistrement_lie) {
 | 
        
           | 18 | aurelien | 375 |   | 
        
           | 4 | aurelien | 376 | 		$requete = 'DELETE FROM annu_meta_valeurs '.
 | 
        
           |  |  | 377 | 		'WHERE amv_cle_ligne = '.$id_enregistrement_lie;
 | 
        
           |  |  | 378 |   | 
        
           |  |  | 379 | 		return $this->requete($requete);
 | 
        
           |  |  | 380 | 	}
 | 
        
           |  |  | 381 |   | 
        
           | 7 | aurelien | 382 | 	/** Supprime les valeurs de metadonnées associés à un identifiant de colonne
 | 
        
           |  |  | 383 | 	 * @param int $id_colonne_liee l'identifiant de la colonne à laquelle sont associées les valeurs à supprimer
 | 
        
           |  |  | 384 | 	 */
 | 
        
           |  |  | 385 | 	public function supprimerValeursMetadonneesParIdColonneLiee($id_colonne_liee) {
 | 
        
           |  |  | 386 | 		$requete = 'DELETE FROM annu_meta_valeurs '.
 | 
        
           |  |  | 387 | 		'WHERE amv_ce_colonne = '.$id_colonne_liee;
 | 
        
           |  |  | 388 |   | 
        
           |  |  | 389 | 		return $this->requete($requete);
 | 
        
           |  |  | 390 | 	}
 | 
        
           |  |  | 391 |   | 
        
           | 4 | aurelien | 392 | 	/**
 | 
        
           |  |  | 393 | 	 * Charge les valeurs de metadonnées pour un identifiant de ligne donné
 | 
        
           | 5 | aurelien | 394 | 	 * @param int $id_annuaire l'identifiant de l'annuaire sur lequel on travaille
 | 
        
           |  |  | 395 | 	 * @param int $id_utilisateur l'identifiant de la ligne dans l'annuaire pour laquelle on veut récupérer les valeur de metadonnées
 | 
        
           | 4 | aurelien | 396 | 	 */
 | 
        
           | 5 | aurelien | 397 | 	 public function chargerListeValeursMetadonneesUtilisateur($id_annuaire, $id_enregistrement_lie) {
 | 
        
           | 4 | aurelien | 398 |   | 
        
           | 7 | aurelien | 399 | 		// première requete pour obtenir les valeurs des champs de metadonnées liées à la ligne
 | 
        
           | 18 | aurelien | 400 | 	 	$requete_valeurs_metadonnees =  'SELECT amv_ce_colonne, amv_valeur, amc_ce_ontologie, amc_abreviation, amc_ce_type_affichage FROM annu_meta_valeurs '.
 | 
        
           | 7 | aurelien | 401 | 	 		 						  	'LEFT JOIN annu_meta_colonne '.
 | 
        
           |  |  | 402 | 	 									'ON annu_meta_colonne.amc_id_champ = annu_meta_valeurs.amv_ce_colonne '.
 | 
        
           |  |  | 403 | 	 									'WHERE amv_cle_ligne = '.$id_enregistrement_lie.' ';
 | 
        
           | 4 | aurelien | 404 |   | 
        
           |  |  | 405 | 		$resultat_valeurs_metadonnees = $this->requeteTous($requete_valeurs_metadonnees);
 | 
        
           |  |  | 406 |   | 
        
           |  |  | 407 | 		if(!$resultat_valeurs_metadonnees) {
 | 
        
           |  |  | 408 |   | 
        
           | 7 | aurelien | 409 | 	 		$liste_metadonnee = array();
 | 
        
           | 4 | aurelien | 410 |   | 
        
           | 7 | aurelien | 411 | 		} else {
 | 
        
           |  |  | 412 | 	 		foreach ($resultat_valeurs_metadonnees as $ligne) {
 | 
        
           | 4 | aurelien | 413 |   | 
        
           | 7 | aurelien | 414 | 				// pour toutes les valeurs qui sont des élements d'une liste d'ontologie
 | 
        
           |  |  | 415 | 				if($ligne['amc_ce_ontologie'] != 0) {
 | 
        
           |  |  | 416 |   | 
        
           | 18 | aurelien | 417 | 					// Si c'est un champ qui contient de multiples valeurs, alors il contient potientiellement le séparateur de métadonnées
 | 
        
           | 7 | aurelien | 418 | 					if(strpos($ligne['amv_valeur'],Config::get('separateur_metadonnee'))) {
 | 
        
           |  |  | 419 |   | 
        
           |  |  | 420 | 						$id_valeurs_metadonnees = explode(Config::get('separateur_metadonnee'), $ligne['amv_valeur']);
 | 
        
           |  |  | 421 | 						$ligne['amv_valeur'] = $id_valeurs_metadonnees;
 | 
        
           |  |  | 422 |   | 
        
           |  |  | 423 | 						foreach ($id_valeurs_metadonnees as $id_valeur) {
 | 
        
           |  |  | 424 | 							$resultat_nom_valeur = $this->renvoyerCorrespondanceNomId($id_valeur,$ligne['amc_ce_ontologie']);
 | 
        
           |  |  | 425 | 							$ligne['amo_nom'][] = $resultat_nom_valeur['amo_nom'];
 | 
        
           |  |  | 426 | 						}
 | 
        
           |  |  | 427 | 					} else {
 | 
        
           |  |  | 428 | 						$resultat_nom_valeur = $this->renvoyerCorrespondanceNomId($ligne['amv_valeur'],$ligne['amc_ce_ontologie']);
 | 
        
           |  |  | 429 | 						$ligne['amo_nom'] = $resultat_nom_valeur['amo_nom'];
 | 
        
           |  |  | 430 | 					}
 | 
        
           |  |  | 431 |   | 
        
           |  |  | 432 | 					$nom_valeur = $resultat_nom_valeur['amo_nom'];
 | 
        
           | 152 | aurelien | 433 | 				} else {
 | 
        
           |  |  | 434 | 					$ligne['amv_valeur'] = stripslashes($ligne['amv_valeur']);
 | 
        
           | 7 | aurelien | 435 | 				}
 | 
        
           |  |  | 436 |   | 
        
           | 18 | aurelien | 437 | 				$ligne['amc_ce_type_affichage'] = $this->renvoyerTypeAffichageParId($ligne['amc_ce_type_affichage']);
 | 
        
           | 7 | aurelien | 438 | 				$liste_metadonnee[$ligne['amc_abreviation']] = $ligne;
 | 
        
           |  |  | 439 | 			}
 | 
        
           | 4 | aurelien | 440 | 		}
 | 
        
           |  |  | 441 |   | 
        
           | 18 | aurelien | 442 | 		$colonnes_totales = $this->chargerListeMetadonneeAnnuaire($id_annuaire);
 | 
        
           | 7 | aurelien | 443 |   | 
        
           | 18 | aurelien | 444 | 		foreach ($colonnes_totales as $colonne) {
 | 
        
           |  |  | 445 | 			if(!isset($liste_metadonnee[$colonne['amc_abreviation']])) {
 | 
        
           |  |  | 446 |   | 
        
           |  |  | 447 | 				if($colonne['amc_ce_ontologie'] != 0) {
 | 
        
           |  |  | 448 | 					$valeur = array();
 | 
        
           |  |  | 449 | 				} else {
 | 
        
           |  |  | 450 | 					$valeur = '';
 | 
        
           |  |  | 451 | 				}
 | 
        
           |  |  | 452 |   | 
        
           |  |  | 453 | 				$liste_metadonnee[$colonne['amc_abreviation']] = array('amv_ce_colonne' => $colonne['amc_id_champ'],
 | 
        
           |  |  | 454 |             		'amv_valeur' => $valeur,
 | 
        
           |  |  | 455 |             		'amo_nom' => '',
 | 
        
           |  |  | 456 |             		'amc_ce_ontologie' => $colonne['amc_ce_ontologie'],
 | 
        
           |  |  | 457 |             		'amc_abreviation' => $colonne['amc_abreviation'],
 | 
        
           |  |  | 458 |             		'amc_ce_type_affichage' => $this->renvoyerTypeAffichageParId($colonne['amc_ce_type_affichage']));
 | 
        
           |  |  | 459 | 			}
 | 
        
           |  |  | 460 | 		}
 | 
        
           |  |  | 461 |   | 
        
           | 4 | aurelien | 462 | 		return $liste_metadonnee;
 | 
        
           |  |  | 463 |   | 
        
           |  |  | 464 | 	 }
 | 
        
           | 18 | aurelien | 465 |   | 
        
           |  |  | 466 | 	/**
 | 
        
           |  |  | 467 | 	 * Recherche les enregistrements correspondants au criètres donnés et renvoie une liste d'identifiants, correspondants
 | 
        
           |  |  | 468 | 	 * @param int $id_annuaire l'identifiant de l'annuaire dans lequel on recherche
 | 
        
           |  |  | 469 | 	 * @valeurs array un talbeau de valeurs à rechercher
 | 
        
           |  |  | 470 | 	 * $exclusive boolean indique si la recherche doit se faire avec un ET ou bien un OU sur les critèrex
 | 
        
           |  |  | 471 | 	 */
 | 
        
           |  |  | 472 | 	 public function rechercherDansValeurMetadonnees($id_annuaire, $valeurs, $exclusive = true) {
 | 
        
           |  |  | 473 |   | 
        
           |  |  | 474 | 		// Définition du séparateur de requête suivant la paramètre
 | 
        
           |  |  | 475 | 		if($exclusive) {
 | 
        
           |  |  | 476 | 			$separateur = ' AND ';
 | 
        
           |  |  | 477 | 		} else {
 | 
        
           |  |  | 478 | 			$separateur = ' OR ';
 | 
        
           |  |  | 479 | 		}
 | 
        
           |  |  | 480 |   | 
        
           | 313 | aurelien | 481 | 		$chaine_recherche = '' ;
 | 
        
           | 18 | aurelien | 482 |   | 
        
           | 313 | aurelien | 483 | 	 	if(!$exclusive) {
 | 
        
           | 18 | aurelien | 484 |   | 
        
           | 313 | aurelien | 485 | 			foreach($valeurs as $nom_champ => $valeur) {
 | 
        
           |  |  | 486 |   | 
        
           |  |  | 487 | 				if(is_array($valeur)) {
 | 
        
           |  |  | 488 | 					foreach($valeur as $cle => $valeur_multi_meta) {
 | 
        
           |  |  | 489 | 						$chaine_recherche .= '(amv_ce_colonne = '.$this->proteger($nom_champ).' AND amv_valeur LIKE '.$this->proteger('%'.$cle.'%').')'.$separateur;
 | 
        
           |  |  | 490 | 					}
 | 
        
           |  |  | 491 | 				} else {
 | 
        
           |  |  | 492 | 					if(trim($valeur) != '') {
 | 
        
           |  |  | 493 | 						$chaine_recherche .= '(amv_ce_colonne = '.$this->proteger($nom_champ).' AND amv_valeur = '.$this->proteger($valeur).')'.$separateur;
 | 
        
           |  |  | 494 | 					}
 | 
        
           | 18 | aurelien | 495 | 				}
 | 
        
           | 313 | aurelien | 496 | 			}
 | 
        
           |  |  | 497 | 		} else {
 | 
        
           |  |  | 498 | 			foreach($valeurs as $nom_champ => $valeur) {
 | 
        
           |  |  | 499 |   | 
        
           |  |  | 500 | 				if(is_array($valeur)) {
 | 
        
           |  |  | 501 | 					foreach($valeur as $cle => $valeur_multi_meta) {
 | 
        
           |  |  | 502 | 						$chaine_recherche .= ' amv_cle_ligne IN (SELECT amv_cle_ligne FROM annu_meta_valeurs WHERE amv_ce_colonne = '.$this->proteger($nom_champ).' AND amv_valeur LIKE '.$this->proteger('%'.$cle.'%').')'.$separateur;
 | 
        
           |  |  | 503 | 					}
 | 
        
           |  |  | 504 | 				} else {
 | 
        
           |  |  | 505 | 					if(trim($valeur) != '') {
 | 
        
           |  |  | 506 | 						$chaine_recherche .= ' amv_cle_ligne IN (SELECT amv_cle_ligne FROM annu_meta_valeurs WHERE amv_ce_colonne = '.$this->proteger($nom_champ).' AND amv_valeur = '.$this->proteger($valeur).')'.$separateur;
 | 
        
           |  |  | 507 | 					}
 | 
        
           | 18 | aurelien | 508 | 				}
 | 
        
           | 313 | aurelien | 509 |  			}
 | 
        
           | 18 | aurelien | 510 | 		}
 | 
        
           |  |  | 511 |   | 
        
           |  |  | 512 | 		if(trim($chaine_recherche) == '') {
 | 
        
           |  |  | 513 | 			return array();
 | 
        
           |  |  | 514 | 		}
 | 
        
           |  |  | 515 |   | 
        
           |  |  | 516 | 		$chaine_recherche = rtrim($chaine_recherche,$separateur);
 | 
        
           |  |  | 517 |   | 
        
           |  |  | 518 | 	 	$requete_recherche = 'SELECT DISTINCT amv_cle_ligne '.
 | 
        
           |  |  | 519 | 							'FROM annu_meta_valeurs '.
 | 
        
           |  |  | 520 | 							'WHERE '.$chaine_recherche ;
 | 
        
           | 313 | aurelien | 521 |   | 
        
           | 18 | aurelien | 522 | 		$resultat_recherche = $this->requeteTous($requete_recherche);
 | 
        
           |  |  | 523 |   | 
        
           |  |  | 524 | 		if($resultat_recherche) {
 | 
        
           |  |  | 525 |   | 
        
           |  |  | 526 | 			$tableau_id = array();
 | 
        
           |  |  | 527 | 			foreach($resultat_recherche as $resultat) {
 | 
        
           |  |  | 528 | 				$tableau_id[] = $resultat['amv_cle_ligne'];
 | 
        
           |  |  | 529 | 			}
 | 
        
           |  |  | 530 | 			return $tableau_id;
 | 
        
           |  |  | 531 |   | 
        
           |  |  | 532 | 		} else {
 | 
        
           |  |  | 533 | 			return array();
 | 
        
           |  |  | 534 | 		}
 | 
        
           |  |  | 535 | 	 }
 | 
        
           | 55 | aurelien | 536 |   | 
        
           |  |  | 537 | 	 /**
 | 
        
           |  |  | 538 | 	  * Renvoie les valeur d'une méta colonne pour un identifiant d'enregistrement lié et de meta colonne donnés
 | 
        
           |  |  | 539 | 	  * @param int $id_champ l'identifiant de champ
 | 
        
           |  |  | 540 | 	  * @param int $id_utilisateur l'identifiant de ligne à laquelle est associée la metadonnée
 | 
        
           |  |  | 541 | 	  * @return array un tableau d'informations contenant les données
 | 
        
           |  |  | 542 | 	  */
 | 
        
           |  |  | 543 | 	  public function obtenirValeurMetadonnee($id_champ, $id_enregistrement_lie) {
 | 
        
           |  |  | 544 |   | 
        
           |  |  | 545 | 	  	$requete_valeur_metadonnee = 'SELECT * FROM annu_meta_valeurs'.
 | 
        
           |  |  | 546 | 	  								' WHERE amv_ce_colonne = '.$this->proteger($id_champ).
 | 
        
           |  |  | 547 | 	  								' AND amv_cle_ligne = '.$this->proteger($id_enregistrement_lie);
 | 
        
           |  |  | 548 |   | 
        
           |  |  | 549 | 	  	$resultat_valeur_metadonnee = $this->requeteTous($requete_valeur_metadonnee);
 | 
        
           |  |  | 550 |   | 
        
           |  |  | 551 | 	  	if($resultat_valeur_metadonnee) {
 | 
        
           |  |  | 552 | 	  		return $resultat_valeur_metadonnee;
 | 
        
           |  |  | 553 | 	  	} else {
 | 
        
           |  |  | 554 |   | 
        
           |  |  | 555 | 	  		return false;
 | 
        
           |  |  | 556 | 	  	}
 | 
        
           |  |  | 557 |   | 
        
           |  |  | 558 | 	  }
 | 
        
           | 59 | aurelien | 559 |   | 
        
           | 82 | aurelien | 560 | 	  /** Suivant un identifiant de champ, renvoie un tableau contenant le nombre d'enregistrement pour chaque valeur
 | 
        
           | 59 | aurelien | 561 | 	  * @param int $id_champ l'identifiant de champ
 | 
        
           |  |  | 562 | 	  * @return array un tableau d'informations contenant les données
 | 
        
           |  |  | 563 | 	  */
 | 
        
           |  |  | 564 | 	  public function obtenirNombreValeurMetadonnee($id_champ) {
 | 
        
           |  |  | 565 |   | 
        
           |  |  | 566 | 	  	$requete_valeurs_liste = 'SELECT amo_nom, amo_abreviation FROM annu_meta_ontologie '.
 | 
        
           |  |  | 567 | 	  							'WHERE amo_ce_parent = '.$this->proteger($id_champ);
 | 
        
           |  |  | 568 |   | 
        
           |  |  | 569 | 	  	$requete_valeur_metadonnee = 'SELECT COUNT(*) as nb, amv_valeur FROM annu_meta_valeurs'.
 | 
        
           |  |  | 570 | 	  								' WHERE amv_ce_colonne = '.$id_champ.' '.
 | 
        
           |  |  | 571 | 	  								' GROUP BY amv_valeur '.
 | 
        
           |  |  | 572 | 									' ORDER BY nb DESC';
 | 
        
           |  |  | 573 |   | 
        
           |  |  | 574 | 	  	$resultat_valeur_metadonnee = $this->requeteTous($requete_valeur_metadonnee);
 | 
        
           |  |  | 575 |   | 
        
           |  |  | 576 | 	  	if($resultat_valeur_metadonnee) {
 | 
        
           |  |  | 577 | 	  		return $resultat_valeur_metadonnee;
 | 
        
           |  |  | 578 | 	  	} else {
 | 
        
           |  |  | 579 |   | 
        
           |  |  | 580 | 	  		return false;
 | 
        
           |  |  | 581 | 	  	}
 | 
        
           |  |  | 582 |   | 
        
           |  |  | 583 | 	  }
 | 
        
           | 245 | aurelien | 584 |   | 
        
           |  |  | 585 | 	  public function obtenirOntologieLieeAChampParId($id_champ) {
 | 
        
           |  |  | 586 |   | 
        
           |  |  | 587 | 	  	$requete_id_ontologie_liee = 'SELECT amc_ce_ontologie FROM annu_meta_colonne '.
 | 
        
           |  |  | 588 | 	  							'WHERE amc_id_champ = '.$this->proteger($id_champ);
 | 
        
           |  |  | 589 |   | 
        
           |  |  | 590 | 	  	$resultat_id_ontologie_liee = $this->requeteUn($requete_id_ontologie_liee);
 | 
        
           |  |  | 591 |   | 
        
           |  |  | 592 | 	  	if($resultat_id_ontologie_liee) {
 | 
        
           |  |  | 593 | 	  		return $resultat_id_ontologie_liee['amc_ce_ontologie'];
 | 
        
           |  |  | 594 | 	  	} else {
 | 
        
           |  |  | 595 | 	  		return 0;
 | 
        
           |  |  | 596 | 	  	}
 | 
        
           |  |  | 597 | 	  }
 | 
        
           | 4 | aurelien | 598 | }
 | 
        
           |  |  | 599 | ?>
 |