Subversion Repositories Applications.annuaire

Rev

Rev 56 | Rev 92 | 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
 
16
	/**
17
	 * (fonction héritée de la classe Controleur)
18
	 * Avant chaque chargement de vue, on ajoute l'url de la page dans
19
	 * les variables à insérer.
20
	 * @param Array $donnes les données à insérer dans la vue
21
	 * @return Array $donnees les données modifiées
22
	 */
23
	public function preTraiterDonnees($donnees) {
53 aurelien 24
 
56 aurelien 25
		// ajout de l'url de l'appli
53 aurelien 26
		$donnees['base_url'] = new Url(Registre::getInstance()->get('base_url_application'));
56 aurelien 27
		$donnees['url_cette_page'] = $_SERVER['SERVER_NAME'].$_SERVER['REQUEST_URI'];
28
 
29
		//ajout des variables d'identification
30
		$donnees['est_admin'] = Registre::getInstance()->get('est_admin');
31
		$donnees['identification_id'] =	Registre::getInstance()->get('identification_id');
32
		$donnees['identification_mail']	= Registre::getInstance()->get('identification_mail');
33
 
4 aurelien 34
		return $donnees;
35
	}
36
 
37
	/**
38
	 * Fonction affichant la vue par défaut, ici le menu principal
39
	 * @return String la vue contenant le menu
40
	 */
41
	public function index() {
42
		$data = array();
7 aurelien 43
		$index_annuaire = $this->getVue('index_annuaire', $data);
4 aurelien 44
 
7 aurelien 45
		return $index_annuaire;
4 aurelien 46
	}
47
 
65 aurelien 48
	/**
49
     * Fonction d'affichage par défaut
50
     */
51
    public function executerActionParDefaut() {
52
 
53
    	if(Registre::getInstance()->get('est_admin')) {
54
			$data = array();
55
			$index_annuaire = $this->getVue('index_annuaire', $data);
56
 
57
			return $index_annuaire;
58
    	} else {
59
			return $this->afficherFicheUtilisateur(Registre::getInstance()->get('identification_id'));
60
    	}
61
    }
62
 
4 aurelien 63
/**-------- Fonctions de gestion des annuaires --------------------------------*/
64
 
65
	/**
66
	 * Charge la vue contenant la liste des annuaires gérés par l'application
67
	 * @return string la vue contenant la liste des annuaires
68
	 */
69
	public function chargerListeAnnuaire() {
70
		$this->chargerModele('AnnuaireModele');
71
		$data['erreurs'] = null;
72
		$data['annuaires'] = $this->AnnuaireModele->chargerListeAnnuaire();
11 aurelien 73
		$liste_annu = $this->getVue(Config::get('dossier_squelettes_annuaires').'liste_annu', $data);
4 aurelien 74
 
7 aurelien 75
		return $liste_annu;
4 aurelien 76
	}
77
 
78
	/**
79
	 * Charge la vue contenant les informations d'un annuaire donné en paramètre
80
	 * @param int $id l'identifiant de l'annuaire
81
	 * @return string la vue contenant les informations sur l'annuaire
82
	 */
83
	public function chargerAnnuaire($id) {
84
		$this->chargerModele('AnnuaireModele');
85
		$this->chargerModele('MetadonneeModele');
86
		$data['erreurs'] = array();
53 aurelien 87
		$data['champs_mappage'] = $this->AnnuaireModele->obtenirChampsMappageAnnuaire($id);
4 aurelien 88
		$data['annuaire'] = $this->AnnuaireModele->chargerAnnuaire($id, true);
89
		$data['metadonnees'] = $this->MetadonneeModele->chargerListeMetadonneeAnnuaire($id);
11 aurelien 90
		$annuaire = $this->getVue(Config::get('dossier_squelettes_annuaires').'annuaire', $data);
4 aurelien 91
 
7 aurelien 92
		return $annuaire;
4 aurelien 93
	}
94
 
95
	/**
96
	 * Charge et affiche la liste des inscrits à un annuaire donné en paramètre
97
	 * @param $id int l'identifiant de l'annuaire
98
	 * @return string la vue contenant les inscrits à l'annuaire
99
	 */
7 aurelien 100
	public function chargerAnnuaireListeInscrits($id, $numero_page = 1, $taille_page = 50) {
4 aurelien 101
 
102
		$this->chargerModele('AnnuaireModele');
103
		$data['erreurs'] = array();
7 aurelien 104
		$data['champs'] = $this->obtenirChampsMappageAnnuaire($id);
11 aurelien 105
		$total_inscrits = $this->AnnuaireModele->chargerNombreAnnuaireListeInscrits($id);
7 aurelien 106
		$data['annuaire'] = $this->AnnuaireModele->chargerAnnuaireListeInscrits($id, $data['champs'][0], $numero_page, $taille_page);
4 aurelien 107
 
19 aurelien 108
		$url_pagination = new URL(Registre::getInstance()->get('base_url_application'));
109
		$url_pagination->setVariableRequete('m','annuaire_inscrits');
110
		$url_pagination->setVariableRequete('id_annuaire',$id);
7 aurelien 111
 
19 aurelien 112
		$data['pagination'] = $this->paginer($numero_page,$taille_page,$total_inscrits,$url_pagination);
11 aurelien 113
 
114
		$annuaires_inscrits = $this->getVue(Config::get('dossier_squelettes_annuaires').'annuaire_inscrits', $data);
115
 
7 aurelien 116
		return $annuaires_inscrits;
4 aurelien 117
	}
118
 
119
/**-------- Fonctions d'affichage du formulaire de saisie d'un champ de metadonnée suivant le type de champ---------*/
120
 
121
	/**
122
	 * Affiche le formulaire d'inscription pour un annuaire donné
123
	 * @param int $id_annuaire l'identifiant de l'annuaire pour lequel on veut afficher le formulaire
124
	 * @param Array $donnees le tableau de données pour préremplir le formulaire si besoin (en cas de retour erreur)
125
	 */
126
	public function afficherFormulaireInscription($id_annuaire, $donnees=array()) {
127
 
128
		$this->chargerModele('AnnuaireModele');
129
		$annuaire = $this->AnnuaireModele->chargerAnnuaire($id_annuaire, false);
130
 
131
		$this->chargerModele('MetadonneeModele');
132
		$donnees['aa_id_annuaire'] = $id_annuaire;
11 aurelien 133
 
4 aurelien 134
		$metadonnees = $this->MetadonneeModele->chargerListeMetadonneeAnnuaire($id_annuaire);
135
 
136
		// TODO: ceci charge toutes les métadonnées, voir si l'on ne peut pas parser le formulaire
137
		// pour ne charger que ce qui est nécéssaire
138
		foreach($metadonnees as $metadonnee) {
139
 
140
			$id_champ = $metadonnee['amc_id_champ'];
34 aurelien 141
			$type_champ = $metadonnee['amc_ce_template_affichage'];
4 aurelien 142
			$nom_champ = $metadonnee['amc_abreviation'];
11 aurelien 143
 
144
			$metadonnee['aa_id_annuaire'] = $id_annuaire;
34 aurelien 145
			if(isset($donnees['erreurs'])) {
146
				$metadonnee['erreurs'] = $donnees['erreurs'];
147
			}
148
 
149
			if(isset($donnees[$type_champ.'_'.$id_champ])) {
150
				$metadonnee['valeur_defaut']['amv_valeur'] = $donnees[$type_champ.'_'.$id_champ];
151
			}
152
 
153
			// on charge le formulaire d'affichage de chacune des métadonnées
4 aurelien 154
			$donnees['champs'][$nom_champ] = $this->afficherFormulaireChampMetadonnees($id_champ,$metadonnee);
155
		}
156
 
19 aurelien 157
		// si le formulaire existe, on le charge
34 aurelien 158
		if(!$this->templateExiste($annuaire['informations']['aa_code'].'_inscription','formulaires/')) {
7 aurelien 159
			$formulaire_inscription = $this->genererFormulaireInscription($donnees);
160
		} else {
19 aurelien 161
			// sinon on en génère un qui contient tous les champs
11 aurelien 162
			$formulaire_inscription = $this->GetVue(Config::get('dossier_squelettes_formulaires').$annuaire['informations']['aa_code'].'_inscription',$donnees);
7 aurelien 163
		}
4 aurelien 164
 
7 aurelien 165
		return $formulaire_inscription;
4 aurelien 166
	}
167
 
168
	/**
169
	 * Charge et affiche le champ correspondant à la modification ou l'ajout d'un champ de metadonnée
170
	 * @param int $id_champ l'identifiant du champ demandé
171
	 * @return string la vue contenant le champ de formulaire correspondant
172
	 */
56 aurelien 173
	public function afficherFormulaireChampMetadonnees($id_champ, $donnees) {
4 aurelien 174
 
175
		// si le champ est restreint à une valeur de liste
176
		if($donnees['amc_ce_ontologie'] != 0) {
177
				$this->chargerModele('OntologieModele');
178
				$donnees['liste_valeurs'] = $this->OntologieModele->chargerListeOntologie($donnees['amc_ce_ontologie']);
179
		}
19 aurelien 180
 
4 aurelien 181
		$donnees['amc_id_champ'] = $id_champ;
34 aurelien 182
 
56 aurelien 183
		if(isset($donnees['amc_ce_template_affichage'])) {
184
			$nom_type_champ = $donnees['amc_ce_template_affichage'];
185
		} else {
186
			$this->chargerModele('MetadonneeModele');
187
			$nom_type_champ = $this->MetadonneeModele->renvoyerTypeAffichageParId($donnees['amc_ce_type_affichage']);
188
		}
189
 
34 aurelien 190
		return $this->getVue(Config::get('dossier_squelettes_champs').$nom_type_champ,$donnees);
4 aurelien 191
	}
192
 
193
/**-------- Fonctions d'inscription -------------------------------------------------------------------------------*/
194
 
195
	/**
7 aurelien 196
	 * Lors d'une tentative d'inscription, ajoute les infos dans la table d'inscription
4 aurelien 197
	 * temporaire et envoie le mail contenant le lien de confirmation si tout s'est bien passé
198
	 * @param Array $valeurs les valeurs à ajouter
199
	 * @return string la vue contenant la confirmation de l'inscription
200
	 */
