Subversion Repositories Applications.annuaire

Rev

Rev 11 | Rev 34 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
4 aurelien 1 
<?php
2 
/**
3 
* PHP Version 5
4 
*
5 
* @category  PHP
6 
* @package   annuaire
7 
* @author    aurelien <aurelien@tela-botanica.org>
8 
* @copyright 2010 Tela-Botanica
9 
* @license   http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt Licence CECILL
10 
* @version   SVN: <svn_id>
11 
* @link      /doc/annuaire/
12 
*/
13 
 
14 
class AnnuaireControleur extends Controleur {
15 
 
7 aurelien 16 
 
4 aurelien 17 
	/**
18 
	 * (fonction héritée de la classe Controleur)
19 
	 * Avant chaque chargement de vue, on ajoute l'url de la page dans
20 
	 * les variables à insérer.
21 
	 * @param Array $donnes les données à insérer dans la vue
22 
	 * @return Array $donnees les données modifiées
23 
	 */
24 
	public function preTraiterDonnees($donnees) {
25 
		$donnees['base_url'] = Registre::getInstance()->get('base_url_application');
26 
		return $donnees;
27 
	}
28 
 
29 
	/**
30 
	 * Fonction affichant la vue par défaut, ici le menu principal
31 
	 * @return String la vue contenant le menu
32 
	 */
33 
	public function index() {
34 
		$data = array();
7 aurelien 35 
		$index_annuaire = $this->getVue('index_annuaire', $data);
4 aurelien 36 
 
7 aurelien 37 
		return $index_annuaire;
4 aurelien 38 
	}
39 
 
40 
/**-------- Fonctions de gestion des annuaires --------------------------------*/
41 
 
42 
	/**
43 
	 * Charge la vue contenant la liste des annuaires gérés par l'application
44 
	 * @return string la vue contenant la liste des annuaires
45 
	 */
46 
	public function chargerListeAnnuaire() {
47 
		$this->chargerModele('AnnuaireModele');
48 
		$data['erreurs'] = null;
49 
		$data['annuaires'] = $this->AnnuaireModele->chargerListeAnnuaire();
11 aurelien 50 
		$liste_annu = $this->getVue(Config::get('dossier_squelettes_annuaires').'liste_annu', $data);
4 aurelien 51 
 
7 aurelien 52 
		return $liste_annu;
4 aurelien 53 
	}
54 
 
55 
	/**
56 
	 * Charge la vue contenant les informations d'un annuaire donné en paramètre
57 
	 * @param int $id l'identifiant de l'annuaire
58 
	 * @return string la vue contenant les informations sur l'annuaire
59 
	 */
60 
	public function chargerAnnuaire($id) {
61 
		$this->chargerModele('AnnuaireModele');
62 
		$this->chargerModele('MetadonneeModele');
63 
		$data['erreurs'] = array();
64 
		$data['annuaire'] = $this->AnnuaireModele->chargerAnnuaire($id, true);
65 
		$data['metadonnees'] = $this->MetadonneeModele->chargerListeMetadonneeAnnuaire($id);
11 aurelien 66 
		$annuaire = $this->getVue(Config::get('dossier_squelettes_annuaires').'annuaire', $data);
4 aurelien 67 
 
7 aurelien 68 
		return $annuaire;
4 aurelien 69 
	}
70 
 
71 
	/**
72 
	 * Charge et affiche la liste des inscrits à un annuaire donné en paramètre
73 
	 * @param $id int l'identifiant de l'annuaire
74 
	 * @return string la vue contenant les inscrits à l'annuaire
75 
	 */
7 aurelien 76 
	public function chargerAnnuaireListeInscrits($id, $numero_page = 1, $taille_page = 50) {
4 aurelien 77 
 
78 
		$this->chargerModele('AnnuaireModele');
79 
		$data['erreurs'] = array();
7 aurelien 80 
		$data['champs'] = $this->obtenirChampsMappageAnnuaire($id);
11 aurelien 81 
		$total_inscrits = $this->AnnuaireModele->chargerNombreAnnuaireListeInscrits($id);
7 aurelien 82 
		$data['annuaire'] = $this->AnnuaireModele->chargerAnnuaireListeInscrits($id, $data['champs'][0], $numero_page, $taille_page);
4 aurelien 83 
 
19 aurelien 84 
		$url_pagination = new URL(Registre::getInstance()->get('base_url_application'));
85 
		$url_pagination->setVariableRequete('m','annuaire_inscrits');
86 
		$url_pagination->setVariableRequete('id_annuaire',$id);
7 aurelien 87 
 
19 aurelien 88 
		$data['pagination'] = $this->paginer($numero_page,$taille_page,$total_inscrits,$url_pagination);
11 aurelien 89 
 
90 
		$annuaires_inscrits = $this->getVue(Config::get('dossier_squelettes_annuaires').'annuaire_inscrits', $data);
91 
 
7 aurelien 92 
		return $annuaires_inscrits;
4 aurelien 93 
	}
94 
 
95 
/**-------- Fonctions d'affichage du formulaire de saisie d'un champ de metadonnée suivant le type de champ---------*/
96 
 
97 
	/**
98 
	 * Affiche le formulaire d'inscription pour un annuaire donné
99 
	 * @param int $id_annuaire l'identifiant de l'annuaire pour lequel on veut afficher le formulaire
100 
	 * @param Array $donnees le tableau de données pour préremplir le formulaire si besoin (en cas de retour erreur)
101 
	 */
102 
	public function afficherFormulaireInscription($id_annuaire, $donnees=array()) {
103 
 
104 
		$this->chargerModele('AnnuaireModele');
105 
		$annuaire = $this->AnnuaireModele->chargerAnnuaire($id_annuaire, false);
106 
 
107 
		$this->chargerModele('MetadonneeModele');
108 
		$donnees['aa_id_annuaire'] = $id_annuaire;
11 aurelien 109 
 
4 aurelien 110 
		$metadonnees = $this->MetadonneeModele->chargerListeMetadonneeAnnuaire($id_annuaire);
111 
 
112 
		// TODO: ceci charge toutes les métadonnées, voir si l'on ne peut pas parser le formulaire
113 
		// pour ne charger que ce qui est nécéssaire
114 
		foreach($metadonnees as $metadonnee) {
115 
 
116 
			$id_champ = $metadonnee['amc_id_champ'];
117 
			$nom_champ = $metadonnee['amc_abreviation'];
11 aurelien 118 
 
119 
			$metadonnee['aa_id_annuaire'] = $id_annuaire;
4 aurelien 120 
			// on charge le formaulaire d'affichage de chacune des métadonnées
121 
			$donnees['champs'][$nom_champ] = $this->afficherFormulaireChampMetadonnees($id_champ,$metadonnee);
122 
		}
123 
 
19 aurelien 124 
		// si le formulaire existe, on le charge
125 
		if(!$this->formulaireExiste($annuaire['informations']['aa_code'],'inscription')) {
7 aurelien 126 
			$formulaire_inscription = $this->genererFormulaireInscription($donnees);
127 
		} else {
19 aurelien 128 
			// sinon on en génère un qui contient tous les champs
11 aurelien 129 
			$formulaire_inscription = $this->GetVue(Config::get('dossier_squelettes_formulaires').$annuaire['informations']['aa_code'].'_inscription',$donnees);
7 aurelien 130 
		}
4 aurelien 131 
 
7 aurelien 132 
		return $formulaire_inscription;
4 aurelien 133 
	}
134 
 
135 
	/**
136 
	 * Charge et affiche le champ correspondant à la modification ou l'ajout d'un champ de metadonnée
137 
	 * @param int $id_champ l'identifiant du champ demandé
138 
	 * @return string la vue contenant le champ de formulaire correspondant
139 
	 */
140 
	public function afficherFormulaireChampMetadonnees($id_champ, $donnees=array()) {
141 
 
142 
		// si le champ est restreint à une valeur de liste
143 
		if($donnees['amc_ce_ontologie'] != 0) {
144 
				$this->chargerModele('OntologieModele');
145 
				$donnees['liste_valeurs'] = $this->OntologieModele->chargerListeOntologie($donnees['amc_ce_ontologie']);
146 
		}
19 aurelien 147 
 
4 aurelien 148 
		$donnees['amc_id_champ'] = $id_champ;
149 
		$this->chargerModele('MetadonneeModele');
19 aurelien 150 
		$nom__type_champ = $this->MetadonneeModele->renvoyerTypeAffichageParId($donnees['amc_ce_type_affichage']);
11 aurelien 151 
		return $this->getVue(Config::get('dossier_squelettes_champs').$nom__type_champ,$donnees);
4 aurelien 152 
	}
153 
 
154 
/**-------- Fonctions d'inscription -------------------------------------------------------------------------------*/
155 
 
156 
	/**
7 aurelien 157 
	 * Lors d'une tentative d'inscription, ajoute les infos dans la table d'inscription
4 aurelien 158 
	 * temporaire et envoie le mail contenant le lien de confirmation si tout s'est bien passé
159 
	 * @param Array $valeurs les valeurs à ajouter
160 
	 * @return string la vue contenant la confirmation de l'inscription
161 
	 */
162 
	public function ajouterInscriptionTemporaire($valeurs) {
163 
 
164 
		$this->chargerModele('MetadonneeModele');
165 
		$id_annuaire = $valeurs['aa_id_annuaire'];
7 aurelien 166 
		unset($valeurs['aa_id_annuaire']);
4 aurelien 167 
 
168 
		$tableau_mappage = $this->obtenirChampsMappageAnnuaire($id_annuaire);
169 
		$valeurs_mappees = array();
170 
 
19 aurelien 171 
		$verificateur = new VerificationControleur();
172 
 
4 aurelien 173 
		// on itère sur le tableau de valeur pour récupérer les champs de mappage;
174 
		foreach($valeurs as $nom_champ => $valeur) {
7 aurelien 175 
 
4 aurelien 176 
			// pour chaque valeur
177 
			// on extrait l'id du champ
7 aurelien 178 
			$ids_champ = mb_split("_",$nom_champ, 3);
4 aurelien 179 
 
7 aurelien 180 
			if(count($ids_champ) == 3) {
181 
 
182 
				$type = $ids_champ[0];
183 
				$id_champ = $ids_champ[2];
19 aurelien 184 
				$condition = $ids_champ[1];
7 aurelien 185 
 
19 aurelien 186 
				// cas de la checkbox qui devrait être là mais pas cochée
187 
				if($condition == 'hidden' && !isset($valeurs[$type.'_'.$id_champ])) {
188 
					// dans ce cas là on fabrique une valeur vide
189 
					$valeurs[$type.'_'.$id_champ] = 0;
190 
				}
191 
 
7 aurelien 192 
			} else {
193 
				$type = $ids_champ[0];
19 aurelien 194 
				$condition = false;
7 aurelien 195 
				$id_champ = $ids_champ[1];
196 
			}
197 
 
4 aurelien 198 
			// Si le champ fait partie des champs mappés
199 
			$cle_champ = array_search($id_champ, $tableau_mappage[1]);
200 
 
201 
			if($cle_champ) {
202 
				// on ajoute sa clé correspondante dans le tableau des champs mappés
203 
				// qui sont les champs à vérifier
19 aurelien 204 
				if($condition) {
205 
					$valeurs_mappees[$cle_champ.$condition] = $valeur;
11 aurelien 206 
				} else {
207 
					$valeurs_mappees[$cle_champ] = $valeur;
208 
				}
4 aurelien 209 
			}
210 
		}
211 
 
212 
		// vérification des champs minimaux : nom, prénom, mail, mot de passe
213 
		// TODO: des champs minimaux différents pour chaque annuaire ? comment les stocke t'on ?
19 aurelien 214 
		if($erreurs = $verificateur->verifierErreursChamps($id_annuaire,$valeurs_mappees, $tableau_mappage)) {
4 aurelien 215 
			$valeurs['erreurs'] = $erreurs;
216 
			return $this->afficherFormulaireInscription($id_annuaire, $valeurs);
7 aurelien 217 
		}
4 aurelien 218 
 
19 aurelien 219 
		$valeurs['aa_id_annuaire'] = $id_annuaire ;
220 
 
7 aurelien 221 
		$code_confirmation = $this->InsererDansTableTemporaireEtCreerCodeConfirmationInscription($valeurs);
4 aurelien 222 
 
223 
		$this->envoyerMailConfirmationInscription($valeurs_mappees['champ_mail'],
224 
													$valeurs_mappees['champ_nom'],
225 
													$valeurs_mappees['champ_prenom'],
226 
													$code_confirmation);
227 
		// Si tout s'est bien passé, on affiche la page de confirmation
11 aurelien 228 
		return $this->getVue(Config::get('dossier_squelettes_annuaires').'annuaire_inscription_reussie',array());
4 aurelien 229 
	}
230 
 
231 
	/**
232 
	 * Ajoute une nouvelle inscription à un annuaire à partir de données d'une table temporaire.
233 
	 * Typiquement, on déclenche cette fonction en cliquant sur le lien contenu dans le mail de confirmation
234 
	 * @param int $indentifant L'identifant de session d'une tentative d'inscription
235 
	 */
236 
	public function ajouterNouvelleInscription($identifiant) {
237 
 
238 
		$this->chargerModele('AnnuaireModele');
239 
 
240 
		$valeurs = $this->AnnuaireModele->chargerDonneesInscriptionTemporaire($identifiant);
241 
 
242 
		if(!$valeurs || count($valeurs) == 0) {
243 
			// TODO afficher vue en cas d'echec
244 
		}
245 
 
19 aurelien 246 
		$id_annuaire = $valeurs['aa_id_annuaire'];
4 aurelien 247 
		unset($valeurs['aa_id_annuaire']);
248 
 
249 
		$this->chargerModele('MetadonneeModele');
7 aurelien 250 
 
19 aurelien 251 
		$verificateur = new VerificationControleur();
252 
 
4 aurelien 253 
		$tableau_mappage = $this->obtenirChampsMappageAnnuaire($id_annuaire);
254 
 
255 
		$valeurs_mappees = array();
256 
 
19 aurelien 257 
		$mail_nouvel_inscrit = $valeurs['text_'.$tableau_mappage[1]['champ_mail']];
258 
 
4 aurelien 259 
		// on itère sur le tableau de valeur pour récupérer les métadonnées;
260 
		foreach($valeurs as $nom_champ => $valeur) {
11 aurelien 261 
 
4 aurelien 262 
			// pour chaque valeur
263 
			// on extrait l'id du champ
19 aurelien 264 
			$ids_champ = mb_split("_",$nom_champ, 3);
4 aurelien 265 
 
19 aurelien 266 
			if(count($ids_champ) == 3) {
267 
 
268 
				$type = $ids_champ[0];
269 
				$id_champ = $ids_champ[2];
270 
				$condition = $ids_champ[1];
271 
 
272 
				// cas de la checkbox qui devrait être là mais pas cochée
273 
				if($condition == 'hidden' && !isset($valeurs[$type.'_'.$id_champ])) {
274 
					// dans ce cas là on fabrique une valeur vide
275 
					$valeurs[$type.'_'.$id_champ] = 0;
276 
				}
277 
 
278 
			} else {
279 
				$type = $ids_champ[0];
280 
				$condition = false;
281 
				$id_champ = $ids_champ[1];
282 
			}
283 
 
284 
 
285 
			// on fait des vérifications et des remplacements sur certaines valeurs
286 
			$valeurs[$nom_champ] = $verificateur->remplacerValeurChampPourInsertion($type,$valeur,$mail_nouvel_inscrit);
287 
 
4 aurelien 288 
			// Si le champ fait partie des champs mappés
289 
			$cle_champ = array_search($id_champ, $tableau_mappage[1]);
290 
			if($cle_champ) {
291 
				// on ajoute sa clé correspondante dans l'annuaire mappé et sa valeur dans le tableau des champs mappés
292 
				$valeurs_mappees[$tableau_mappage[0][$cle_champ]] = $valeur;
293 
				// et on supprime sa valeur du tableau de valeurs pour ne pas la retrouver lors
11 aurelien 294 
				// de l'insertion des métadonnées
4 aurelien 295 
				unset($valeurs[$nom_champ]);
296 
			}
297 
		}
298 
 
299 
		// obtenir l'id du nouvel arrivant en faisant un select sur le mail qui doit être unique
300 
		$id_nouvel_inscrit = $this->ajouterNouvelleInscriptionDansAnnuaireMappe($id_annuaire,$valeurs_mappees, $tableau_mappage[0]);
301 
 
19 aurelien 302 
		// les champs de metadonnees arrivent avec un identifiant sous la forme type_condition_id
4 aurelien 303 
		foreach($valeurs as $nom_champ => $valeur) {
304 
 
19 aurelien 305 
			// pour chaque valeur
306 
			// on extrait l'id du champ
4 aurelien 307 
			$ids_champ = mb_split("_",$nom_champ);
308 
			$id_champ = $ids_champ[count($ids_champ) - 1];
309 
 
310 
			// Si l'insertion dans la base a réussi
311 
			if($this->MetadonneeModele->ajouterNouvelleValeurMetadonnee($id_champ,$id_nouvel_inscrit,$valeur)) {
312 
				// on continue
313 
			} else {
314 
 
315 
				// Si une des insertions échoue, on supprime les méta valeurs déjà entrées.
316 
				$this->MetadonneeModele->supprimerValeursMetadonneesParIdEnregistrementLie($id_nouvel_inscrit);
317 
				return false;
318 
			}
319 
		}
320 
 
321 
		//TODO: gérer le cas de spip et de wikini par un multimapping des champs
322 
		//TODO: voir openid
323 
 
324 
		// Si tout a réussi on supprime les données d'inscription temporaire
325 
		$this->AnnuaireModele->supprimerDonneesInscriptionTemporaire($identifiant);
326 
 
19 aurelien 327 
		$annuaire = $this->AnnuaireModele->chargerAnnuaire($id_annuaire, false);
328 
 
329 
		// S'il existe une page d'accueil spécifique à l'annuaire pour la confirmation d'inscription
330 
		if($this->templateExiste($annuaire['informations']['aa_code'].'_inscription_confirmation', Config::get('dossier_squelettes_annuaires'))) {
331 
			// on l'affiche
332 
			$donnees = array('id_utilisateur' => $id_nouvel_inscrit, 'id_annuaire' => $id_annuaire);
333 
			return $this->getVue(Config::get('dossier_squelettes_annuaires').$annuaire['informations']['aa_code'].'_inscription_confirmation', $donnees);
334 
 
335 
		} else {
336 
			// sinon on le redirige
337 
			return $this->afficherFicheUtilisateur($id_annuaire, $id_nouvel_inscrit);
338 
		}
4 aurelien 339 
	}
340 
 
341 
	/**
342 
	 * Ajoute un nouvel inscrit dans l'annuaire mappé donné en paramètre.
343 
	 * En cas de succès, renvoie l'identifiant du nouvel inscrit qui sera
344 
	 * utilisé pour insérer les métadonnées liées
345 
	 *
346 
	 * @param int $id_annuaire identifiant de l'annuaire auquel sera lié le nouvel inscrit
347 
	 * @param Array $valeurs_mappees Tableau contenant les valeurs à insérer et ayant comme clés des noms de colonnes
348 
	 * @param Array $noms_champs Tableau contenant les noms des champs à insérer
349 
	 * @return int l'identifiant unique du nouvel inscrit
350 
	 */
351 
	public function ajouterNouvelleInscriptionDansAnnuaireMappe($id_annuaire,$valeurs_mappees, $noms_champs) {
352 
 
353 
		$this->chargerModele('AnnuaireModele');
19 aurelien 354 
		$resultat = $this->AnnuaireModele->ajouterInscriptionDansAnnuaireMappe($id_annuaire, $valeurs_mappees, $noms_champs);
4 aurelien 355 
 
356 
		return $resultat;
357 
	}
358 
 
359 
	/**
360 
	 * Affiche la fiche principale d'un utilisateur
361 
	 * @param int $id_annuaire l'identifiant de l'annuaire
362 
	 * @param int $id_utilisateur l'identifiant de l'utilisateur
363 
	 * @return string la vue contenant la fiche utilisateur
364 
	 */
365 
	public function afficherFicheUtilisateur($id_annuaire, $id_utilisateur) {
366 
 
367 
		$this->chargerModele('AnnuaireModele');
368 
		$tableau_mappage = $this->obtenirChampsMappageAnnuaire($id_annuaire);
369 
		$tableau_valeurs = $this->AnnuaireModele->obtenirValeursUtilisateur($id_annuaire, $id_utilisateur,$tableau_mappage[0]);
370 
 
19 aurelien 371 
		$this->chargerModele('MetadonneeModele');
372 
		$champs_metadonnees= $this->MetadonneeModele->chargerListeValeursMetadonneesUtilisateur($id_annuaire, $id_utilisateur);
373 
 
374 
		$verificateur = new VerificationControleur();
375 
 
376 
		// on vérifie s'il existe un type d'affichage particulier pour les colonnes de l'annuaire mappé
5 aurelien 377 
		foreach($tableau_mappage[0] as $cle => $nom_champ) {
19 aurelien 378 
 
5 aurelien 379 
			$valeur = $tableau_valeurs[$nom_champ] ;
19 aurelien 380 
			if(isset($tableau_mappage[1][$cle])) {
381 
 
382 
				$tableau_valeurs[$cle] = array('amv_valeur' => $valeur,'amc_id_champ' => $tableau_mappage[1][$cle]);
383 
				$type_affichage = $this->MetadonneeModele->renvoyerTypeAffichagePourColonne($tableau_mappage[1][$cle]);
384 
				if($type_affichage) {
385 
					$tableau_valeurs[$cle]['amc_ce_type_affichage'] = $type_affichage;
386 
				}
387 
 
388 
			} else {
389 
				$tableau_valeurs[$cle] = $valeur;
390 
			}
5 aurelien 391 
			unset($tableau_valeurs[$nom_champ]);
392 
		}
393 
 
11 aurelien 394 
		$donnees['id_annuaire'] = $id_annuaire;
19 aurelien 395 
		$donnees['id_utilisateur'] = $id_utilisateur;
396 
		$champs =  array_merge($tableau_valeurs, $champs_metadonnees);
4 aurelien 397 
 
19 aurelien 398 
		foreach($champs as $cle => $champ) {
399 
 
400 
			if(is_array($champ) && isset($champ['amc_ce_type_affichage'])) {
401 
				$type = $champ['amc_ce_type_affichage'];
402 
			} else {
403 
				$type = false;
404 
			}
405 
			$champs[$cle] = $verificateur->verifierEtRemplacerValeurChampPourAffichage($type,$champ ,$id_annuaire);
406 
		}
407 
 
408 
		$donnees['champs'] = $champs;
409 
 
11 aurelien 410 
		$annuaire_inscrits = $this->getVue(Config::get('dossier_squelettes_fiches').'annuaire_tela_inscrits_fiche',$donnees);
7 aurelien 411 
 
412 
		return $annuaire_inscrits;
4 aurelien 413 
	}
414 
 
19 aurelien 415 
	public function afficherFormulaireModificationInscription($id_annuaire, $id_utilisateur, $erreurs = false) {
4 aurelien 416 
 
19 aurelien 417 
		$this->chargerModele('AnnuaireModele');
418 
		$annuaire = $this->AnnuaireModele->chargerAnnuaire($id_annuaire, false);
4 aurelien 419 
 
19 aurelien 420 
		$this->chargerModele('MetadonneeModele');
421 
		$donnees['aa_id_annuaire'] = $id_annuaire;
4 aurelien 422 
 
19 aurelien 423 
		$metadonnees = $this->MetadonneeModele->chargerListeMetadonneeAnnuaire($id_annuaire);
424 
		$tableau_mappage = $this->obtenirChampsMappageAnnuaire($id_annuaire);
4 aurelien 425 
 
19 aurelien 426 
		$valeurs_annuaire = $this->AnnuaireModele->obtenirValeursUtilisateur($id_annuaire, $id_utilisateur,$tableau_mappage[0]);
427 
		$valeurs_metadonnees= $this->MetadonneeModele->chargerListeValeursMetadonneesUtilisateur($id_annuaire, $id_utilisateur);
4 aurelien 428 
 
19 aurelien 429 
		foreach($tableau_mappage[0] as $cle => $nom_champ) {
430 
			$valeur = $valeurs_annuaire[$nom_champ] ;
431 
			if($cle != 'champ_id') {
432 
				$valeurs_metadonnees[$metadonnees[$tableau_mappage[1][$cle]]['amc_abreviation']] = array('amv_valeur' => $valeur,'amc_id_champ' => $tableau_mappage[1][$cle]) ;
433 
			}
434 
		}
7 aurelien 435 
 
19 aurelien 436 
		// TODO: ceci charge toutes les métadonnées, voir si l'on ne peut pas parser le formulaire
437 
		// pour ne charger que ce qui est nécéssaire
438 
		foreach($metadonnees as $metadonnee) {
439 
 
440 
			$id_champ = $metadonnee['amc_id_champ'];
441 
			$nom_champ = $metadonnee['amc_abreviation'];
442 
 
443 
			if(isset($valeurs_metadonnees[$nom_champ])) {
444 
				$metadonnee['valeur_defaut'] = $valeurs_metadonnees[$nom_champ];
445 
			}
446 
 
447 
			$metadonnee['aa_id_annuaire'] = $id_annuaire;
448 
			// on charge le formulaire d'affichage de chacune des métadonnées
449 
			$donnees['champs'][$nom_champ] = $this->afficherFormulaireChampMetadonnees($id_champ,$metadonnee);
450 
 
451 
		}
452 
 
453 
		$donnees['id_utilisateur'] = $id_utilisateur;
454 
 
455 
		// le nom du formulaire d'inscription est le même que le code de l'annuaire du genre code_annuaire_inscription
456 
		if(!$this->formulaireExiste($annuaire['informations']['aa_code'])) {
457 
			$formulaire_inscription = $this->genererFormulaireInscription($donnees);
458 
		} else {
459 
			$formulaire_inscription = $this->GetVue(Config::get('dossier_squelettes_formulaires').$annuaire['informations']['aa_code'].'_modification',$donnees);
460 
		}
461 
 
462 
		return $formulaire_inscription;
463 
 
4 aurelien 464 
	}
465 
 
19 aurelien 466 
	public function modifierInscription($valeurs) {
11 aurelien 467 
 
19 aurelien 468 
		$this->chargerModele('MetadonneeModele');
4 aurelien 469 
 
19 aurelien 470 
		$id_utilisateur = $valeurs['id_utilisateur'];
471 
		unset($valeurs['id_utilisateur']);
472 
 
473 
		$id_annuaire = $valeurs['aa_id_annuaire'];
474 
		unset($valeurs['aa_id_annuaire']);
475 
 
476 
		$this->chargerModele('MetadonneeModele');
477 
 
478 
		$verificateur = new VerificationControleur();
479 
 
480 
		$erreurs = $verificateur->verifierErreurChampModification($id_annuaire, $id_utilisateur);
481 
 
482 
		if(count($erreurs) > 0) {
483 
			return $this->afficherFormulaireModificationInscription($id_annuaire,$id_utilisateur,$erreurs);
484 
		}
485 
 
486 
		// TODO faire la fonction
487 
		$changement_mot_de_passe = $verificateur->verifierChangementMotDePasse($id_annuaire, $id_utilisateur, $valeurs);
488 
 
489 
		$tableau_mappage = $this->obtenirChampsMappageAnnuaire($id_annuaire);
490 
 
491 
		$valeurs_mappees = array();
492 
		$valeurs_metadonnees = array();
493 
 
494 
		// on itère sur le tableau de valeur pour récupérer les métadonnées;
495 
		foreach($valeurs as $nom_champ => $valeur) {
496 
 
497 
			// pour chaque valeur
498 
			// on extrait l'id du champ
499 
			$ids_champ = mb_split("_",$nom_champ);
500 
 
501 
			// l'identifiant du champ est la dernière valeur du tableau
502 
			if(count($ids_champ) == 3) {
503 
 
504 
				$type = $ids_champ[0];
505 
				$id_champ = $ids_champ[2];
506 
				$condition = $ids_champ[1];
507 
 
508 
			} else {
509 
				$type = $ids_champ[0];
510 
				$condition = false;
511 
				$id_champ = $ids_champ[1];
512 
			}
513 
 
514 
			// cas de la checkbox qui devrait être là mais pas cochée
515 
			if($condition == 'hidden') {
516 
 
517 
				if(!isset($valeurs[$type.'_'.$id_champ])) {
518 
					// dans ce cas là on fabrique une valeur qui vaut 0
519 
					$nom_champ = $type.'_'.$id_champ;
520 
					$valeur = '0';
521 
				} else {
522 
 
523 
					$nom_champ = $type.'_'.$id_champ;
524 
					$valeur = $valeurs[$type.'_'.$id_champ];
525 
					// on s'assure de ne pas itérer sur la valeur de checkbox
526 
					// qui sinon serait traitée deux fois
527 
					unset($valeurs[$type.'_'.$id_champ]);
528 
				}
529 
			}
530 
 
531 
			// Si le champ fait partie des champs mappés
532 
			$cle_champ = array_search($id_champ, $tableau_mappage[1]);
533 
			if($cle_champ) {
534 
				// on fait des vérifications et des remplacements sur certaines valeurs
535 
				$valeur = $verificateur->remplacerValeurChampPourModification($type,$valeur,$condition);
536 
 
537 
				// on ajoute sa clé correspondante dans l'annuaire mappé et sa valeur dans le tableau des champs mappés
538 
				$valeurs_mappees[$tableau_mappage[0][$cle_champ]] = $valeur;
539 
			} else {
540 
				$valeurs_metadonnees[$nom_champ] = $valeur;
541 
			}
542 
		}
543 
 
4 aurelien 544 
		$this->chargerModele('AnnuaireModele');
19 aurelien 545 
		$modification_annuaire = $this->AnnuaireModele->modifierInscriptionDansAnnuaireMappe($id_annuaire, $id_utilisateur ,$valeurs_mappees, $tableau_mappage[0]);
4 aurelien 546 
 
19 aurelien 547 
		// les champs de metadonnees arrivent avec un identifiant sous la forme type_xxx_id
548 
		foreach($valeurs_metadonnees as $nom_champ => $valeur) {
549 
 
550 
			// pour chaque valeur
551 
			// on extrait l'id du champ
552 
			$ids_champ = mb_split("_",$nom_champ);
553 
			$id_champ = $ids_champ[count($ids_champ) - 1];
554 
 
555 
			// l'identifiant du champ est la dernière valeur du tableau
556 
			if(count($ids_champ) == 3) {
557 
 
558 
				$type = $ids_champ[0];
559 
				$id_champ = $ids_champ[2];
560 
				$condition = $ids_champ[1];
561 
 
562 
			} else {
563 
				$type = $ids_champ[0];
564 
				$condition = false;
565 
				$id_champ = $ids_champ[1];
566 
			}
567 
 
568 
			// on fait des remplacements sur certaines valeurs
569 
			$valeur = $verificateur->remplacerValeurChampPourModification($type,$valeur,$condition, $id_utilisateur);
570 
 
571 
			// S'il existe déjà une valeur de metadonnée pour cette colonne et cet utilisateur
572 
			if($this->MetadonneeModele->valeurExiste($id_champ,$id_utilisateur)) {
573 
 
574 
				// On se contente de la modifier
575 
				// Ceci afin d'éviter de créer des lignes vides lors de la création d'un utilisateur
576 
				if($this->MetadonneeModele->modifierValeurMetadonnee($id_champ,$id_utilisateur,$valeur)) {
577 
 
578 
				} else {
579 
					return false;
580 
				}
581 
			} else {
582 
				// S'il n'existe pas de valeur, on ajoute une nouvelle ligne à la table de valeurs de meta données
583 
				if($this->MetadonneeModele->ajouterNouvelleValeurMetadonnee($id_champ,$id_utilisateur,$valeur)) {
584 
					// Si l'insertion a réussi, on continue
585 
				} else {
586 
					// TODO: lever exception
587 
					return false;
588 
				}
589 
			}
4 aurelien 590 
		}
591 
 
19 aurelien 592 
		return $this->afficherFicheUtilisateur($id_annuaire, $id_utilisateur);
4 aurelien 593 
	}
594 
 
19 aurelien 595 
	public function afficherFormulaireOubliMotDePasse($id_annuaire) {
5 aurelien 596 
 
19 aurelien 597 
		$donnees['aa_id_annuaire'] = $id_annuaire;
5 aurelien 598 
 
19 aurelien 599 
		return $this->getVue(Config::get('dossier_squelettes_formulaires').'oubli_mdp',$donnees);
600 
	}
4 aurelien 601 
 
19 aurelien 602 
	public function reinitialiserMotDePasse($id_annuaire, $mail) {
4 aurelien 603 
 
19 aurelien 604 
		$this->chargerModele('AnnuaireModele');
605 
		$verificateur = new VerificationControleur('VerificationControleur');
4 aurelien 606 
 
19 aurelien 607 
		$donnees = array();
608 
		// en vérifiant directement si le mail est valide, on se dispense d'un appel à la base de données
609 
		// TODO: est-ce une bonne idée ?
610 
		if(!$verificateur->mailValide($mail) || !$this->AnnuaireModele->utilisateurExisteParMail($id_annuaire,$mail)) {
611 
			$donnees['erreurs']['mail'] = 'Cet utilisateur n\'existe pas';
612 
			$donnees['aa_id_annuaire'] = $id_annuaire;
613 
			return $this->getVue(Config::get('dossier_squelettes_formulaires').'oubli_mdp',$donnees);
614 
		}
4 aurelien 615 
 
19 aurelien 616 
		$nouveau_mdp = $this->AnnuaireModele->reinitialiserMotDePasse($id_annuaire, $mail);
617 
 
618 
		if(!$nouveau_mdp) {
619 
			$donnees['erreurs']['mdp'] = 'Impossible de générer un nouveau mot de passe';
620 
			$donnees['aa_id_annuaire'] = $id_annuaire;
621 
			return $this->getVue('oubli_mdp',$donnees);
622 
		}
623 
 
624 
		$donnees['nouveau_mdp'] = $nouveau_mdp;
625 
 
626 
		return $this->envoyerMailOubliMdp($id_annuaire,$mail , $nouveau_mdp);
4 aurelien 627 
	}
628 
 
19 aurelien 629 
	public function supprimerInscription($id_annuaire, $id_utilisateur) {
4 aurelien 630 
 
19 aurelien 631 
		$this->chargerModele('AnnuaireModele');
632 
		$champs_mappage = $this->obtenirChampsMappageAnnuaire($id_annuaire);
633 
		$suppression_inscription = $this->AnnuaireModele->supprimerInscriptionDansAnnuaireMappe($id_annuaire, $id_utilisateur);
4 aurelien 634 
 
19 aurelien 635 
		$donnees = array('erreurs' => array());
4 aurelien 636 
 
19 aurelien 637 
		$this->chargerModele('MetadonneeModele');
638 
 		$suppression_metadonnees = $this->MetadonneeModele->supprimerValeursMetadonneesParIdEnregistrementLie($id_utilisateur);
639 
 
640 
		if(!$suppression_inscription || !$suppression_metadonnees) {
641 
			$donnees['erreurs']['inscription'] = $suppression_inscription;
642 
			$donnees['erreurs']['metadonnees'] = $suppression_metadonnees;
643 
			$donnees['erreurs']['titre'] = 'Impossible de supprimer l\'inscription ';
644 
 
645 
			return $this->getVue(Config::get('dossier_squelettes_elements').'erreurs',$donnees);
4 aurelien 646 
		}
647 
 
19 aurelien 648 
		return $this->index();
649 
	}
650 
 
651 
	public function afficherFormulaireRecherche($id_annuaire, $donnees = array()) {
652 
 
653 
		$this->chargerModele('AnnuaireModele');
654 
		$annuaire = $this->AnnuaireModele->chargerAnnuaire($id_annuaire, false);
655 
 
656 
		$this->chargerModele('MetadonneeModele');
657 
		$metadonnees = $this->MetadonneeModele->chargerListeMetadonneeAnnuaire($id_annuaire);
658 
 
659 
		$donnees['aa_id_annuaire'] = $id_annuaire;
660 
 
661 
		// TODO: ceci charge toutes les métadonnées, voir si l'on ne peut pas parser le formulaire
662 
		// pour ne charger que ce qui est nécéssaire
663 
 
664 
		foreach($metadonnees as $metadonnee) {
665 
 
666 
			$id_champ = $metadonnee['amc_id_champ'];
667 
			$nom_champ = $metadonnee['amc_abreviation'];
668 
 
669 
			$metadonnee['aa_id_annuaire'] = $id_annuaire;
670 
			// on charge le formulaire d'affichage de chacune des métadonnées
671 
			$donnees['champs'][$nom_champ] = $this->afficherFormulaireChampMetadonnees($id_champ,$metadonnee);
4 aurelien 672 
		}
673 
 
19 aurelien 674 
		// Si le formulaire spécifique à l'annuaire existe, on l'affiche
675 
		if(!$this->formulaireExiste($annuaire['informations']['aa_code'],'recherche')) {
676 
			$formulaire_recherche = $this->genererFormulaireInscription($donnees);
677 
		} else {
678 
			// Sinon on prend celui par defaut
679 
			$formulaire_recherche = $this->GetVue(Config::get('dossier_squelettes_formulaires').$annuaire['informations']['aa_code'].'_recherche',$donnees);
4 aurelien 680 
		}
681 
 
19 aurelien 682 
		return $formulaire_recherche;
4 aurelien 683 
	}
684 
 
19 aurelien 685 
	/**
686 
	 * Recherche un ou plusieurs inscrits selon les valeurs passées en paramètres, qui peuvent êtres des valeurs
687 
	 * dans l'annuaire mappé ou bien des valeurs de metadonnées
688 
	 * @param int $id_annuaire l'identifiant de l'annuaire
689 
	 * @param array $valeurs_recherchees les valeurs à rechercher
690 
	 * @param boolean $exclusive indique si la recherche si fait sur tous les critères ou bien sur au moins un
691 
	 * @param int $numero_page le numero de page demandé
692 
	 * @param int $taille_page la taille de page
693 
	 */
694 
	public function rechercherInscrit($id_annuaire,$valeurs_recherchees, $exclusive = true,  $numero_page = 1, $taille_page = 50) {
7 aurelien 695 
 
19 aurelien 696 
		$this->chargerModele('AnnuaireModele');
697 
		$annuaire = $this->AnnuaireModele->chargerAnnuaire($id_annuaire, true);
7 aurelien 698 
 
19 aurelien 699 
		$tableau_mappage = $this->AnnuaireModele->obtenirChampsMappageAnnuaire($id_annuaire);
7 aurelien 700 
 
19 aurelien 701 
		$valeurs_get = $valeurs_recherchees;
7 aurelien 702 
 
19 aurelien 703 
		$valeurs_mappees = array();
704 
		$valeurs = array();
7 aurelien 705 
 
19 aurelien 706 
		// on itère sur le tableau de valeur pour récupérer les métadonnées;
707 
		foreach($valeurs_recherchees as $nom_champ => $valeur) {
708 
 
709 
			// pour chaque valeur
710 
			// on extrait l'id du champ
711 
			$ids_champ = mb_split("_",$nom_champ);
712 
 
713 
			if(count($ids_champ) == 2) {
714 
 
715 
				// l'identifiant du champ est la dernière valeur du tableau
716 
				$type = $ids_champ[0];
717 
				$id_champ = $ids_champ[1];
718 
 
719 
				// Si le champ fait partie des champs mappés
720 
				$cle_champ = array_search($id_champ, $tableau_mappage[1]);
721 
				if($cle_champ) {
722 
					// on ajoute sa clé correspondante dans l'annuaire mappé et sa valeur dans le tableau des champs mappés
723 
					$valeurs_mappees[$tableau_mappage[0][$cle_champ]] = $valeur;
724 
					// et on supprime sa valeur du tableau de valeurs pour ne pas la retrouver lors
725 
					// de l'insertion des métadonnées
7 aurelien 726 
				} else {
19 aurelien 727 
					$valeurs_recherchees[$id_champ] = $valeur;
7 aurelien 728 
				}
19 aurelien 729 
				// on retire la valeur du tableau pour ne pas la retrouver dans les deux recherches
730 
			}
7 aurelien 731 
 
19 aurelien 732 
			unset($valeurs_recherchees[$nom_champ]);
7 aurelien 733 
		}
734 
 
19 aurelien 735 
		$champ_id_annuaire = $tableau_mappage[0]['champ_id'];
7 aurelien 736 
 
19 aurelien 737 
		// on recherche dans les métadonnées
738 
		$this->chargerModele('MetadonneeModele');
739 
		// le résultat est un ensemble d'identifiants
740 
		$resultat_metadonnees = $this->MetadonneeModele->rechercherDansValeurMetadonnees($id_annuaire,$valeurs_recherchees, $exclusive);
11 aurelien 741 
 
19 aurelien 742 
		// on recherche les infos dans la table annuaire mappée
743 
		// en incluant ou excluant les id déjà trouvées dans les metadonnées
744 
		// suivant le critères d'exclusivité ou non
745 
		$resultat_annuaire_mappe = $this->AnnuaireModele->rechercherInscritDansAnnuaireMappe($id_annuaire,$valeurs_mappees, $resultat_metadonnees, $exclusive);
11 aurelien 746 
 
19 aurelien 747 
		$resultat_recherche = $resultat_annuaire_mappe;
11 aurelien 748 
 
19 aurelien 749 
		$nb_resultats = count($resultat_recherche);
11 aurelien 750 
 
19 aurelien 751 
		// on renvoie une liste identique à celle de la liste des inscrits
752 
		$donnees['resultats_recherche'] = $resultat_recherche;
753 
		$donnees['tableau_mappage'] = $tableau_mappage[0];
754 
		$donnees['id_annuaire'] = $id_annuaire;
755 
		$donnees['nb_resultats'] = $nb_resultats;
11 aurelien 756 
 
19 aurelien 757 
		$url_base = clone(Registre::getInstance()->get('base_url_application'));
11 aurelien 758 
 
19 aurelien 759 
		$url_pagination = new URL($url_base);
760 
 
761 
		$valeurs_get['id_annuaire'] = $id_annuaire;
762 
		$valeurs_get['m'] = 'annuaire_recherche_inscrit';
763 
		$url_pagination->setVariablesRequete($valeurs_get);
764 
 
765 
		$donnees['pagination'] = $this->paginer($numero_page,$taille_page,$nb_resultats,$url_pagination);
766 
		$vue_resultat_recherche = $this->getVue(Config::get('dossier_squelettes_annuaires').'annuaire_resultat_recherche', $donnees);
767 
 
768 
		return $this->afficherFormulaireRecherche($id_annuaire, $valeurs_recherchees).$vue_resultat_recherche;
11 aurelien 769 
	}
770 
 
19 aurelien 771 
 
772 
/** ---------------------------------    Fonction privées -------------------------------------------*/
773 
 
4 aurelien 774 
	/**
19 aurelien 775 
	 * En cas de tentative d'inscription, envoie un mail contenant un lien de confirmation à l'utilisateur
776 
	 * @param string $adresse_mail adresse mail
777 
	 * @param string $nom nom
778 
	 * @param string $prenom prénom
779 
	 * @param string $code_confirmation_inscription code de confirmation à inclure dans le mail
780 
	 *
781 
	 * @return boolean le succès ou l'échec de l'envoi du mail
4 aurelien 782 
	 */
19 aurelien 783 
	private function envoyerMailConfirmationInscription($adresse_mail, $nom, $prenom, $code_confirmation_inscription) {
4 aurelien 784 
 
19 aurelien 785 
		$base_url = clone(Registre::getInstance()->get('base_url_application'));
4 aurelien 786 
 
19 aurelien 787 
		$base_url->setVariableRequete('m','annuaire_inscription_confirmation');
788 
		$base_url->setVariableRequete('id',$code_confirmation_inscription);
789 
 
790 
		$donnees = array('nom' => $nom, 'prenom' => $prenom, 'lien_confirmation_inscription' => $base_url->getURL());
791 
		$contenu_mail = $this->getVue(Config::get('dossier_squelettes_mails').'mail_confirmation_inscription',$donnees);
792 
 
793 
		 // Pour envoyer un mail HTML, l'en-tête Content-type doit être défini
794 
	     $entetes  = 'MIME-Version: 1.0' . "\r\n";
795 
	     $entetes .= 'Content-type: text/html; charset='.Config::get('appli_encodage'). "\r\n";
796 
	     // En-têtes additionnels
797 
	     $entetes .= 'To: '.$adresse_mail."\r\n";
798 
	     $entetes .= 'From: '.Config::get('adresse_mail_annuaire')."\r\n";
799 
 
800 
		return mail($adresse_mail,'Inscription à l\'annuaire',$contenu_mail, $entetes);
801 
 
4 aurelien 802 
	}
7 aurelien 803 
 
19 aurelien 804 
	 /** En cas d'oubli de mot de passe, régénère le mot de passe et envoie un mail à l'utilisateur
805 
	 * @param int $id_annuaire l'identifiant d'annuaire
806 
	 * @param string $adresse_mail adresse mail
807 
	 * @return boolean le succès ou l'échec de l'envoi du mail
808 
	 */
809 
	private function envoyerMailOubliMdp($id_annuaire,$mail, $nouveau_mdp) {
810 
 
811 
		$base_url = clone(Registre::getInstance()->get('base_url_application'));
812 
 
813 
		$base_url->setVariableRequete('m','annuaire_fiche_utilisateur_consultation');
814 
		$base_url->setVariableRequete('id',1);
815 
 
816 
		$donnees['nouveau_mdp'] = $nouveau_mdp;
817 
		$donnees['lien_profil'] = $base_url;
818 
 
819 
		$contenu_mail = $this->getVue(Config::get('dossier_squelettes_mails').'mail_oubli_mdp',$donnees);
820 
 
821 
		 // Pour envoyer un mail HTML, l'en-tête Content-type doit être défini
822 
	     $entetes  = 'MIME-Version: 1.0' . "\r\n";
823 
	     $entetes .= 'Content-type: text/html; charset='.Config::get('appli_encodage'). "\r\n";
824 
	     // En-têtes additionnels
825 
	     $entetes .= 'To: '.$mail."\r\n";
826 
	     $entetes .= 'From: '.Config::get('adresse_mail_annuaire')."\r\n";
827 
 
828 
		 return mail($mail,'Inscription à l\'annuaire',$contenu_mail, $entetes);
829 
 
830 
	}
831 
 
7 aurelien 832 
	/**
19 aurelien 833 
	 * Insère les données dans la table d'inscription temporaire et crée un code de confirmation (à insérer dans le mail)
834 
	 * @param Array $valeurs les valeurs à insérer
7 aurelien 835 
	 */
19 aurelien 836 
	private function InsererDansTableTemporaireEtCreerCodeConfirmationInscription($valeurs) {
7 aurelien 837 
 
19 aurelien 838 
		// Le code de confirmation est constitué des 8 premiers caractères de l'identifiant de session
839 
		$code_confirmation = substr(session_id(), 0, 8) ;
7 aurelien 840 
 
19 aurelien 841 
		$this->chargerModele('AnnuaireModele');
842 
 
843 
		if(!$this->AnnuaireModele->ajouterNouvelleInscriptionTemporaire($code_confirmation, $valeurs)) {
844 
			return false;
7 aurelien 845 
		}
19 aurelien 846 
 
847 
		return $code_confirmation;
7 aurelien 848 
	}
849 
 
19 aurelien 850 
 
851 
/**--------------------------- Fonctions de vérification et de correspondance des champs --------------------*/
852 
 
7 aurelien 853 
	/**
19 aurelien 854 
	 * Renvoie les champs de mappage correspondant à un annuaire donné
855 
	 * @param int $id_annuaire l'indentifant de l'annuaire pour lequel on veut ces informations
856 
	 * @return Array un tableau de mappage des champs
857 
	 *
858 
	 */
859 
	private function obtenirChampsMappageAnnuaire($id_annuaire) {
860 
 
861 
		$this->chargerModele('AnnuaireModele');
862 
		$tableau_mappage = $this->AnnuaireModele->obtenirChampsMappageAnnuaire($id_annuaire);
863 
 
864 
		return $tableau_mappage;
865 
	}
866 
 
867 
	/**
7 aurelien 868 
	 * Renvoie le formulaire demandé s'il existe, sinon faux
869 
	 * @param string $nom_formulaire le nom du formulaire demandé (qui est normalement le code d'un annuaire)
870 
	 * @return boolean true si le formulaire existe, false sinon
871 
	 */
872 
	private function formulaireExiste($nom_formulaire) {
873 
 
19 aurelien 874 
		return $this->templateExiste($nom_formulaire.'_inscription', Config::get('dossier_squelettes_formulaires'));
7 aurelien 875 
	}
876 
 
877 
	/**
19 aurelien 878 
	 * Renvoie le template demandé s'il existe, sinon faux
879 
	 * @param string $nom_formulaire le nom du formulaire demandé (qui est normalement le code d'un annuaire)
880 
	 * @param string $dossier le nom du dossier sous dossier demandé
881 
	 * @return boolean true si le formulaire existe, false sinon
882 
	 */
883 
	private function templateExiste($nom_template, $dossier = '/') {
884 
		return file_exists(Config::get('chemin_squelettes').$dossier.$nom_template.'.tpl.html');
885 
	}
886 
 
887 
	/**
7 aurelien 888 
	 * Renvoie un formulaire d'inscription minimal auto-généré
889 
	 * @param string $donnees les donnée à inclure dans le formulaire
890 
	 * @return string la vue contenant le formulaire généré
891 
	 */
11 aurelien 892 
	private function genererFormulaireInscription($donnees) {
7 aurelien 893 
 
11 aurelien 894 
		$formulaire_modele = $this->getVue(Config::get('dossier_squelettes_formulaires').'inscription',$donnees);
7 aurelien 895 
 
896 
		if($formulaire_modele) {
897 
			return $formulaire_modele;
898 
		} else {
899 
			trigger_error("impossible de trouver le squelette de référence pour le formulaire");
900 
		}
901 
 
902 
		return false;
903 
	}
11 aurelien 904 
 
905 
	/**
906 
	 * Renvoie le template de pagination, considérant des éléments donnés en paramètre
907 
	 */
19 aurelien 908 
	private function paginer($numero_page, $taille_page = 1, $total, $url_base = '') {
11 aurelien 909 
 
910 
		// TODO, faire plus complexe, tri alphabétique etc...
911 
		$page_precedente = $numero_page-1;
912 
		$page_suivante = $numero_page+1;
913 
 
19 aurelien 914 
		if($taille_page <= 0) {
915 
			$taille_page = 1;
916 
		}
917 
 
11 aurelien 918 
		$nombre_pages = round($total/$taille_page,'PHP_ROUND_HALF_DOWN') ;
919 
 
920 
 
921 
		if($numero_page < 2) {
922 
			$page_precedente = false;
923 
		}
924 
 
925 
		if($taille_page*($numero_page) >= $total) {
926 
			$page_suivante = false;
927 
		}
928 
 
929 
		$donnees['pagination']= array('numero_page' => $numero_page, 'page_precedente' => $page_precedente, 'page_suivante' => $page_suivante, 'nombre_pages' => $nombre_pages, 'taille_page' => $taille_page);
930 
		$donnees['base_url_pagination'] = clone($url_base);
931 
 
932 
		return $this->getVue(Config::get('dossier_squelettes_elements').'pagination',$donnees);
933 
 
934 
	}
935 
 
19 aurelien 936 
 
937 
/** --- Fonction pour les images ------------------------------------------------------------------------*/
938 
 
11 aurelien 939 
	public function afficherFormulaireUploadImage($id_annuaire,$id_utilisateur) {
940 
 
941 
		$donnees['aa_id_annuaire'] = $id_annuaire;
942 
		$donnees['id_utilisateur'] = $id_utilisateur;
943 
 
944 
 
945 
		$donnees['amc_nom'] = 'Avatar';
946 
		$donnees['amc_id_champ'] = 101;
947 
 
948 
 
949 
		return $this->getVue(Config::get('dossier_squelettes_champs').'image',$donnees);
950 
	}
951 
 
952 
	/**
953 
	 * Ajoute une image uploadée à travers le formulaire
954 
	 *
955 
	 */
19 aurelien 956 
	public function ajouterImageUtilisateur($id_annuaire, $id_utilisateur, $fichier_a_stocker, $retourner_booleen = false) {
11 aurelien 957 
 
958 
		foreach($fichier_a_stocker as $nom_champ => $fichier) {
959 
 
960 
			//TODO: ajouter les vérifications de format
961 
 
962 
			$ids_champ = mb_split("_",$nom_champ, 3);
963 
 
964 
			if(count($ids_champ) == 2) {
965 
 
966 
				$type = $ids_champ[0];
967 
				$id_champ = $ids_champ[1];
968 
 
969 
			} else {
970 
				trigger_error('Ce champ n\'est pas relié à un annuaire');
971 
				return false;
972 
			}
973 
 
974 
			$this->chargerModele('ImageModele');
975 
			$stockage_image = $this->ImageModele->stockerFichier($id_annuaire, $id_utilisateur, $fichier);
976 
 
977 
			$this->chargerModele('MetadonneeModele');
978 
			if($stockage_image && $this->MetadonneeModele->ajouterNouvelleValeurMetadonnee($id_champ,$id_utilisateur,$stockage_image)) {
979 
 
980 
			} else {
981 
				return false;
982 
			}
983 
		}
984 
 
19 aurelien 985 
		if($retourner_booleen) {
986 
			return true;
987 
		} else {
988 
			return $this->afficherFicheUtilisateur($id_annuaire, $id_utilisateur) ;
989 
		}
11 aurelien 990 
	}
4 aurelien 991 
}
992 
?>