201
	public function ajouterInscriptionTemporaire($valeurs) {
202
 
203
		$this->chargerModele('MetadonneeModele');
204
		$id_annuaire = $valeurs['aa_id_annuaire'];
7 aurelien 205
		unset($valeurs['aa_id_annuaire']);
4 aurelien 206
 
207
		$tableau_mappage = $this->obtenirChampsMappageAnnuaire($id_annuaire);
208
		$valeurs_mappees = array();
34 aurelien 209
		$valeurs_a_inserer = array();
4 aurelien 210
 
19 aurelien 211
		$verificateur = new VerificationControleur();
212
 
4 aurelien 213
		// on itère sur le tableau de valeur pour récupérer les champs de mappage;
214
		foreach($valeurs as $nom_champ => $valeur) {
7 aurelien 215
 
4 aurelien 216
			// pour chaque valeur
217
			// on extrait l'id du champ
7 aurelien 218
			$ids_champ = mb_split("_",$nom_champ, 3);
4 aurelien 219
 
7 aurelien 220
			if(count($ids_champ) == 3) {
221
 
222
				$type = $ids_champ[0];
223
				$id_champ = $ids_champ[2];
19 aurelien 224
				$condition = $ids_champ[1];
7 aurelien 225
 
19 aurelien 226
				// cas de la checkbox qui devrait être là mais pas cochée
227
				if($condition == 'hidden' && !isset($valeurs[$type.'_'.$id_champ])) {
228
					// dans ce cas là on fabrique une valeur vide
229
					$valeurs[$type.'_'.$id_champ] = 0;
230
				}
231
 
7 aurelien 232
			} else {
233
				$type = $ids_champ[0];
19 aurelien 234
				$condition = false;
7 aurelien 235
				$id_champ = $ids_champ[1];
236
			}
237
 
4 aurelien 238
			// Si le champ fait partie des champs mappés
239
			$cle_champ = array_search($id_champ, $tableau_mappage[1]);
240
 
53 aurelien 241
			// on ajoute sa clé correspondante dans le tableau des champs mappés
242
			// qui sont les champs à vérifier
243
			if($condition) {
244
				$condition = $valeurs[$type.'_'.$id_champ];
245
				$valeurs_mappees[$id_champ] = array('valeur' => $valeur, 'type' => $type, 'condition' => $condition);
246
			} else {
247
				//$valeurs_mappees[$cle_champ] = $valeur;
248
				$valeurs_mappees[$id_champ] = array('valeur' => $valeur, 'type' => $type, 'condition' => false);
4 aurelien 249
			}
34 aurelien 250
 
251
			if(!$condition) {
252
				$valeurs_a_inserer[$nom_champ] = $valeur;
253
			}
4 aurelien 254
		}
255
 
256
		// vérification des champs minimaux : nom, prénom, mail, mot de passe
53 aurelien 257
		if($erreurs = $verificateur->verifierErreursChampsSelonType($id_annuaire,$valeurs_mappees, $tableau_mappage)) {
4 aurelien 258
			$valeurs['erreurs'] = $erreurs;
259
			return $this->afficherFormulaireInscription($id_annuaire, $valeurs);
7 aurelien 260
		}
4 aurelien 261
 
34 aurelien 262
		$valeurs_a_inserer['aa_id_annuaire'] = $id_annuaire ;
19 aurelien 263
 
34 aurelien 264
		$code_confirmation = $this->InsererDansTableTemporaireEtCreerCodeConfirmationInscription($valeurs_a_inserer);
4 aurelien 265
 
65 aurelien 266
		$mail = $valeurs_mappees[$tableau_mappage[1]['champ_mail']]['valeur'];
267
		$nom = $valeurs_mappees[$tableau_mappage[1]['champ_nom']]['valeur'];
268
		$prenom = $valeurs_mappees[$tableau_mappage[1]['champ_prenom']]['valeur'];
269
 
270
 
271
		$this->envoyerMailConfirmationInscription($mail,
272
													$nom,
273
													$prenom,
4 aurelien 274
													$code_confirmation);
275
		// Si tout s'est bien passé, on affiche la page de confirmation
11 aurelien 276
		return $this->getVue(Config::get('dossier_squelettes_annuaires').'annuaire_inscription_reussie',array());
4 aurelien 277
	}
278
 
279
	/**
280
	 * Ajoute une nouvelle inscription à un annuaire à partir de données d'une table temporaire.
281
	 * Typiquement, on déclenche cette fonction en cliquant sur le lien contenu dans le mail de confirmation
282
	 * @param int $indentifant L'identifant de session d'une tentative d'inscription
283
	 */
284
	public function ajouterNouvelleInscription($identifiant) {
285
 
286
		$this->chargerModele('AnnuaireModele');
287
 
288
		$valeurs = $this->AnnuaireModele->chargerDonneesInscriptionTemporaire($identifiant);
289
 
290
		if(!$valeurs || count($valeurs) == 0) {
291
			// TODO afficher vue en cas d'echec
292
		}
293
 
19 aurelien 294
		$id_annuaire = $valeurs['aa_id_annuaire'];
4 aurelien 295
		unset($valeurs['aa_id_annuaire']);
296
 
297
		$this->chargerModele('MetadonneeModele');
7 aurelien 298
 
19 aurelien 299
		$verificateur = new VerificationControleur();
300
 
4 aurelien 301
		$tableau_mappage = $this->obtenirChampsMappageAnnuaire($id_annuaire);
302
 
303
		$valeurs_mappees = array();
34 aurelien 304
		$valeurs_metadonnees = array();
4 aurelien 305
 
34 aurelien 306
		$mail_nouvel_inscrit = $valeurs['mail_'.$tableau_mappage[1]['champ_mail']];
65 aurelien 307
		//$pass_nouvel_inscrit = $valeurs['pass_'.$tableau_mappage[1]['champ_pass']];
19 aurelien 308
 
4 aurelien 309
		// on itère sur le tableau de valeur pour récupérer les métadonnées;
310
		foreach($valeurs as $nom_champ => $valeur) {
11 aurelien 311
 
4 aurelien 312
			// pour chaque valeur
313
			// on extrait l'id du champ
34 aurelien 314
			$ids_champ = mb_split("_",$nom_champ, 2);
4 aurelien 315
 
34 aurelien 316
			$type = $ids_champ[0];
317
			$condition = false;
318
			$id_champ = $ids_champ[1];
19 aurelien 319
 
320
			// on fait des vérifications et des remplacements sur certaines valeurs
34 aurelien 321
			$valeur = $verificateur->remplacerValeurChampPourInsertion($type,$valeur,$mail_nouvel_inscrit);
19 aurelien 322
 
4 aurelien 323
			// Si le champ fait partie des champs mappés
324
			$cle_champ = array_search($id_champ, $tableau_mappage[1]);
325
			if($cle_champ) {
326
				// on ajoute sa clé correspondante dans l'annuaire mappé et sa valeur dans le tableau des champs mappés
327
				$valeurs_mappees[$tableau_mappage[0][$cle_champ]] = $valeur;
328
				// et on supprime sa valeur du tableau de valeurs pour ne pas la retrouver lors
11 aurelien 329
				// de l'insertion des métadonnées
4 aurelien 330
				unset($valeurs[$nom_champ]);
34 aurelien 331
			} else {
332
				$valeurs_metadonnees[$nom_champ] = $valeur;
4 aurelien 333
			}
334
		}
335
 
336
		// obtenir l'id du nouvel arrivant en faisant un select sur le mail qui doit être unique
337
		$id_nouvel_inscrit = $this->ajouterNouvelleInscriptionDansAnnuaireMappe($id_annuaire,$valeurs_mappees, $tableau_mappage[0]);
338
 
19 aurelien 339
		// les champs de metadonnees arrivent avec un identifiant sous la forme type_condition_id
34 aurelien 340
		foreach($valeurs_metadonnees as $nom_champ => $valeur) {
4 aurelien 341
 
19 aurelien 342
			// pour chaque valeur
343
			// on extrait l'id du champ
4 aurelien 344
			$ids_champ = mb_split("_",$nom_champ);
345
			$id_champ = $ids_champ[count($ids_champ) - 1];
346
 
347
			// Si l'insertion dans la base a réussi
348
			if($this->MetadonneeModele->ajouterNouvelleValeurMetadonnee($id_champ,$id_nouvel_inscrit,$valeur)) {
349
				// on continue
350
			} else {
351
 
352
				// Si une des insertions échoue, on supprime les méta valeurs déjà entrées.
353
				$this->MetadonneeModele->supprimerValeursMetadonneesParIdEnregistrementLie($id_nouvel_inscrit);
354
				return false;
355
			}
356
		}
357
 
358
		//TODO: gérer le cas de spip et de wikini par un multimapping des champs
359
		//TODO: voir openid
56 aurelien 360
 
361
 
53 aurelien 362
		// TODO appel des plugins d'inscription
56 aurelien 363
		// on crée un controleur appelle les hooks de résumé pour chaque application externe
364
		$resumes_controleur = new ApplicationExterneControleur();
365
		$resumes_controleur->ajouterInscription($id_nouvel_inscrit, $mail_nouvel_inscrit);
4 aurelien 366
 
367
		// Si tout a réussi on supprime les données d'inscription temporaire
368
		$this->AnnuaireModele->supprimerDonneesInscriptionTemporaire($identifiant);
369
 
19 aurelien 370
		$annuaire = $this->AnnuaireModele->chargerAnnuaire($id_annuaire, false);
371
 
53 aurelien 372
		// Identifier l'utilisateur !
373
		//$identificateur = new IdentificationControleur();
374
		//$identificateur->fabriquerCookie($mail_nouvel_inscrit, $pass_nouvel_inscrit, false);
375
		//$identificateur->loggerUtilisateurParCookie();
376
 
19 aurelien 377
		// S'il existe une page d'accueil spécifique à l'annuaire pour la confirmation d'inscription
378
		if($this->templateExiste($annuaire['informations']['aa_code'].'_inscription_confirmation', Config::get('dossier_squelettes_annuaires'))) {
379
			// on l'affiche
380
			$donnees = array('id_utilisateur' => $id_nouvel_inscrit, 'id_annuaire' => $id_annuaire);
381
			return $this->getVue(Config::get('dossier_squelettes_annuaires').$annuaire['informations']['aa_code'].'_inscription_confirmation', $donnees);
382
 
383
		} else {
384
			// sinon on le redirige
385
			return $this->afficherFicheUtilisateur($id_annuaire, $id_nouvel_inscrit);
386
		}
4 aurelien 387
	}
388
 
389
	/**
390
	 * Ajoute un nouvel inscrit dans l'annuaire mappé donné en paramètre.
391
	 * En cas de succès, renvoie l'identifiant du nouvel inscrit qui sera
392
	 * utilisé pour insérer les métadonnées liées
393
	 *
394
	 * @param int $id_annuaire identifiant de l'annuaire auquel sera lié le nouvel inscrit
395
	 * @param Array $valeurs_mappees Tableau contenant les valeurs à insérer et ayant comme clés des noms de colonnes
396
	 * @param Array $noms_champs Tableau contenant les noms des champs à insérer
397
	 * @return int l'identifiant unique du nouvel inscrit
398
	 */
399
	public function ajouterNouvelleInscriptionDansAnnuaireMappe($id_annuaire,$valeurs_mappees, $noms_champs) {
400
 
401
		$this->chargerModele('AnnuaireModele');
19 aurelien 402
		$resultat = $this->AnnuaireModele->ajouterInscriptionDansAnnuaireMappe($id_annuaire, $valeurs_mappees, $noms_champs);
4 aurelien 403
 
404
		return $resultat;
405
	}
406
 
53 aurelien 407
	public function afficherFormulaireIdentification($donnees = array()) {
408
 
409
		return $this->getVue(Config::get('dossier_squelettes_formulaires').'identification', $donnees);
410
	}
411
 
4 aurelien 412
	/**
413
	 * Affiche la fiche principale d'un utilisateur
414
	 * @param int $id_annuaire l'identifiant de l'annuaire
415
	 * @param int $id_utilisateur l'identifiant de l'utilisateur
416
	 * @return string la vue contenant la fiche utilisateur
417
	 */
418
	public function afficherFicheUtilisateur($id_annuaire, $id_utilisateur) {
419
 
34 aurelien 420
		// Chargement des informations de l'utilisateur dans la table annuaire principale
4 aurelien 421
		$this->chargerModele('AnnuaireModele');
34 aurelien 422
		$annuaire = $this->AnnuaireModele->chargerAnnuaire($id_annuaire);
4 aurelien 423
		$tableau_mappage = $this->obtenirChampsMappageAnnuaire($id_annuaire);
424
		$tableau_valeurs = $this->AnnuaireModele->obtenirValeursUtilisateur($id_annuaire, $id_utilisateur,$tableau_mappage[0]);
425
 
34 aurelien 426
		// chargement des métadonnées associées à l'utilisateur
19 aurelien 427
		$this->chargerModele('MetadonneeModele');
428
		$champs_metadonnees= $this->MetadonneeModele->chargerListeValeursMetadonneesUtilisateur($id_annuaire, $id_utilisateur);
429
 
430
		$verificateur = new VerificationControleur();
431
 
432
		// on vérifie s'il existe un type d'affichage particulier pour les colonnes de l'annuaire mappé
5 aurelien 433
		foreach($tableau_mappage[0] as $cle => $nom_champ) {
19 aurelien 434
 
5 aurelien 435
			$valeur = $tableau_valeurs[$nom_champ] ;
19 aurelien 436
			if(isset($tableau_mappage[1][$cle])) {
437
 
438
				$tableau_valeurs[$cle] = array('amv_valeur' => $valeur,'amc_id_champ' => $tableau_mappage[1][$cle]);
439
				$type_affichage = $this->MetadonneeModele->renvoyerTypeAffichagePourColonne($tableau_mappage[1][$cle]);
440
				if($type_affichage) {
441
					$tableau_valeurs[$cle]['amc_ce_type_affichage'] = $type_affichage;
442
				}
443
 
444
			} else {
445
				$tableau_valeurs[$cle] = $valeur;
446
			}
5 aurelien 447
			unset($tableau_valeurs[$nom_champ]);
448
		}
449
 
11 aurelien 450
		$donnees['id_annuaire'] = $id_annuaire;
19 aurelien 451
		$donnees['id_utilisateur'] = $id_utilisateur;
452
		$champs =  array_merge($tableau_valeurs, $champs_metadonnees);
4 aurelien 453
 
19 aurelien 454
		foreach($champs as $cle => $champ) {
455
 
456
			if(is_array($champ) && isset($champ['amc_ce_type_affichage'])) {
457
				$type = $champ['amc_ce_type_affichage'];
458
			} else {
459
				$type = false;
460
			}
34 aurelien 461
			// on remplace les valeurs de certains champs pour l'affichage (ex: checkbox cochée de se transforme en oui )
19 aurelien 462
			$champs[$cle] = $verificateur->verifierEtRemplacerValeurChampPourAffichage($type,$champ ,$id_annuaire);
463
		}
464
 
465
		$donnees['champs'] = $champs;
466
 
56 aurelien 467
		if(Registre::getInstance()->get('est_admin')) {
468
			$donnees['formulaire_blocage'] = $this->getVue(Config::get('dossier_squelettes_elements').'blocage',$donnees);
469
		}
7 aurelien 470
 
56 aurelien 471
		//Debug::printr($champs);
472
 
473
		$fiche_inscrit = $this->getVue(Config::get('dossier_squelettes_fiches').$annuaire['informations']['aa_code'].'_fiche',$donnees);
474
 
475
		return $fiche_inscrit;
4 aurelien 476
	}
477
 
34 aurelien 478
	/** Affiche le resumé des contributions d'un utilisateur
479
	 * @param int $id_annuaire l'identifiant de l'annuaire
480
	 * @param int $id_utilisateur l'identifiant de l'utilisateur
481
	 * @return string la vue contenant les contributions utilisateur
482
	 */
483
	public function afficherFicheResumeUtilisateur($id_annuaire, $id_utilisateur) {
4 aurelien 484
 
19 aurelien 485
		$this->chargerModele('AnnuaireModele');
56 aurelien 486
		$annuaire = $this->AnnuaireModele->chargerAnnuaire($id_annuaire);
34 aurelien 487
		$tableau_mappage = $this->obtenirChampsMappageAnnuaire($id_annuaire);
488
		$tableau_valeurs = $this->AnnuaireModele->obtenirValeursUtilisateur($id_annuaire, $id_utilisateur,$tableau_mappage[0]);
489
 
490
		$this->chargerModele('MetadonneeModele');
491
		$champs_metadonnees= $this->MetadonneeModele->chargerListeValeursMetadonneesUtilisateur($id_annuaire, $id_utilisateur);
492
 
493
		$verificateur = new VerificationControleur();
494
 
495
		// on vérifie s'il existe un type d'affichage particulier pour les colonnes de l'annuaire mappé
496
		foreach($tableau_mappage[0] as $cle => $nom_champ) {
497
 
498
			$valeur = $tableau_valeurs[$nom_champ] ;
499
			if(isset($tableau_mappage[1][$cle])) {
500
 
501
				$tableau_valeurs[$cle] = array('amv_valeur' => $valeur,'amc_id_champ' => $tableau_mappage[1][$cle]);
502
				$type_affichage = $this->MetadonneeModele->renvoyerTypeAffichagePourColonne($tableau_mappage[1][$cle]);
503
				if($type_affichage) {
504
					$tableau_valeurs[$cle]['amc_ce_type_affichage'] = $type_affichage;
505
				}
506
 
507
			} else {
508
				$tableau_valeurs[$cle] = $valeur;
509
			}
510
			unset($tableau_valeurs[$nom_champ]);
511
		}
512
 
513
		$mail_utilisateur = $this->AnnuaireModele->obtenirMailParId($id_annuaire,$id_utilisateur);
514
 
515
		$donnees['id_annuaire'] = $id_annuaire;
516
		$donnees['id_utilisateur'] = $id_utilisateur;
56 aurelien 517
		$donnees['mail_utilisateur'] = $mail_utilisateur;
34 aurelien 518
		$champs =  array_merge($tableau_valeurs, $champs_metadonnees);
519
 
520
		foreach($champs as $cle => $champ) {
521
 
522
			if(is_array($champ) && isset($champ['amc_ce_type_affichage'])) {
523
				$type = $champ['amc_ce_type_affichage'];
524
			} else {
525
				$type = false;
526
			}
527
			$champs[$cle] = $verificateur->verifierEtRemplacerValeurChampPourAffichage($type,$champ ,$id_annuaire);
528
		}
529
 
530
		$url_modification_profil = new Url(Config::get('base_url_application'));
531
		$url_modification_profil->setVariableRequete('m','annuaire_formulaire_modification_inscription');
532
		$url_modification_profil->setVariableRequete('id_annuaire',$id_annuaire);
533
		$url_modification_profil->setVariableRequete('id_utilisateur',$id_utilisateur);
534
 
535
		$url_oubli_mdp = new Url(Config::get('base_url_application'));
536
		$url_oubli_mdp->setVariableRequete('m','annuaire_afficher_formulaire_oubli_mdp');
537
		$url_oubli_mdp->setVariableRequete('id_annuaire',$id_annuaire);
538
		$url_oubli_mdp->setVariableRequete('id_utilisateur',$id_utilisateur);
539
 
540
		$donnees['url_oubli_mdp'] = $url_oubli_mdp;
541
 
542
		$donnees['url_modification_profil'] = $url_modification_profil;
543
 
544
		$donnees['champs'] = $champs;
545
 
546
		// on crée un controleur appelle les hooks de résumé pour chaque application externe
547
		$resumes_controleur = new ApplicationExterneControleur();
548
 
549
		$donnees['resumes'] = $resumes_controleur->obtenirResume($id_utilisateur,$mail_utilisateur);
56 aurelien 550
		$donnees['carte_id'] = $this->getVue(Config::get('dossier_squelettes_fiches').$annuaire['informations']['aa_code'].'_carte_id',$donnees);
551
 
552
		$fiche_contrib = $this->getVue(Config::get('dossier_squelettes_fiches').$annuaire['informations']['aa_code'].'_resume',$donnees);
553
 
554
		return $fiche_contrib;
555
	}
556
 
557
	public function gererInscriptionExterne($id_annuaire, $id_utilisateur) {
558
 
559
		$this->chargerModele('AnnuaireModele');
560
		$tableau_mappage = $this->obtenirChampsMappageAnnuaire($id_annuaire);
561
		$tableau_valeurs = $this->AnnuaireModele->obtenirValeursUtilisateur($id_annuaire, $id_utilisateur,$tableau_mappage[0]);
562
 
563
		$this->chargerModele('MetadonneeModele');
564
		$champs_metadonnees= $this->MetadonneeModele->chargerListeValeursMetadonneesUtilisateur($id_annuaire, $id_utilisateur);
565
 
566
		$verificateur = new VerificationControleur();
567
 
568
		// on vérifie s'il existe un type d'affichage particulier pour les colonnes de l'annuaire mappé
569
		foreach($tableau_mappage[0] as $cle => $nom_champ) {
570
 
571
			$valeur = $tableau_valeurs[$nom_champ] ;
572
			if(isset($tableau_mappage[1][$cle])) {
573
 
574
				$tableau_valeurs[$cle] = array('amv_valeur' => $valeur,'amc_id_champ' => $tableau_mappage[1][$cle]);
575
				$type_affichage = $this->MetadonneeModele->renvoyerTypeAffichagePourColonne($tableau_mappage[1][$cle]);
576
				if($type_affichage) {
577
					$tableau_valeurs[$cle]['amc_ce_type_affichage'] = $type_affichage;
578
				}
579
 
580
			} else {
581
				$tableau_valeurs[$cle] = $valeur;
582
			}
583
			unset($tableau_valeurs[$nom_champ]);
584
		}
585
 
586
		$mail_utilisateur = $this->AnnuaireModele->obtenirMailParId($id_annuaire,$id_utilisateur);
587
 
588
		$donnees['id_annuaire'] = $id_annuaire;
589
		$donnees['id_utilisateur'] = $id_utilisateur;
590
		$champs =  array_merge($tableau_valeurs, $champs_metadonnees);
591
 
592
		foreach($champs as $cle => $champ) {
593
 
594
			if(is_array($champ) && isset($champ['amc_ce_type_affichage'])) {
595
				$type = $champ['amc_ce_type_affichage'];
596
			} else {
597
				$type = false;
598
			}
599
			$champs[$cle] = $verificateur->verifierEtRemplacerValeurChampPourAffichage($type,$champ ,$id_annuaire);
600
		}
601
 
602
		$mail_utilisateur = $this->AnnuaireModele->obtenirMailParId($id_annuaire,$id_utilisateur);
603
 
604
		// on crée un controleur appelle les hooks de résumé pour chaque application externe
605
		$resumes_controleur = new ApplicationExterneControleur();
606
 
607
		$donnees['champs'] = $champs;
608
		$donnees['resumes'] = $resumes_controleur->gererInscription($id_utilisateur,$mail_utilisateur);
34 aurelien 609
		$donnees['carte_id'] = $this->getVue(Config::get('dossier_squelettes_fiches').'annuaire_tela_inscrits_carte_id',$donnees);
610
 
56 aurelien 611
		$fiche_contrib = $this->getVue(Config::get('dossier_squelettes_fiches').'annuaire_tela_inscrits_gestion_inscription',$donnees);
34 aurelien 612
 
613
		return $fiche_contrib;
614
	}
615
 
616
	public function afficherFormulaireModificationInscription($id_annuaire, $id_utilisateur, $erreurs = array()) {
617
 
618
		$this->chargerModele('AnnuaireModele');
19 aurelien 619
		$annuaire = $this->AnnuaireModele->chargerAnnuaire($id_annuaire, false);
4 aurelien 620
 
19 aurelien 621
		$this->chargerModele('MetadonneeModele');
622
		$donnees['aa_id_annuaire'] = $id_annuaire;
4 aurelien 623
 
19 aurelien 624
		$metadonnees = $this->MetadonneeModele->chargerListeMetadonneeAnnuaire($id_annuaire);
625
		$tableau_mappage = $this->obtenirChampsMappageAnnuaire($id_annuaire);
4 aurelien 626
 
19 aurelien 627
		$valeurs_annuaire = $this->AnnuaireModele->obtenirValeursUtilisateur($id_annuaire, $id_utilisateur,$tableau_mappage[0]);
628
		$valeurs_metadonnees= $this->MetadonneeModele->chargerListeValeursMetadonneesUtilisateur($id_annuaire, $id_utilisateur);
4 aurelien 629
 
19 aurelien 630
		foreach($tableau_mappage[0] as $cle => $nom_champ) {
631
			$valeur = $valeurs_annuaire[$nom_champ] ;
632
			if($cle != 'champ_id') {
633
				$valeurs_metadonnees[$metadonnees[$tableau_mappage[1][$cle]]['amc_abreviation']] = array('amv_valeur' => $valeur,'amc_id_champ' => $tableau_mappage[1][$cle]) ;
634
			}
635
		}
7 aurelien 636
 
19 aurelien 637
		// TODO: ceci charge toutes les métadonnées, voir si l'on ne peut pas parser le formulaire
638
		// pour ne charger que ce qui est nécéssaire
639
		foreach($metadonnees as $metadonnee) {
640
 
641
			$id_champ = $metadonnee['amc_id_champ'];
642
			$nom_champ = $metadonnee['amc_abreviation'];
643
 
644
			if(isset($valeurs_metadonnees[$nom_champ])) {
645
				$metadonnee['valeur_defaut'] = $valeurs_metadonnees[$nom_champ];
646
			}
647
 
648
			$metadonnee['aa_id_annuaire'] = $id_annuaire;
649
			// on charge le formulaire d'affichage de chacune des métadonnées
650
			$donnees['champs'][$nom_champ] = $this->afficherFormulaireChampMetadonnees($id_champ,$metadonnee);
651
 
652
		}
653
 
654
		$donnees['id_utilisateur'] = $id_utilisateur;
34 aurelien 655
		$donnees['erreurs'] = $erreurs;
19 aurelien 656
 
657
		// le nom du formulaire d'inscription est le même que le code de l'annuaire du genre code_annuaire_inscription
658
		if(!$this->formulaireExiste($annuaire['informations']['aa_code'])) {
659
			$formulaire_inscription = $this->genererFormulaireInscription($donnees);
660
		} else {
661
			$formulaire_inscription = $this->GetVue(Config::get('dossier_squelettes_formulaires').$annuaire['informations']['aa_code'].'_modification',$donnees);
662
		}
663
 
664
		return $formulaire_inscription;
665
 
4 aurelien 666
	}
667
 
19 aurelien 668
	public function modifierInscription($valeurs) {
11 aurelien 669
 
19 aurelien 670
		$this->chargerModele('MetadonneeModele');
4 aurelien 671
 
19 aurelien 672
		$id_utilisateur = $valeurs['id_utilisateur'];
673
		unset($valeurs['id_utilisateur']);
674
 
675
		$id_annuaire = $valeurs['aa_id_annuaire'];
676
		unset($valeurs['aa_id_annuaire']);
677
 
678
		$this->chargerModele('MetadonneeModele');
34 aurelien 679
		$tableau_mappage = $this->obtenirChampsMappageAnnuaire($id_annuaire);
19 aurelien 680
 
34 aurelien 681
		$mail_utilisateur = $this->AnnuaireModele->obtenirMailParId($id_annuaire, $id_utilisateur);
682
		$ancien_mail = $mail_utilisateur;
683
 
19 aurelien 684
		$verificateur = new VerificationControleur();
685
 
686
		$valeurs_mappees = array();
687
		$valeurs_metadonnees = array();
688
 
34 aurelien 689
		$erreurs = array();
690
 
691
		// on itère sur le tableau de valeur pour récupérer les métadonnées
692
		// et les valeurs
19 aurelien 693
		foreach($valeurs as $nom_champ => $valeur) {
694
 
695
			// pour chaque valeur
696
			// on extrait l'id du champ
697
			$ids_champ = mb_split("_",$nom_champ);
698
 
34 aurelien 699
			$confirmation = false;
700
			$valeur_a_ignorer = false;
701
 
19 aurelien 702
			// l'identifiant du champ est la dernière valeur du tableau
703
			if(count($ids_champ) == 3) {
704
 
705
				$type = $ids_champ[0];
706
				$id_champ = $ids_champ[2];
707
				$condition = $ids_champ[1];
708
 
709
			} else {
710
				$type = $ids_champ[0];
711
				$condition = false;
712
				$id_champ = $ids_champ[1];
713
			}
714
 
34 aurelien 715
			if($type == 'checkbox' && $condition != 'hidden') {
716
				// on récupère la valeur
717
					$nom_champ = $type.'_'.$id_champ;
718
					$valeur = $valeurs[$type.'_'.$id_champ];
719
			}
720
 
19 aurelien 721
			// cas de la checkbox qui devrait être là mais pas cochée
722
			if($condition == 'hidden') {
723
 
724
				if(!isset($valeurs[$type.'_'.$id_champ])) {
725
					// dans ce cas là on fabrique une valeur qui vaut 0
726
					$nom_champ = $type.'_'.$id_champ;
727
					$valeur = '0';
728
				} else {
34 aurelien 729
					// sinon la valeur a déjà été traitée et doit être ignorée
730
					$valeur_a_ignorer = true;
731
				}
732
			}
19 aurelien 733
 
34 aurelien 734
			if($type ==  'mail') {
735
				$mail_utilisateur = $valeur;
736
			}
737
 
738
			// cas du changement de mot de passe
739
			if($type == 'password') {
740
 
741
				if($condition == 'conf') {
742
					$valeur_a_ignorer = true;
19 aurelien 743
				}
34 aurelien 744
 
745
				$tentative_changemement_mdp = false;
746
 
747
				if(isset($valeurs[$type.'_conf_'.$id_champ]) && trim($valeurs[$type.'_conf_'.$id_champ]) != '') {
748
					$tentative_changemement_mdp = true;
749
				} else {
750
					$valeur_a_ignorer = true;
751
				}
752
 
753
				if($tentative_changemement_mdp) {
754
					$confirmation = $valeurs[$type.'_conf_'.$id_champ];
755
				}
19 aurelien 756
			}
757
 
34 aurelien 758
			// Si la valeur n'est présente dans le formulaire que pour des raisons de vérification
759
			// on passe à l'iteration suivante
760
			if($valeur_a_ignorer) {
761
				continue;
762
			}
763
 
764
			$verification = $verificateur->verifierErreurChampModification($id_annuaire, $id_utilisateur, $type , $valeur, $confirmation);
765
 
766
			if($verification[0] == false) {
767
				$erreurs[$type.'_'.$id_champ] = $verification[1];
768
 
769
			}
770
 
771
			// on fait des vérifications et des remplacements sur certaines valeurs
772
			// et quelques fois des actions externes
773
			$valeur = $verificateur->remplacerValeurChampPourModification($id_annuaire, $id_utilisateur, $type, $valeur, $mail_utilisateur);
774
 
19 aurelien 775
			// Si le champ fait partie des champs mappés
776
			$cle_champ = array_search($id_champ, $tableau_mappage[1]);
777
			if($cle_champ) {
778
				// on ajoute sa clé correspondante dans l'annuaire mappé et sa valeur dans le tableau des champs mappés
779
				$valeurs_mappees[$tableau_mappage[0][$cle_champ]] = $valeur;
780
			} else {
34 aurelien 781
				// sinon, il est stocké dans les valeurs de metadonnées
782
				$valeurs_metadonnees[$id_champ] = $valeur;
19 aurelien 783
			}
784
		}
785
 
34 aurelien 786
		if(count($erreurs) > 0) {
787
			return $this->afficherFormulaireModificationInscription($id_annuaire,$id_utilisateur,$erreurs);
788
		}
789
 
4 aurelien 790
		$this->chargerModele('AnnuaireModele');
19 aurelien 791
		$modification_annuaire = $this->AnnuaireModele->modifierInscriptionDansAnnuaireMappe($id_annuaire, $id_utilisateur ,$valeurs_mappees, $tableau_mappage[0]);
4 aurelien 792
 
34 aurelien 793
		$nouveau_mail = $this->AnnuaireModele->obtenirMailParId($id_annuaire, $id_utilisateur);
19 aurelien 794
 
34 aurelien 795
		// Si le mail a changé alors il faut appeler les applications externes pour modification
796
		if($ancien_mail != $mail_utilisateur) {
65 aurelien 797
 
34 aurelien 798
			$appli_controleur = new ApplicationExterneControleur();
65 aurelien 799
 
800
			//TODO ajouter une fonction renvoyant les infos à diffuser pour la modification
801
			// utiliser la fonction infos Open id ?
802
			$params = array (
803
				'id_utilisateur' => $id_utilisateur,
804
				'prenom' => 'Aurelien',
805
				'nom' => 'Peronnet',
806
				'mail' => $mail_utilisateur,
807
				'pass' => '',
808
				'pays' => 'fr',
809
				'nouveau_pass' => '',
810
				'nouveau_mail' => $nouveau_mail
811
			);
812
 
813
			$appli_controleur->modifierInscription($id_utilisateur, $params);
814
 
815
			// pour qu'ils lancent les procédures de désinscription associées
816
			$lettre_controleur = new LettreControleur();
817
			$lettre_controleur->modificationInscriptionLettreActualite($ancien_mail, $nouveau_mail);
34 aurelien 818
		}
19 aurelien 819
 
34 aurelien 820
		// les champs arrivent avec un identifiant sous la forme type_xxx_id
821
		foreach($valeurs_metadonnees as $id_champ => $valeur) {
19 aurelien 822
 
823
			// S'il existe déjà une valeur de metadonnée pour cette colonne et cet utilisateur
34 aurelien 824
			// car on a pu ajouter de nouveaux champs entre temps
19 aurelien 825
			if($this->MetadonneeModele->valeurExiste($id_champ,$id_utilisateur)) {
826
				// On se contente de la modifier
56 aurelien 827
				$this->MetadonneeModele->modifierValeurMetadonnee($id_champ,$id_utilisateur,$valeur);
19 aurelien 828
 
829
			} else {
830
				// S'il n'existe pas de valeur, on ajoute une nouvelle ligne à la table de valeurs de meta données
831
				if($this->MetadonneeModele->ajouterNouvelleValeurMetadonnee($id_champ,$id_utilisateur,$valeur)) {
832
					// Si l'insertion a réussi, on continue
833
				} else {
834
					return false;
835
				}
836
			}
4 aurelien 837
		}
838
 
19 aurelien 839
		return $this->afficherFicheUtilisateur($id_annuaire, $id_utilisateur);
4 aurelien 840
	}
841
 
56 aurelien 842
	public function estAbonneLettreActualite($id_annuaire, $id_utilisateur) {
843
 
844
		$annuaire_modele = $this->getModele('AnnuaireModele');
845
		$champs_description = $annuaire_modele->obtenirChampsDescriptionAnnuaire($id_annuaire);
846
 
847
		$valeur = $annuaire_modele->obtenirValeurChampAnnuaireMappe($id_annuaire, $id_utilisateur, 'champ_lettre');
848
 
849
		return $valeur;
850
	}
851
 
852
	public function abonnerDesabonnerLettreActualite($id_annuaire, $id_utilisateur, $abonner = true) {
853
 
854
		$annuaire_modele = $this->getModele('AnnuaireModele');
855
		$champs_description = $annuaire_modele->obtenirChampsDescriptionAnnuaire($id_annuaire);
856
 
857
		$mail_utilisateur = $annuaire_modele->obtenirMailParId($id_annuaire, $id_utilisateur);
858
 
859
		$champ_lettre = $champs_description[0]['champ_lettre'];
860
 
861
		if($abonner) {
862
			$valeur = 'on';
863
		} else {
864
			$valeur = '0';
865
		}
866
 
867
		$verificateur = new VerificationControleur();
868
		$valeur_modif = $verificateur->remplacerValeurChampPourModification($id_annuaire, $id_utilisateur, 'lettre', $valeur, $mail_utilisateur);
869
 
870
 
871
		$annuaire_modele = $this->getModele('AnnuaireModele');
872
		$valeur_modif = $annuaire_modele->modifierValeurChampAnnuaireMappe($id_annuaire, $id_utilisateur, $champ_lettre, $valeur_modif);
873
		//$this->chargerModele('MetadonneeModele');
874
		//$this->MetadonneeModele->modifierValeurMetadonnee($champ_lettre,$id_utilisateur,$valeur_modif);
875
 
876
		return $valeur_modif;
877
	}
878
 
879
	public function bloquerDebloquerUtilisateur($id_annuaire, $id_utilisateur, $bloquer = true) {
880
 
881
		$annuaire_modele = $this->getModele('AnnuaireModele');
882
		$champs_description = $annuaire_modele->obtenirChampsDescriptionAnnuaire($id_annuaire);
883
 
884
		$valeur = '0';
885
 
886
		if($bloquer) {
887
			$valeur = '1';
888
		}
889
 
890
		$metadonne_modele = $this->getModele('MetadonneeModele');
891
		$metadonne_modele->modifierValeurMetadonnee($champs_description[1]['champ_statut'],$id_utilisateur,$valeur);
892
 
893
		return $this->afficherFicheUtilisateur($id_annuaire, $id_utilisateur);
894
	}
895
 
34 aurelien 896
	/**
897
	 * Affiche le formulaire permettant d'entrer un mail et de recevoir le mot de passe
898
	 * associé sur cette adresse
899
	 * @param int $id_annuaire l'identifiant de l'annuaire associé
900
	 */
19 aurelien 901
	public function afficherFormulaireOubliMotDePasse($id_annuaire) {
5 aurelien 902
 
19 aurelien 903
		$donnees['aa_id_annuaire'] = $id_annuaire;
5 aurelien 904
 
19 aurelien 905
		return $this->getVue(Config::get('dossier_squelettes_formulaires').'oubli_mdp',$donnees);
906
	}
4 aurelien 907
 
34 aurelien 908
	/**
909
	 * Supprime l'ancien mot de passe d'un utilisateur et crée un nouveau mot de passe
910
	 * aléatoire qui sera envoyé par mail
911
	 * @param int $id_annuaire l'identifiant de l'annuaire associé
912
	 * @param int $mail le mail auquel on envoie le mot de passe
913
	 *
914
	 */
19 aurelien 915
	public function reinitialiserMotDePasse($id_annuaire, $mail) {
4 aurelien 916
 
19 aurelien 917
		$this->chargerModele('AnnuaireModele');
918
		$verificateur = new VerificationControleur('VerificationControleur');
4 aurelien 919
 
19 aurelien 920
		$donnees = array();
34 aurelien 921
 
19 aurelien 922
		if(!$verificateur->mailValide($mail) || !$this->AnnuaireModele->utilisateurExisteParMail($id_annuaire,$mail)) {
923
			$donnees['erreurs']['mail'] = 'Cet utilisateur n\'existe pas';
924
			$donnees['aa_id_annuaire'] = $id_annuaire;
925
			return $this->getVue(Config::get('dossier_squelettes_formulaires').'oubli_mdp',$donnees);
926
		}
4 aurelien 927
 
19 aurelien 928
		$nouveau_mdp = $this->AnnuaireModele->reinitialiserMotDePasse($id_annuaire, $mail);
929
 
930
		if(!$nouveau_mdp) {
931
			$donnees['erreurs']['mdp'] = 'Impossible de générer un nouveau mot de passe';
932
			$donnees['aa_id_annuaire'] = $id_annuaire;
933
			return $this->getVue('oubli_mdp',$donnees);
934
		}
935
 
936
		$donnees['nouveau_mdp'] = $nouveau_mdp;
937
 
938
		return $this->envoyerMailOubliMdp($id_annuaire,$mail , $nouveau_mdp);
4 aurelien 939
	}
940
 
34 aurelien 941
	/**
942
	 * Supprime l'inscription d'un utilisateur dans un annuaire donné
943
	 * @param int $id_annuaire l'identifiant de l'annuaire associé
944
	 * @param int $id_utilisateur l'identifiant de l'utilisateur à supprimer
945
	 */
19 aurelien 946
	public function supprimerInscription($id_annuaire, $id_utilisateur) {
4 aurelien 947
 
19 aurelien 948
		$this->chargerModele('AnnuaireModele');
949
		$champs_mappage = $this->obtenirChampsMappageAnnuaire($id_annuaire);
950
		$suppression_inscription = $this->AnnuaireModele->supprimerInscriptionDansAnnuaireMappe($id_annuaire, $id_utilisateur);
4 aurelien 951
 
34 aurelien 952
		$mail_utilisateur = $this->AnnuaireModele->obtenirMailParId($id_utilisateur);
953
 
19 aurelien 954
		$donnees = array('erreurs' => array());
4 aurelien 955
 
19 aurelien 956
		$this->chargerModele('MetadonneeModele');
957
 		$suppression_metadonnees = $this->MetadonneeModele->supprimerValeursMetadonneesParIdEnregistrementLie($id_utilisateur);
958
 
959
		if(!$suppression_inscription || !$suppression_metadonnees) {
960
			$donnees['erreurs']['inscription'] = $suppression_inscription;
961
			$donnees['erreurs']['metadonnees'] = $suppression_metadonnees;
962
			$donnees['erreurs']['titre'] = 'Impossible de supprimer l\'inscription ';
963
 
964
			return $this->getVue(Config::get('dossier_squelettes_elements').'erreurs',$donnees);
4 aurelien 965
		}
966
 
34 aurelien 967
		// on appelle les controleur de lettre actu et d'applications externes
968
		$appli_controleur = new ApplicationExterneControleur();
969
		$appli_controleur->supprimerInscription($id_utilisateur, $mail_utilisateur);
970
 
971
		// pour qu'ils lancent les procédures de désinscription associées
972
		$lettre_controleur = new LettreControleur();
973
		$lettre_controleur->desinscriptionLettreActualite($mail_utilisateur);
974
 
19 aurelien 975
		return $this->index();
976
	}
977
 
34 aurelien 978
	/**
979
	 * Affiche le formulaire de recherche pour un annuaire donné ou en génère un à la volée
980
	 * @param int $id_annuaire l'identifiant de l'annuaire
981
	 * @param array $donnees des données utilisées pour pré remplir le formulaire
982
	 * @return string le html contenant le formulaire de recherche
983
	 */
19 aurelien 984
	public function afficherFormulaireRecherche($id_annuaire, $donnees = array()) {
985
 
986
		$this->chargerModele('AnnuaireModele');
987
		$annuaire = $this->AnnuaireModele->chargerAnnuaire($id_annuaire, false);
988
 
989
		$this->chargerModele('MetadonneeModele');
990
		$metadonnees = $this->MetadonneeModele->chargerListeMetadonneeAnnuaire($id_annuaire);
991
 
992
		$donnees['aa_id_annuaire'] = $id_annuaire;
993
 
994
		// TODO: ceci charge toutes les métadonnées, voir si l'on ne peut pas parser le formulaire
995
		// pour ne charger que ce qui est nécéssaire
996
 
34 aurelien 997
		foreach($metadonnees as $nom_champ => $metadonnee) {
19 aurelien 998
 
34 aurelien 999
			//echo $nom_champ;
1000
 
19 aurelien 1001
			$id_champ = $metadonnee['amc_id_champ'];
34 aurelien 1002
			$type_champ = $metadonnee['amc_ce_template_affichage'];
19 aurelien 1003
			$nom_champ = $metadonnee['amc_abreviation'];
1004
 
34 aurelien 1005
			if(isset($donnees[$type_champ.'_'.$id_champ])) {
1006
				$metadonnee['valeur_defaut']['amv_valeur'] = $donnees[$type_champ.'_'.$id_champ];
1007
			}
1008
 
19 aurelien 1009
			$metadonnee['aa_id_annuaire'] = $id_annuaire;
1010
			// on charge le formulaire d'affichage de chacune des métadonnées
1011
			$donnees['champs'][$nom_champ] = $this->afficherFormulaireChampMetadonnees($id_champ,$metadonnee);
4 aurelien 1012
		}
1013
 
19 aurelien 1014
		// Si le formulaire spécifique à l'annuaire existe, on l'affiche
34 aurelien 1015
		if(!$this->templateExiste($annuaire['informations']['aa_code'].'_recherche','/formulaires/')) {
1016
			$formulaire_recherche = $this->genererFormulaireRecherche($donnees);
19 aurelien 1017
		} else {
1018
			// Sinon on prend celui par defaut
1019
			$formulaire_recherche = $this->GetVue(Config::get('dossier_squelettes_formulaires').$annuaire['informations']['aa_code'].'_recherche',$donnees);
4 aurelien 1020
		}
1021
 
19 aurelien 1022
		return $formulaire_recherche;
4 aurelien 1023
	}
1024
 
19 aurelien 1025
	/**
1026
	 * Recherche un ou plusieurs inscrits selon les valeurs passées en paramètres, qui peuvent êtres des valeurs
1027
	 * dans l'annuaire mappé ou bien des valeurs de metadonnées
1028
	 * @param int $id_annuaire l'identifiant de l'annuaire
1029
	 * @param array $valeurs_recherchees les valeurs à rechercher
1030
	 * @param boolean $exclusive indique si la recherche si fait sur tous les critères ou bien sur au moins un
1031
	 * @param int $numero_page le numero de page demandé
1032
	 * @param int $taille_page la taille de page
1033
	 */
1034
	public function rechercherInscrit($id_annuaire,$valeurs_recherchees, $exclusive = true,  $numero_page = 1, $taille_page = 50) {
7 aurelien 1035
 
19 aurelien 1036
		$this->chargerModele('AnnuaireModele');
1037
		$annuaire = $this->AnnuaireModele->chargerAnnuaire($id_annuaire, true);
7 aurelien 1038
 
53 aurelien 1039
		if(isset($_GET['numero_page'])) {
1040
			$numero_page = $_GET['numero_page'];
1041
		}
1042
 
1043
		if(isset($_GET['taille_page'])) {
1044
			$taille_page = $_GET['taille_page'];
1045
		}
1046
 
19 aurelien 1047
		$tableau_mappage = $this->AnnuaireModele->obtenirChampsMappageAnnuaire($id_annuaire);
7 aurelien 1048
 
19 aurelien 1049
		$valeurs_mappees = array();
1050
		$valeurs = array();
7 aurelien 1051
 
19 aurelien 1052
		// on itère sur le tableau de valeur pour récupérer les métadonnées;
1053
		foreach($valeurs_recherchees as $nom_champ => $valeur) {
1054
 
1055
			// pour chaque valeur
1056
			// on extrait l'id du champ
1057
			$ids_champ = mb_split("_",$nom_champ);
1058
 
1059
			if(count($ids_champ) == 2) {
1060
 
1061
				// l'identifiant du champ est la dernière valeur du tableau
1062
				$type = $ids_champ[0];
1063
				$id_champ = $ids_champ[1];
1064
 
1065
				// Si le champ fait partie des champs mappés
1066
				$cle_champ = array_search($id_champ, $tableau_mappage[1]);
1067
				if($cle_champ) {
1068
					// on ajoute sa clé correspondante dans l'annuaire mappé et sa valeur dans le tableau des champs mappés
1069
					$valeurs_mappees[$tableau_mappage[0][$cle_champ]] = $valeur;
1070
					// et on supprime sa valeur du tableau de valeurs pour ne pas la retrouver lors
1071
					// de l'insertion des métadonnées
7 aurelien 1072
				} else {
19 aurelien 1073
					$valeurs_recherchees[$id_champ] = $valeur;
7 aurelien 1074
				}
19 aurelien 1075
				// on retire la valeur du tableau pour ne pas la retrouver dans les deux recherches
34 aurelien 1076
				$valeurs_get[$nom_champ] = $valeur;
19 aurelien 1077
			}
7 aurelien 1078
 
19 aurelien 1079
			unset($valeurs_recherchees[$nom_champ]);
7 aurelien 1080
		}
1081
 
56 aurelien 1082
		$admin = Registre::getInstance()->get('est_admin');
1083
 
1084
		//if(!$admin) {
1085
		//	$champs_blocage = $this->AnnuaireModele->obtenirChampsDescriptionAnnuaire($id_annuaire);
1086
		//	$valeurs_recherchees[$champs_blocage[1]['champ_statut']] = '0';
1087
		//}
1088
 
19 aurelien 1089
		$champ_id_annuaire = $tableau_mappage[0]['champ_id'];
7 aurelien 1090
 
19 aurelien 1091
		// on recherche dans les métadonnées
1092
		$this->chargerModele('MetadonneeModele');
1093
		// le résultat est un ensemble d'identifiants
1094
		$resultat_metadonnees = $this->MetadonneeModele->rechercherDansValeurMetadonnees($id_annuaire,$valeurs_recherchees, $exclusive);
11 aurelien 1095
 
19 aurelien 1096
		// on recherche les infos dans la table annuaire mappée
1097
		// en incluant ou excluant les id déjà trouvées dans les metadonnées
1098
		// suivant le critères d'exclusivité ou non
53 aurelien 1099
		$resultat_annuaire_mappe = $this->AnnuaireModele->rechercherInscritDansAnnuaireMappe($id_annuaire,$valeurs_mappees, $resultat_metadonnees, $exclusive, $numero_page, $taille_page);
11 aurelien 1100
 
53 aurelien 1101
		$resultat_recherche = $resultat_annuaire_mappe['resultat'];
11 aurelien 1102
 
53 aurelien 1103
		$nb_resultats = $resultat_annuaire_mappe['total'];
11 aurelien 1104
 
19 aurelien 1105
		// on renvoie une liste identique à celle de la liste des inscrits
1106
		$donnees['resultats_recherche'] = $resultat_recherche;
1107
		$donnees['tableau_mappage'] = $tableau_mappage[0];
1108
		$donnees['id_annuaire'] = $id_annuaire;
1109
		$donnees['nb_resultats'] = $nb_resultats;
11 aurelien 1110
 
34 aurelien 1111
		$url_base = new URL(Registre::getInstance()->get('base_url_application'));
53 aurelien 1112
		$url_pagination = clone($url_base);
11 aurelien 1113
 
53 aurelien 1114
		$valeurs_get['id_annuaire'] = $id_annuaire;
1115
		$valeurs_get['m'] = $_GET['m'];
1116
 
34 aurelien 1117
		$donnees['pagination'] = $this->paginer($numero_page,$taille_page,$nb_resultats,$url_pagination, $valeurs_get);
1118
		$vue_resultat_recherche = $this->getVue(Config::get('dossier_squelettes_annuaires').'annuaire_resultat_recherche', $donnees);
1119
 
1120
		return $this->afficherFormulaireRecherche($id_annuaire, $valeurs_get).$vue_resultat_recherche;
1121
	}
1122
 
1123
	/** Recherche un ou plusieurs inscrits selon des indications géographiques, qui peuvent êtres des valeurs
1124
	 * dans l'annuaire mappé ou bien des valeurs de metadonnées
1125
	 * @param int $id_annuaire l'identifiant de l'annuaire
1126
	 * @param array $valeurs_recherchees les valeurs à rechercher
1127
	 * @param boolean $exclusive indique si la recherche si fait sur tous les critères ou bien sur au moins un
1128
	 * @param int $numero_page le numero de page demandé
1129
	 * @param int $taille_page la taille de page
1130
	 */
1131
	public function rechercherInscritParlocalisation($id_annuaire,$valeurs_recherchees, $numero_page = 1, $taille_page = 50) {
1132
 
53 aurelien 1133
		if(isset($_GET['taille_page'])) {
1134
			$taille_page = $_GET['taille_page'];
1135
		} else  {
1136
			$taille_page = 50;
1137
		}
1138
 
1139
		if(isset($_GET['numero_page'])) {
1140
			$numero_page = $_GET['numero_page'];
1141
		} else {
1142
			$numero_page = 1;
1143
		}
1144
 
34 aurelien 1145
		$this->chargerModele('AnnuaireModele');
1146
		$annuaire = $this->AnnuaireModele->chargerAnnuaire($id_annuaire, true);
1147
 
1148
		$tableau_mappage = $this->AnnuaireModele->obtenirChampsMappageAnnuaire($id_annuaire);
1149
 
1150
		$valeurs_get = $valeurs_recherchees;
1151
 
1152
		$valeurs_mappees = array();
1153
		$valeurs = array();
1154
 
1155
		$champ_id_annuaire = $tableau_mappage[0]['champ_id'];
1156
 
53 aurelien 1157
		$valeur = $valeurs_recherchees['pays'];
56 aurelien 1158
		$champ_critere = $tableau_mappage[0]['champ_pays'];
34 aurelien 1159
 
56 aurelien 1160
		if(isset($valeurs_recherchees['departement'])) {
1161
			$valeur = $valeurs_recherchees['departement'];
1162
			$champ_critere = $tableau_mappage[0]['champ_code_postal'];
1163
		}
1164
 
53 aurelien 1165
		//Debug::printr($valeurs_get);
34 aurelien 1166
 
53 aurelien 1167
		$resultat_annuaire_mappe = $this->AnnuaireModele->rechercherInscritDansAnnuaireMappeParChamp($id_annuaire, $champ_critere, $valeur, true, $taille_page, $numero_page);
1168
 
1169
		/*
1170
		// on recherche dans les métadonnées
1171
		$this->chargerModele('MetadonneeModele');
1172
		// le résultat est un ensemble d'identifiants
1173
		$resultat_metadonnees = $this->MetadonneeModele->rechercherDansValeurMetadonnees($id_annuaire,$valeurs_recherchees, false);
1174
		*/
1175
 
34 aurelien 1176
		// on recherche les infos dans la table annuaire mappée
1177
		// en incluant ou excluant les id déjà trouvées dans les metadonnées
1178
		// suivant le critères d'exclusivité ou non
1179
		//$resultat_annuaire_mappe = $this->AnnuaireModele->rechercherInscritDansAnnuaireMappe($id_annuaire,$valeurs_mappees, $resultat_metadonnees, $exclusive);
1180
 
1181
		$resultat_recherche = $resultat_annuaire_mappe;
1182
 
53 aurelien 1183
		$nb_resultats = $resultat_recherche['total'];
1184
		$inscrits_resultats = $resultat_recherche['resultat'];
34 aurelien 1185
 
1186
		// on renvoie une liste identique à celle de la liste des inscrits
53 aurelien 1187
		$donnees['resultats_recherche'] = $inscrits_resultats;
34 aurelien 1188
		$donnees['tableau_mappage'] = $tableau_mappage[0];
1189
		$donnees['id_annuaire'] = $id_annuaire;
1190
		$donnees['nb_resultats'] = $nb_resultats;
1191
 
53 aurelien 1192
		//Debug::printr($donnees['resultats_recherche']);
1193
 
34 aurelien 1194
		$url_base = new URL(Registre::getInstance()->get('base_url_application'));
19 aurelien 1195
		$url_pagination = new URL($url_base);
1196
 
34 aurelien 1197
		$donnees['pagination'] = $this->paginer($numero_page,$taille_page,$nb_resultats,$url_pagination, $valeurs_get);
19 aurelien 1198
		$vue_resultat_recherche = $this->getVue(Config::get('dossier_squelettes_annuaires').'annuaire_resultat_recherche', $donnees);
1199
 
34 aurelien 1200
		return $vue_resultat_recherche;
11 aurelien 1201
	}
1202
 
19 aurelien 1203
 
56 aurelien 1204
/** ---------------------------------    Fonction d'extraction d'informations utilisées par les web services -------------------------------------------*/
1205
 
1206
	public function utilisateurExiste($id_annuaire,$id, $utilise_mail = true) {
1207
 
1208
		$this->chargerModele('AnnuaireModele');
1209
 
1210
		if($utilise_mail) {
1211
			$existe = $this->AnnuaireModele->utilisateurExisteParMail($id_annuaire,$id);
1212
		} else {
1213
			$existe = $this->AnnuaireModele->utilisateurExisteParId($id_annuaire,$id);
1214
		}
1215
 
1216
		return $existe;
1217
	}
1218
 
1219
	public function obtenirInfosUtilisateurOpenId($id_annuaire,$id, $mail = true) {
1220
 
1221
		$this->chargerModele('AnnuaireModele');
1222
 
1223
		if($mail) {
1224
			$id = $this->AnnuaireModele->obtenirIdParMail($id_annuaire,$id);
1225
		}
1226
 
1227
		$champs_mappage = $this->AnnuaireModele->obtenirChampsMappageAnnuaire($id_annuaire);
1228
 
1229
		$valeurs = $this->AnnuaireModele->obtenirValeursUtilisateur($id_annuaire,$id, $champs_mappage[0]);
1230
 
1231
		$valeurs_open_id = array('fullname' => $valeurs[$champs_mappage[0]['champ_nom']].' '.$valeurs[$champs_mappage[0]['champ_prenom']],
1232
                           'nickname' => $valeurs[$champs_mappage[0]['champ_nom']],
1233
                           'dob' => '25/10/1984',
1234
                           'email' => $valeurs[$champs_mappage[0]['champ_mail']],
1235
                           'gender' => 'M',
1236
                           'postcode' => $valeurs[$champs_mappage[0]['champ_code_postal']],
1237
                           'country' => 'FR',
1238
                           'language' => 'fr',
1239
                           'timezone' => 'Europe/Paris');
1240
 
1241
		return $valeurs_open_id;
1242
	}
1243
 
1244
	public function comparerIdentifiantMotDePasse($id_annuaire,$id_utilisateur,$mot_de_passe, $utilise_mail = true, $mdp_deja_crypte = true) {
1245
 
1246
		$this->chargerModele('AnnuaireModele');
1247
 
1248
		if($utilise_mail) {
1249
			$id_utilisateur = $this->AnnuaireModele->obtenirIdParMail($id_annuaire,$id_utilisateur);
1250
		}
1251
 
1252
		if(!$mdp_deja_crypte) {
1253
			$mdp_deja_crypte = VerificationControleur::encrypterMotDePasseStatic($mot_de_passe);
1254
		}
1255
 
1256
		return $this->AnnuaireModele->comparerIdentifiantMotDePasse($id_annuaire,$id_utilisateur,$mot_de_passe);
1257
	}
1258
 
1259
 
19 aurelien 1260
/** ---------------------------------    Fonction privées -------------------------------------------*/
1261
 
4 aurelien 1262
	/**
19 aurelien 1263
	 * En cas de tentative d'inscription, envoie un mail contenant un lien de confirmation à l'utilisateur
1264
	 * @param string $adresse_mail adresse mail
1265
	 * @param string $nom nom
1266
	 * @param string $prenom prénom
1267
	 * @param string $code_confirmation_inscription code de confirmation à inclure dans le mail
1268
	 *
1269
	 * @return boolean le succès ou l'échec de l'envoi du mail
4 aurelien 1270
	 */
19 aurelien 1271
	private function envoyerMailConfirmationInscription($adresse_mail, $nom, $prenom, $code_confirmation_inscription) {
4 aurelien 1272
 
19 aurelien 1273
		$base_url = clone(Registre::getInstance()->get('base_url_application'));
4 aurelien 1274
 
19 aurelien 1275
		$base_url->setVariableRequete('m','annuaire_inscription_confirmation');
1276
		$base_url->setVariableRequete('id',$code_confirmation_inscription);
1277
 
1278
		$donnees = array('nom' => $nom, 'prenom' => $prenom, 'lien_confirmation_inscription' => $base_url->getURL());
1279
		$contenu_mail = $this->getVue(Config::get('dossier_squelettes_mails').'mail_confirmation_inscription',$donnees);
1280
 
1281
		 // Pour envoyer un mail HTML, l'en-tête Content-type doit être défini
1282
	     $entetes  = 'MIME-Version: 1.0' . "\r\n";
1283
	     $entetes .= 'Content-type: text/html; charset='.Config::get('appli_encodage'). "\r\n";
1284
	     // En-têtes additionnels
1285
	     $entetes .= 'To: '.$adresse_mail."\r\n";
1286
	     $entetes .= 'From: '.Config::get('adresse_mail_annuaire')."\r\n";
1287
 
1288
		return mail($adresse_mail,'Inscription à l\'annuaire',$contenu_mail, $entetes);
1289
 
4 aurelien 1290
	}
7 aurelien 1291
 
19 aurelien 1292
	 /** En cas d'oubli de mot de passe, régénère le mot de passe et envoie un mail à l'utilisateur
1293
	 * @param int $id_annuaire l'identifiant d'annuaire
1294
	 * @param string $adresse_mail adresse mail
1295
	 * @return boolean le succès ou l'échec de l'envoi du mail
1296
	 */
1297
	private function envoyerMailOubliMdp($id_annuaire,$mail, $nouveau_mdp) {
1298
 
1299
		$base_url = clone(Registre::getInstance()->get('base_url_application'));
1300
 
1301
		$base_url->setVariableRequete('m','annuaire_fiche_utilisateur_consultation');
1302
		$base_url->setVariableRequete('id',1);
1303
 
1304
		$donnees['nouveau_mdp'] = $nouveau_mdp;
1305
		$donnees['lien_profil'] = $base_url;
1306
 
1307
		$contenu_mail = $this->getVue(Config::get('dossier_squelettes_mails').'mail_oubli_mdp',$donnees);
1308
 
1309
		 // Pour envoyer un mail HTML, l'en-tête Content-type doit être défini
1310
	     $entetes  = 'MIME-Version: 1.0' . "\r\n";
1311
	     $entetes .= 'Content-type: text/html; charset='.Config::get('appli_encodage'). "\r\n";
1312
	     // En-têtes additionnels
1313
	     $entetes .= 'To: '.$mail."\r\n";
1314
	     $entetes .= 'From: '.Config::get('adresse_mail_annuaire')."\r\n";
1315
 
1316
		 return mail($mail,'Inscription à l\'annuaire',$contenu_mail, $entetes);
1317
 
1318
	}
1319
 
7 aurelien 1320
	/**
19 aurelien 1321
	 * Insère les données dans la table d'inscription temporaire et crée un code de confirmation (à insérer dans le mail)
1322
	 * @param Array $valeurs les valeurs à insérer
7 aurelien 1323
	 */
19 aurelien 1324
	private function InsererDansTableTemporaireEtCreerCodeConfirmationInscription($valeurs) {
7 aurelien 1325
 
19 aurelien 1326
		// Le code de confirmation est constitué des 8 premiers caractères de l'identifiant de session
1327
		$code_confirmation = substr(session_id(), 0, 8) ;
7 aurelien 1328
 
19 aurelien 1329
		$this->chargerModele('AnnuaireModele');
1330
 
1331
		if(!$this->AnnuaireModele->ajouterNouvelleInscriptionTemporaire($code_confirmation, $valeurs)) {
1332
			return false;
7 aurelien 1333
		}
19 aurelien 1334
 
1335
		return $code_confirmation;
7 aurelien 1336
	}
1337
 
19 aurelien 1338
 
1339
/**--------------------------- Fonctions de vérification et de correspondance des champs --------------------*/
1340
 
7 aurelien 1341
	/**
19 aurelien 1342
	 * Renvoie les champs de mappage correspondant à un annuaire donné
1343
	 * @param int $id_annuaire l'indentifant de l'annuaire pour lequel on veut ces informations
1344
	 * @return Array un tableau de mappage des champs
1345
	 *
1346
	 */
1347
	private function obtenirChampsMappageAnnuaire($id_annuaire) {
1348
 
1349
		$this->chargerModele('AnnuaireModele');
1350
		$tableau_mappage = $this->AnnuaireModele->obtenirChampsMappageAnnuaire($id_annuaire);
1351
 
1352
		return $tableau_mappage;
1353
	}
1354
 
1355
	/**
7 aurelien 1356
	 * Renvoie le formulaire demandé s'il existe, sinon faux
1357
	 * @param string $nom_formulaire le nom du formulaire demandé (qui est normalement le code d'un annuaire)
1358
	 * @return boolean true si le formulaire existe, false sinon
1359
	 */
1360
	private function formulaireExiste($nom_formulaire) {
1361
 
19 aurelien 1362
		return $this->templateExiste($nom_formulaire.'_inscription', Config::get('dossier_squelettes_formulaires'));
7 aurelien 1363
	}
1364
 
1365
	/**
19 aurelien 1366
	 * Renvoie le template demandé s'il existe, sinon faux
1367
	 * @param string $nom_formulaire le nom du formulaire demandé (qui est normalement le code d'un annuaire)
1368
	 * @param string $dossier le nom du dossier sous dossier demandé
1369
	 * @return boolean true si le formulaire existe, false sinon
1370
	 */
1371
	private function templateExiste($nom_template, $dossier = '/') {
34 aurelien 1372
 
19 aurelien 1373
		return file_exists(Config::get('chemin_squelettes').$dossier.$nom_template.'.tpl.html');
1374
	}
1375
 
1376
	/**
7 aurelien 1377
	 * Renvoie un formulaire d'inscription minimal auto-généré
1378
	 * @param string $donnees les donnée à inclure dans le formulaire
1379
	 * @return string la vue contenant le formulaire généré
1380
	 */
11 aurelien 1381
	private function genererFormulaireInscription($donnees) {
7 aurelien 1382
 
11 aurelien 1383
		$formulaire_modele = $this->getVue(Config::get('dossier_squelettes_formulaires').'inscription',$donnees);
7 aurelien 1384
 
1385
		if($formulaire_modele) {
1386
			return $formulaire_modele;
1387
		} else {
1388
			trigger_error("impossible de trouver le squelette de référence pour le formulaire");
1389
		}
1390
 
1391
		return false;
1392
	}
11 aurelien 1393
 
1394
	/**
34 aurelien 1395
	 * Renvoie un formulaire d'inscription minimal auto-généré
1396
	 * @param string $donnees les donnée à inclure dans le formulaire
1397
	 * @return string la vue contenant le formulaire généré
1398
	 */
1399
	private function genererFormulaireRecherche($donnees) {
1400
 
1401
		$formulaire_modele = $this->getVue(Config::get('dossier_squelettes_formulaires').'recherche',$donnees);
1402
 
1403
		if($formulaire_modele) {
1404
			return $formulaire_modele;
1405
		} else {
1406
			trigger_error("impossible de trouver le squelette de référence pour le formulaire");
1407
		}
1408
 
1409
		return false;
1410
	}
1411
 
1412
	/**
11 aurelien 1413
	 * Renvoie le template de pagination, considérant des éléments donnés en paramètre
53 aurelien 1414
	 * @param int $numero_page le numéro de page en cours
1415
	 * @param int $taille_page la taille de page
1416
	 * @param int $total le nombre total de pages
1417
	 * @param object $url_base l'url de base de la page
1418
	 * @param array $valeurs les valeurs à concatener à l'url
1419
	 * @return string le html contenu la template de pagination rempli avec les infos
11 aurelien 1420
	 */
34 aurelien 1421
	private function paginer($numero_page = 1, $taille_page = 50, $total, $url_base, $valeurs) {
11 aurelien 1422
 
1423
		// TODO, faire plus complexe, tri alphabétique etc...
1424
		$page_precedente = $numero_page-1;
1425
		$page_suivante = $numero_page+1;
1426
 
19 aurelien 1427
		if($taille_page <= 0) {
1428
			$taille_page = 1;
1429
		}
1430
 
11 aurelien 1431
		$nombre_pages = round($total/$taille_page,'PHP_ROUND_HALF_DOWN') ;
1432
 
53 aurelien 1433
		foreach($valeurs as $cle => $variable) {
1434
			$url_base->setVariableRequete($cle,$variable);
1435
		}
11 aurelien 1436
 
1437
		if($numero_page < 2) {
1438
			$page_precedente = false;
53 aurelien 1439
			$url_page_precedente = '';
1440
		} else {
1441
			$url_page_prec = clone($url_base);
1442
				$url_page_prec->setVariableRequete('numero_page',($page_precedente));
1443
				$url_page_prec->setVariableRequete('taille_page',($taille_page));
1444
				$url_page_precedente = $url_page_prec->getUrl();
11 aurelien 1445
		}
1446
 
1447
		if($taille_page*($numero_page) >= $total) {
1448
			$page_suivante = false;
53 aurelien 1449
			$url_page_suivante = '';
1450
		} else {
1451
			$url_page_suiv = clone($url_base);
1452
				$url_page_suiv->setVariableRequete('numero_page',($page_suivante));
1453
				$url_page_suiv->setVariableRequete('taille_page',($taille_page));
1454
				$url_page_suivante = $url_page_suiv->getUrl();
11 aurelien 1455
		}
1456
 
56 aurelien 1457
		$url_pages = array();
53 aurelien 1458
 
1459
		for($i = 1; $i <= $nombre_pages ; $i++) {
1460
 
1461
				$url_page_prev = clone($url_base);
1462
				$url_page_prev->setVariableRequete('numero_page',($i));
1463
				$url_page_prev->setVariableRequete('taille_page',($taille_page));
1464
				$url_pages[$i] = $url_page_prev->getUrl();
34 aurelien 1465
		}
1466
 
53 aurelien 1467
 
1468
 
1469
		$donnees = array('url_pages' => $url_pages, 'numero_page' => $numero_page,
1470
							'page_precedente' => $page_precedente, 'page_suivante' => $page_suivante,
1471
							'url_page_precedente' => $url_page_precedente, 'url_page_suivante' => $url_page_suivante,
1472
							'nombre_pages' => $nombre_pages, 'taille_page' => $taille_page);
34 aurelien 1473
		$donnees['base_url_pagination'] = $url_base;
11 aurelien 1474
 
1475
		return $this->getVue(Config::get('dossier_squelettes_elements').'pagination',$donnees);
1476
	}
1477
 
19 aurelien 1478
 
1479
/** --- Fonction pour les images ------------------------------------------------------------------------*/
1480
 
53 aurelien 1481
	public function afficherFormulaireUploadImage($id_annuaire,$id_utilisateur, $donnees = array()) {
11 aurelien 1482
 
1483
		$donnees['aa_id_annuaire'] = $id_annuaire;
1484
		$donnees['id_utilisateur'] = $id_utilisateur;
1485
 
1486
		$donnees['amc_nom'] = 'Avatar';
1487
 
53 aurelien 1488
		$this->chargerModele('AnnuaireModele');
1489
		$id_champ_image = $this->AnnuaireModele->obtenirChampAvatar($id_annuaire);
11 aurelien 1490
 
53 aurelien 1491
		if(!$id_champ_image) {
1492
			$donnees['erreurs'] = 'Aucun champ n\'est défini pour l\'image de profil';
1493
			return $this->getVue(Config::get('dossier_squelettes_elements').'erreurs',$donnees);
1494
		}
1495
 
1496
		$donnees['amc_id_champ'] = $id_champ_image;
1497
 
11 aurelien 1498
		return $this->getVue(Config::get('dossier_squelettes_champs').'image',$donnees);
1499
	}
1500
 
1501
	/**
1502
	 * Ajoute une image uploadée à travers le formulaire
1503
	 *
1504
	 */
19 aurelien 1505
	public function ajouterImageUtilisateur($id_annuaire, $id_utilisateur, $fichier_a_stocker, $retourner_booleen = false) {
11 aurelien 1506
 
53 aurelien 1507
		$donnees = array('erreurs' => array());
1508
 
11 aurelien 1509
		foreach($fichier_a_stocker as $nom_champ => $fichier) {
1510
 
1511
			$ids_champ = mb_split("_",$nom_champ, 3);
1512
 
1513
			if(count($ids_champ) == 2) {
1514
 
1515
				$type = $ids_champ[0];
1516
				$id_champ = $ids_champ[1];
1517
 
65 aurelien 1518
 
11 aurelien 1519
			} else {
1520
				trigger_error('Ce champ n\'est pas relié à un annuaire');
1521
				return false;
1522
			}
1523
 
1524
			$this->chargerModele('ImageModele');
53 aurelien 1525
 
1526
			$format_accepte = $this->ImageModele->verifierFormat($fichier['name']);
1527
 
1528
			if(!$format_accepte) {
1529
				$donnees['erreurs'][$id_champ] = 'Cette extension de fichier n\'est pas prise en charge';
1530
				return $this->afficherFormulaireUploadImage($id_annuaire, $id_utilisateur,$id_champ,$donnees);
1531
			}
1532
 
11 aurelien 1533
			$stockage_image = $this->ImageModele->stockerFichier($id_annuaire, $id_utilisateur, $fichier);
1534
 
1535
			$this->chargerModele('MetadonneeModele');
1536
 
65 aurelien 1537
			if($this->MetadonneeModele->valeurExiste($id_champ,$id_utilisateur)) {
1538
				// On se contente de la modifier
1539
				if($stockage_image && $this->MetadonneeModele->modifierValeurMetadonnee($id_champ,$id_utilisateur,$id_utilisateur)) {
1540
 
1541
				} else {
1542
					$donnees['erreurs'][$id_champ] = 'Problème durant le stockage de l\'image';
1543
					return $this->afficherFormulaireUploadImage($id_annuaire, $id_utilisateur,$id_champ,$donnees);
1544
				}
1545
 
11 aurelien 1546
			} else {
65 aurelien 1547
				// S'il n'existe pas de valeur, on ajoute une nouvelle ligne à la table de valeurs de meta données
1548
				if($stockage_image && $this->MetadonneeModele->ajouterNouvelleValeurMetadonnee($id_champ,$id_utilisateur,$id_utilisateur)) {
1549
					// Si l'insertion a réussi, on continue
1550
				} else {
1551
					$donnees['erreurs'][$id_champ] = 'Problème durant le stockage de l\'image';
1552
					return $this->afficherFormulaireUploadImage($id_annuaire, $id_utilisateur,$id_champ,$donnees);
1553
				}
11 aurelien 1554
			}
1555
		}
1556
 
19 aurelien 1557
		if($retourner_booleen) {
1558
			return true;
1559
		} else {
1560
			return $this->afficherFicheUtilisateur($id_annuaire, $id_utilisateur) ;
1561
		}
11 aurelien 1562
	}
34 aurelien 1563
 
53 aurelien 1564
	public function chargerNombreAnnuaireListeInscritsParPays($id_annuaire, $id_zones) {
34 aurelien 1565
 
53 aurelien 1566
		$annuaire_modele = $this->getModele('AnnuaireModele');
1567
		return $annuaire_modele->chargerNombreAnnuaireListeInscritsParPays($id_annuaire, $id_zones);
34 aurelien 1568
	}
1569
 
1570
	public function chargerNombreAnnuaireListeInscritsParDepartement($id_annuaire) {
1571
		$this->chargerModele('AnnuaireModele');
1572
		return $this->AnnuaireModele->chargerNombreAnnuaireListeInscritsParDepartement($id_annuaire);
1573
	}
4 aurelien 1574
}
1575
?>