| 81,11 → 81,11 |
|---|
| $total_inscrits = $this->AnnuaireModele->chargerNombreAnnuaireListeInscrits($id); |
| $data['annuaire'] = $this->AnnuaireModele->chargerAnnuaireListeInscrits($id, $data['champs'][0], $numero_page, $taille_page); |
| |
| $url_base = clone(Registre::getInstance()->get('base_url_application')); |
| $url_base->setVariableRequete('m','annuaire_inscrits'); |
| $url_base->setVariableRequete('id_annuaire',$id); |
| $url_pagination = new URL(Registre::getInstance()->get('base_url_application')); |
| $url_pagination->setVariableRequete('m','annuaire_inscrits'); |
| $url_pagination->setVariableRequete('id_annuaire',$id); |
| |
| $data['pagination'] = $this->paginer($numero_page,$taille_page,$total_inscrits,$url_base); |
| $data['pagination'] = $this->paginer($numero_page,$taille_page,$total_inscrits,$url_pagination); |
| |
| $annuaires_inscrits = $this->getVue(Config::get('dossier_squelettes_annuaires').'annuaire_inscrits', $data); |
| |
| 121,12 → 121,11 |
|---|
| $donnees['champs'][$nom_champ] = $this->afficherFormulaireChampMetadonnees($id_champ,$metadonnee); |
| } |
| |
| // le nom du formulaire d'inscription est le même que le code de l'annuaire |
| // TODO: réfléchir à une meilleure manière de stocker ça |
| // Générer un fichier s'il n'existe pas ? et ensuite le lire ? |
| if(!$this->formulaireExiste($annuaire['informations']['aa_code'])) { |
| // si le formulaire existe, on le charge |
| if(!$this->formulaireExiste($annuaire['informations']['aa_code'],'inscription')) { |
| $formulaire_inscription = $this->genererFormulaireInscription($donnees); |
| } else { |
| // sinon on en génère un qui contient tous les champs |
| $formulaire_inscription = $this->GetVue(Config::get('dossier_squelettes_formulaires').$annuaire['informations']['aa_code'].'_inscription',$donnees); |
| } |
| |
| 145,9 → 144,10 |
|---|
| $this->chargerModele('OntologieModele'); |
| $donnees['liste_valeurs'] = $this->OntologieModele->chargerListeOntologie($donnees['amc_ce_ontologie']); |
| } |
| |
| $donnees['amc_id_champ'] = $id_champ; |
| $this->chargerModele('MetadonneeModele'); |
| $nom__type_champ = $this->MetadonneeModele->renvoyerCorrespondanceNomTemplateChamp($donnees['amc_ce_type_affichage']); |
| $nom__type_champ = $this->MetadonneeModele->renvoyerTypeAffichageParId($donnees['amc_ce_type_affichage']); |
| return $this->getVue(Config::get('dossier_squelettes_champs').$nom__type_champ,$donnees); |
| } |
| |
| 168,6 → 168,8 |
|---|
| $tableau_mappage = $this->obtenirChampsMappageAnnuaire($id_annuaire); |
| $valeurs_mappees = array(); |
| |
| $verificateur = new VerificationControleur(); |
| |
| // on itère sur le tableau de valeur pour récupérer les champs de mappage; |
| foreach($valeurs as $nom_champ => $valeur) { |
| |
| 179,17 → 181,20 |
|---|
| |
| $type = $ids_champ[0]; |
| $id_champ = $ids_champ[2]; |
| $confirmation = $ids_champ[2]; |
| $condition = $ids_champ[1]; |
| |
| // cas de la checkbox qui devrait être là mais pas cochée |
| if($condition == 'hidden' && !isset($valeurs[$type.'_'.$id_champ])) { |
| // dans ce cas là on fabrique une valeur vide |
| $valeurs[$type.'_'.$id_champ] = 0; |
| } |
| |
| } else { |
| $type = $ids_champ[0]; |
| $confirmation = false; |
| $condition = false; |
| $id_champ = $ids_champ[1]; |
| } |
| |
| // on fait des vérifications et des remplacements sur certaines valeurs |
| $valeurs[$nom_champ] = $this->verifierEtRemplacerValeurChamp($type,$valeur,$confirmation); |
| |
| // Si le champ fait partie des champs mappés |
| $cle_champ = array_search($id_champ, $tableau_mappage[1]); |
| |
| 196,22 → 201,23 |
|---|
| if($cle_champ) { |
| // on ajoute sa clé correspondante dans le tableau des champs mappés |
| // qui sont les champs à vérifier |
| if($confirmation) { |
| $valeurs_mappees[$cle_champ.'_conf'] = $valeur; |
| if($condition) { |
| $valeurs_mappees[$cle_champ.$condition] = $valeur; |
| } else { |
| $valeurs_mappees[$cle_champ] = $valeur; |
| } |
| |
| } |
| } |
| |
| // vérification des champs minimaux : nom, prénom, mail, mot de passe |
| // TODO: des champs minimaux différents pour chaque annuaire ? comment les stocke t'on ? |
| if($erreurs = $this->verifierErreursChamps($id_annuaire,$valeurs_mappees, $tableau_mappage)) { |
| if($erreurs = $verificateur->verifierErreursChamps($id_annuaire,$valeurs_mappees, $tableau_mappage)) { |
| $valeurs['erreurs'] = $erreurs; |
| return $this->afficherFormulaireInscription($id_annuaire, $valeurs); |
| } |
| |
| $valeurs['aa_id_annuaire'] = $id_annuaire ; |
| |
| $code_confirmation = $this->InsererDansTableTemporaireEtCreerCodeConfirmationInscription($valeurs); |
| |
| $this->envoyerMailConfirmationInscription($valeurs_mappees['champ_mail'], |
| 237,25 → 243,48 |
|---|
| // TODO afficher vue en cas d'echec |
| } |
| |
| //$id_annuaire = $valeurs['aa_id_annuaire']; |
| $id_annuaire = $valeurs['aa_id_annuaire']; |
| unset($valeurs['aa_id_annuaire']); |
| |
| $id_annuaire = 1; |
| |
| $this->chargerModele('MetadonneeModele'); |
| |
| $verificateur = new VerificationControleur(); |
| |
| $tableau_mappage = $this->obtenirChampsMappageAnnuaire($id_annuaire); |
| |
| $valeurs_mappees = array(); |
| |
| $mail_nouvel_inscrit = $valeurs['text_'.$tableau_mappage[1]['champ_mail']]; |
| |
| // on itère sur le tableau de valeur pour récupérer les métadonnées; |
| foreach($valeurs as $nom_champ => $valeur) { |
| |
| // pour chaque valeur |
| // on extrait l'id du champ |
| $ids_champ = mb_split("_",$nom_champ); |
| $id_champ = $ids_champ[count($ids_champ) - 1]; |
| $ids_champ = mb_split("_",$nom_champ, 3); |
| |
| if(count($ids_champ) == 3) { |
| |
| $type = $ids_champ[0]; |
| $id_champ = $ids_champ[2]; |
| $condition = $ids_champ[1]; |
| |
| // cas de la checkbox qui devrait être là mais pas cochée |
| if($condition == 'hidden' && !isset($valeurs[$type.'_'.$id_champ])) { |
| // dans ce cas là on fabrique une valeur vide |
| $valeurs[$type.'_'.$id_champ] = 0; |
| } |
| |
| } else { |
| $type = $ids_champ[0]; |
| $condition = false; |
| $id_champ = $ids_champ[1]; |
| } |
| |
| |
| // on fait des vérifications et des remplacements sur certaines valeurs |
| $valeurs[$nom_champ] = $verificateur->remplacerValeurChampPourInsertion($type,$valeur,$mail_nouvel_inscrit); |
| |
| // Si le champ fait partie des champs mappés |
| $cle_champ = array_search($id_champ, $tableau_mappage[1]); |
| if($cle_champ) { |
| 270,12 → 299,12 |
|---|
| // obtenir l'id du nouvel arrivant en faisant un select sur le mail qui doit être unique |
| $id_nouvel_inscrit = $this->ajouterNouvelleInscriptionDansAnnuaireMappe($id_annuaire,$valeurs_mappees, $tableau_mappage[0]); |
| |
| // les champs de metadonnees arrivent avec un identifiant sous la forme type_xxx_id |
| // les champs de metadonnees arrivent avec un identifiant sous la forme type_condition_id |
| foreach($valeurs as $nom_champ => $valeur) { |
| |
| // l'identifiant du champ est la dernière valeur du tableau |
| // pour chaque valeur |
| // on extrait l'id du champ |
| $ids_champ = mb_split("_",$nom_champ); |
| $type = $ids_champ[0]; |
| $id_champ = $ids_champ[count($ids_champ) - 1]; |
| |
| // Si l'insertion dans la base a réussi |
| 295,8 → 324,18 |
|---|
| // Si tout a réussi on supprime les données d'inscription temporaire |
| $this->AnnuaireModele->supprimerDonneesInscriptionTemporaire($identifiant); |
| |
| // TODO: renvoyer l'utilisateur sur sa fiche |
| return $this->afficherFormulaireUploadImage($id_annuaire, $identifiant); |
| $annuaire = $this->AnnuaireModele->chargerAnnuaire($id_annuaire, false); |
| |
| // S'il existe une page d'accueil spécifique à l'annuaire pour la confirmation d'inscription |
| if($this->templateExiste($annuaire['informations']['aa_code'].'_inscription_confirmation', Config::get('dossier_squelettes_annuaires'))) { |
| // on l'affiche |
| $donnees = array('id_utilisateur' => $id_nouvel_inscrit, 'id_annuaire' => $id_annuaire); |
| return $this->getVue(Config::get('dossier_squelettes_annuaires').$annuaire['informations']['aa_code'].'_inscription_confirmation', $donnees); |
| |
| } else { |
| // sinon on le redirige |
| return $this->afficherFicheUtilisateur($id_annuaire, $id_nouvel_inscrit); |
| } |
| } |
| |
| /** |
| 312,7 → 351,7 |
|---|
| public function ajouterNouvelleInscriptionDansAnnuaireMappe($id_annuaire,$valeurs_mappees, $noms_champs) { |
| |
| $this->chargerModele('AnnuaireModele'); |
| $resultat = $this->AnnuaireModele->ajouterDansAnnuaireMappe($id_annuaire, $valeurs_mappees, $noms_champs); |
| $resultat = $this->AnnuaireModele->ajouterInscriptionDansAnnuaireMappe($id_annuaire, $valeurs_mappees, $noms_champs); |
| |
| return $resultat; |
| } |
| 329,231 → 368,503 |
|---|
| $tableau_mappage = $this->obtenirChampsMappageAnnuaire($id_annuaire); |
| $tableau_valeurs = $this->AnnuaireModele->obtenirValeursUtilisateur($id_annuaire, $id_utilisateur,$tableau_mappage[0]); |
| |
| // pour le moment on considère que les champs de mappage ne sont pas des valeurs d'ontologies |
| // stockées dans la table ontologie |
| $this->chargerModele('MetadonneeModele'); |
| $champs_metadonnees= $this->MetadonneeModele->chargerListeValeursMetadonneesUtilisateur($id_annuaire, $id_utilisateur); |
| |
| $verificateur = new VerificationControleur(); |
| |
| // on vérifie s'il existe un type d'affichage particulier pour les colonnes de l'annuaire mappé |
| foreach($tableau_mappage[0] as $cle => $nom_champ) { |
| |
| $valeur = $tableau_valeurs[$nom_champ] ; |
| $tableau_valeurs[$cle] = $valeur; |
| if(isset($tableau_mappage[1][$cle])) { |
| |
| $tableau_valeurs[$cle] = array('amv_valeur' => $valeur,'amc_id_champ' => $tableau_mappage[1][$cle]); |
| $type_affichage = $this->MetadonneeModele->renvoyerTypeAffichagePourColonne($tableau_mappage[1][$cle]); |
| if($type_affichage) { |
| $tableau_valeurs[$cle]['amc_ce_type_affichage'] = $type_affichage; |
| } |
| |
| } else { |
| $tableau_valeurs[$cle] = $valeur; |
| } |
| unset($tableau_valeurs[$nom_champ]); |
| } |
| |
| $this->chargerModele('MetadonneeModele'); |
| $champs_metadonnees= $this->MetadonneeModele->chargerListeValeursMetadonneesUtilisateur($id_annuaire, $id_utilisateur); |
| |
| $donnees['id_annuaire'] = $id_annuaire; |
| $donnees['champs'] = array_merge($tableau_valeurs, $champs_metadonnees); |
| $donnees['id_utilisateur'] = $id_utilisateur; |
| $champs = array_merge($tableau_valeurs, $champs_metadonnees); |
| |
| foreach($champs as $cle => $champ) { |
| |
| if(is_array($champ) && isset($champ['amc_ce_type_affichage'])) { |
| $type = $champ['amc_ce_type_affichage']; |
| } else { |
| $type = false; |
| } |
| $champs[$cle] = $verificateur->verifierEtRemplacerValeurChampPourAffichage($type,$champ ,$id_annuaire); |
| } |
| |
| $donnees['champs'] = $champs; |
| |
| $annuaire_inscrits = $this->getVue(Config::get('dossier_squelettes_fiches').'annuaire_tela_inscrits_fiche',$donnees); |
| |
| return $annuaire_inscrits; |
| } |
| |
| /** |
| * En cas de tentative d'inscription, envoie un mail contenant un lien de confirmation à l'utilisateur |
| * @param string $adresse_mail adresse mail |
| * @param string $nom nom |
| * @param string $prenom prénom |
| * @param string $code_confirmation_inscription code de confirmation à inclure dans le mail |
| * |
| * @return boolean le succès ou l'échec de l'envoi du mail |
| */ |
| public function envoyerMailConfirmationInscription($adresse_mail, $nom, $prenom, $code_confirmation_inscription) { |
| public function afficherFormulaireModificationInscription($id_annuaire, $id_utilisateur, $erreurs = false) { |
| |
| $base_url = clone(Registre::getInstance()->get('base_url_application')); |
| $this->chargerModele('AnnuaireModele'); |
| $annuaire = $this->AnnuaireModele->chargerAnnuaire($id_annuaire, false); |
| |
| $base_url->setVariableRequete('m','annuaire_inscription_confirmation'); |
| $base_url->setVariableRequete('id',$code_confirmation_inscription); |
| $this->chargerModele('MetadonneeModele'); |
| $donnees['aa_id_annuaire'] = $id_annuaire; |
| |
| $donnees = array('nom' => $nom, 'prenom' => $prenom, 'lien_confirmation_inscription' => $base_url->getURL()); |
| $contenu_mail = $this->getVue(Config::get('dossier_squelettes_mails').'mail_confirmation_inscription',$donnees); |
| $metadonnees = $this->MetadonneeModele->chargerListeMetadonneeAnnuaire($id_annuaire); |
| $tableau_mappage = $this->obtenirChampsMappageAnnuaire($id_annuaire); |
| |
| // Pour envoyer un mail HTML, l'en-tête Content-type doit être défini |
| $entetes = 'MIME-Version: 1.0' . "\r\n"; |
| $entetes .= 'Content-type: text/html; charset='.Config::get('appli_encodage'). "\r\n"; |
| // En-têtes additionnels |
| $entetes .= 'To: '.$adresse_mail."\r\n"; |
| $entetes .= 'From: '.Config::get('adresse_mail_annuaire')."\r\n"; |
| $valeurs_annuaire = $this->AnnuaireModele->obtenirValeursUtilisateur($id_annuaire, $id_utilisateur,$tableau_mappage[0]); |
| $valeurs_metadonnees= $this->MetadonneeModele->chargerListeValeursMetadonneesUtilisateur($id_annuaire, $id_utilisateur); |
| |
| return mail($adresse_mail,'Inscription au site Tela Botanica',$contenu_mail, $entetes); |
| foreach($tableau_mappage[0] as $cle => $nom_champ) { |
| $valeur = $valeurs_annuaire[$nom_champ] ; |
| if($cle != 'champ_id') { |
| $valeurs_metadonnees[$metadonnees[$tableau_mappage[1][$cle]]['amc_abreviation']] = array('amv_valeur' => $valeur,'amc_id_champ' => $tableau_mappage[1][$cle]) ; |
| } |
| } |
| |
| // TODO: ceci charge toutes les métadonnées, voir si l'on ne peut pas parser le formulaire |
| // pour ne charger que ce qui est nécéssaire |
| foreach($metadonnees as $metadonnee) { |
| |
| $id_champ = $metadonnee['amc_id_champ']; |
| $nom_champ = $metadonnee['amc_abreviation']; |
| |
| if(isset($valeurs_metadonnees[$nom_champ])) { |
| $metadonnee['valeur_defaut'] = $valeurs_metadonnees[$nom_champ]; |
| } |
| |
| $metadonnee['aa_id_annuaire'] = $id_annuaire; |
| // on charge le formulaire d'affichage de chacune des métadonnées |
| $donnees['champs'][$nom_champ] = $this->afficherFormulaireChampMetadonnees($id_champ,$metadonnee); |
| |
| } |
| |
| $donnees['id_utilisateur'] = $id_utilisateur; |
| |
| // le nom du formulaire d'inscription est le même que le code de l'annuaire du genre code_annuaire_inscription |
| if(!$this->formulaireExiste($annuaire['informations']['aa_code'])) { |
| $formulaire_inscription = $this->genererFormulaireInscription($donnees); |
| } else { |
| $formulaire_inscription = $this->GetVue(Config::get('dossier_squelettes_formulaires').$annuaire['informations']['aa_code'].'_modification',$donnees); |
| } |
| |
| return $formulaire_inscription; |
| |
| } |
| |
| /** |
| * Insère les données dans la table d'inscription temporaire et crée un code de confirmation (à insérer dans le mail) |
| * @param Array $valeurs les valeurs à insérer |
| */ |
| private function InsererDansTableTemporaireEtCreerCodeConfirmationInscription($valeurs) { |
| public function modifierInscription($valeurs) { |
| |
| // Le code de confirmation est constitué des 8 premiers caractères de l'identifiant de session |
| $code_confirmation = substr(session_id(), 0, 8) ; |
| $this->chargerModele('MetadonneeModele'); |
| |
| $id_utilisateur = $valeurs['id_utilisateur']; |
| unset($valeurs['id_utilisateur']); |
| |
| $id_annuaire = $valeurs['aa_id_annuaire']; |
| unset($valeurs['aa_id_annuaire']); |
| |
| $this->chargerModele('MetadonneeModele'); |
| |
| $verificateur = new VerificationControleur(); |
| |
| $erreurs = $verificateur->verifierErreurChampModification($id_annuaire, $id_utilisateur); |
| |
| if(count($erreurs) > 0) { |
| return $this->afficherFormulaireModificationInscription($id_annuaire,$id_utilisateur,$erreurs); |
| } |
| |
| // TODO faire la fonction |
| $changement_mot_de_passe = $verificateur->verifierChangementMotDePasse($id_annuaire, $id_utilisateur, $valeurs); |
| |
| $tableau_mappage = $this->obtenirChampsMappageAnnuaire($id_annuaire); |
| |
| $valeurs_mappees = array(); |
| $valeurs_metadonnees = array(); |
| |
| // on itère sur le tableau de valeur pour récupérer les métadonnées; |
| foreach($valeurs as $nom_champ => $valeur) { |
| |
| // pour chaque valeur |
| // on extrait l'id du champ |
| $ids_champ = mb_split("_",$nom_champ); |
| |
| // l'identifiant du champ est la dernière valeur du tableau |
| if(count($ids_champ) == 3) { |
| |
| $type = $ids_champ[0]; |
| $id_champ = $ids_champ[2]; |
| $condition = $ids_champ[1]; |
| |
| } else { |
| $type = $ids_champ[0]; |
| $condition = false; |
| $id_champ = $ids_champ[1]; |
| } |
| |
| // cas de la checkbox qui devrait être là mais pas cochée |
| if($condition == 'hidden') { |
| |
| if(!isset($valeurs[$type.'_'.$id_champ])) { |
| // dans ce cas là on fabrique une valeur qui vaut 0 |
| $nom_champ = $type.'_'.$id_champ; |
| $valeur = '0'; |
| } else { |
| |
| $nom_champ = $type.'_'.$id_champ; |
| $valeur = $valeurs[$type.'_'.$id_champ]; |
| // on s'assure de ne pas itérer sur la valeur de checkbox |
| // qui sinon serait traitée deux fois |
| unset($valeurs[$type.'_'.$id_champ]); |
| } |
| } |
| |
| // Si le champ fait partie des champs mappés |
| $cle_champ = array_search($id_champ, $tableau_mappage[1]); |
| if($cle_champ) { |
| // on fait des vérifications et des remplacements sur certaines valeurs |
| $valeur = $verificateur->remplacerValeurChampPourModification($type,$valeur,$condition); |
| |
| // on ajoute sa clé correspondante dans l'annuaire mappé et sa valeur dans le tableau des champs mappés |
| $valeurs_mappees[$tableau_mappage[0][$cle_champ]] = $valeur; |
| } else { |
| $valeurs_metadonnees[$nom_champ] = $valeur; |
| } |
| } |
| |
| $this->chargerModele('AnnuaireModele'); |
| $modification_annuaire = $this->AnnuaireModele->modifierInscriptionDansAnnuaireMappe($id_annuaire, $id_utilisateur ,$valeurs_mappees, $tableau_mappage[0]); |
| |
| if(!$this->AnnuaireModele->ajouterNouvelleInscriptionTemporaire($code_confirmation, $valeurs)) { |
| return false; |
| // les champs de metadonnees arrivent avec un identifiant sous la forme type_xxx_id |
| foreach($valeurs_metadonnees as $nom_champ => $valeur) { |
| |
| // pour chaque valeur |
| // on extrait l'id du champ |
| $ids_champ = mb_split("_",$nom_champ); |
| $id_champ = $ids_champ[count($ids_champ) - 1]; |
| |
| // l'identifiant du champ est la dernière valeur du tableau |
| if(count($ids_champ) == 3) { |
| |
| $type = $ids_champ[0]; |
| $id_champ = $ids_champ[2]; |
| $condition = $ids_champ[1]; |
| |
| } else { |
| $type = $ids_champ[0]; |
| $condition = false; |
| $id_champ = $ids_champ[1]; |
| } |
| |
| // on fait des remplacements sur certaines valeurs |
| $valeur = $verificateur->remplacerValeurChampPourModification($type,$valeur,$condition, $id_utilisateur); |
| |
| // S'il existe déjà une valeur de metadonnée pour cette colonne et cet utilisateur |
| if($this->MetadonneeModele->valeurExiste($id_champ,$id_utilisateur)) { |
| |
| // On se contente de la modifier |
| // Ceci afin d'éviter de créer des lignes vides lors de la création d'un utilisateur |
| if($this->MetadonneeModele->modifierValeurMetadonnee($id_champ,$id_utilisateur,$valeur)) { |
| |
| } else { |
| return false; |
| } |
| } else { |
| // S'il n'existe pas de valeur, on ajoute une nouvelle ligne à la table de valeurs de meta données |
| if($this->MetadonneeModele->ajouterNouvelleValeurMetadonnee($id_champ,$id_utilisateur,$valeur)) { |
| // Si l'insertion a réussi, on continue |
| } else { |
| // TODO: lever exception |
| return false; |
| } |
| } |
| } |
| |
| return $code_confirmation; |
| return $this->afficherFicheUtilisateur($id_annuaire, $id_utilisateur); |
| } |
| |
| public function afficherFormulaireOubliMotDePasse($id_annuaire) { |
| |
| /**--------------------------- Fonctions de vérification et de correspondance des champs --------------------*/ |
| $donnees['aa_id_annuaire'] = $id_annuaire; |
| |
| /** |
| * Renvoie les champs de mappage correspondant à un annuaire donné |
| * @param int $id_annuaire l'indentifant de l'annuaire pour lequel on veut ces informations |
| * @return Array un tableau de mappage des champs |
| * |
| */ |
| private function obtenirChampsMappageAnnuaire($id_annuaire) { |
| return $this->getVue(Config::get('dossier_squelettes_formulaires').'oubli_mdp',$donnees); |
| } |
| |
| $tableau_mappage = array(); |
| public function reinitialiserMotDePasse($id_annuaire, $mail) { |
| |
| $tableau_mappage[0]['champ_id'] = 'U_ID'; |
| $tableau_mappage[0]['champ_mail'] = 'U_MAIL'; |
| $tableau_mappage[0]['champ_nom'] = 'U_NAME'; |
| $tableau_mappage[0]['champ_prenom'] = 'U_SURNAME'; |
| $tableau_mappage[0]['champ_pass'] = 'U_PASSWD'; |
| $this->chargerModele('AnnuaireModele'); |
| $verificateur = new VerificationControleur('VerificationControleur'); |
| |
| //$tableau_mappage[1]['champ_id'] = 'U_ID'; |
| $tableau_mappage[1]['champ_mail'] = '16'; |
| $tableau_mappage[1]['champ_nom'] = '1'; |
| $tableau_mappage[1]['champ_prenom'] = '7'; |
| $tableau_mappage[1]['champ_pass'] = '11'; |
| $donnees = array(); |
| // en vérifiant directement si le mail est valide, on se dispense d'un appel à la base de données |
| // TODO: est-ce une bonne idée ? |
| if(!$verificateur->mailValide($mail) || !$this->AnnuaireModele->utilisateurExisteParMail($id_annuaire,$mail)) { |
| $donnees['erreurs']['mail'] = 'Cet utilisateur n\'existe pas'; |
| $donnees['aa_id_annuaire'] = $id_annuaire; |
| return $this->getVue(Config::get('dossier_squelettes_formulaires').'oubli_mdp',$donnees); |
| } |
| |
| // TODO: voir comment stocker les correspondances de mappage |
| return $tableau_mappage; |
| $nouveau_mdp = $this->AnnuaireModele->reinitialiserMotDePasse($id_annuaire, $mail); |
| |
| if(!$nouveau_mdp) { |
| $donnees['erreurs']['mdp'] = 'Impossible de générer un nouveau mot de passe'; |
| $donnees['aa_id_annuaire'] = $id_annuaire; |
| return $this->getVue('oubli_mdp',$donnees); |
| } |
| |
| $donnees['nouveau_mdp'] = $nouveau_mdp; |
| |
| return $this->envoyerMailOubliMdp($id_annuaire,$mail , $nouveau_mdp); |
| } |
| |
| // TODO: utiliser les fonction de mappage définies plus haut |
| /** |
| * Vérifie que les valeurs pour des champs de mappage d'un annuaire donné |
| * sont correctes |
| * @param int $id_annuaire l'identifiant de l'annuaire |
| * @param Array $valeurs les valeurs à vérifier |
| */ |
| private function verifierErreursChamps($id_annuaire, $valeurs, $tableau_mappage) { |
| public function supprimerInscription($id_annuaire, $id_utilisateur) { |
| |
| $erreurs = false; |
| $this->chargerModele('AnnuaireModele'); |
| $champs_mappage = $this->obtenirChampsMappageAnnuaire($id_annuaire); |
| $suppression_inscription = $this->AnnuaireModele->supprimerInscriptionDansAnnuaireMappe($id_annuaire, $id_utilisateur); |
| |
| if(!$this->mailValide($valeurs['champ_mail'])) { |
| $erreurs['text_'.$tableau_mappage[1]['champ_mail']] = 'mail invalide'; |
| } |
| $donnees = array('erreurs' => array()); |
| |
| if(trim($valeurs['champ_pass']) == '' |
| || $valeurs['champ_pass'] != $valeurs['champ_pass']) { |
| $erreurs['password_'.$tableau_mappage[1]['champ_pass']] = 'mot de passe invalide'; |
| $this->chargerModele('MetadonneeModele'); |
| $suppression_metadonnees = $this->MetadonneeModele->supprimerValeursMetadonneesParIdEnregistrementLie($id_utilisateur); |
| |
| if(!$suppression_inscription || !$suppression_metadonnees) { |
| $donnees['erreurs']['inscription'] = $suppression_inscription; |
| $donnees['erreurs']['metadonnees'] = $suppression_metadonnees; |
| $donnees['erreurs']['titre'] = 'Impossible de supprimer l\'inscription '; |
| |
| return $this->getVue(Config::get('dossier_squelettes_elements').'erreurs',$donnees); |
| } |
| |
| if(trim($valeurs['champ_nom']) == '') { |
| $erreurs['text_'.$tableau_mappage[1]['champ_prenom']] = 'le nom est obligatoire'; |
| return $this->index(); |
| } |
| |
| public function afficherFormulaireRecherche($id_annuaire, $donnees = array()) { |
| |
| $this->chargerModele('AnnuaireModele'); |
| $annuaire = $this->AnnuaireModele->chargerAnnuaire($id_annuaire, false); |
| |
| $this->chargerModele('MetadonneeModele'); |
| $metadonnees = $this->MetadonneeModele->chargerListeMetadonneeAnnuaire($id_annuaire); |
| |
| $donnees['aa_id_annuaire'] = $id_annuaire; |
| |
| // TODO: ceci charge toutes les métadonnées, voir si l'on ne peut pas parser le formulaire |
| // pour ne charger que ce qui est nécéssaire |
| |
| foreach($metadonnees as $metadonnee) { |
| |
| $id_champ = $metadonnee['amc_id_champ']; |
| $nom_champ = $metadonnee['amc_abreviation']; |
| |
| $metadonnee['aa_id_annuaire'] = $id_annuaire; |
| // on charge le formulaire d'affichage de chacune des métadonnées |
| $donnees['champs'][$nom_champ] = $this->afficherFormulaireChampMetadonnees($id_champ,$metadonnee); |
| } |
| |
| if(trim($valeurs['champ_prenom']) == '') { |
| $erreurs['text_'.$tableau_mappage[1]['champ_nom']] = 'le prénom est obligatoire'; |
| // Si le formulaire spécifique à l'annuaire existe, on l'affiche |
| if(!$this->formulaireExiste($annuaire['informations']['aa_code'],'recherche')) { |
| $formulaire_recherche = $this->genererFormulaireInscription($donnees); |
| } else { |
| // Sinon on prend celui par defaut |
| $formulaire_recherche = $this->GetVue(Config::get('dossier_squelettes_formulaires').$annuaire['informations']['aa_code'].'_recherche',$donnees); |
| } |
| |
| return $erreurs; |
| return $formulaire_recherche; |
| } |
| |
| private function verifierEtRemplacerValeurChamp($type, $valeur) { |
| /** |
| * Recherche un ou plusieurs inscrits selon les valeurs passées en paramètres, qui peuvent êtres des valeurs |
| * dans l'annuaire mappé ou bien des valeurs de metadonnées |
| * @param int $id_annuaire l'identifiant de l'annuaire |
| * @param array $valeurs_recherchees les valeurs à rechercher |
| * @param boolean $exclusive indique si la recherche si fait sur tous les critères ou bien sur au moins un |
| * @param int $numero_page le numero de page demandé |
| * @param int $taille_page la taille de page |
| */ |
| public function rechercherInscrit($id_annuaire,$valeurs_recherchees, $exclusive = true, $numero_page = 1, $taille_page = 50) { |
| |
| $valeur_modifiee = $valeur; |
| $this->chargerModele('AnnuaireModele'); |
| $annuaire = $this->AnnuaireModele->chargerAnnuaire($id_annuaire, true); |
| |
| switch($type) { |
| $tableau_mappage = $this->AnnuaireModele->obtenirChampsMappageAnnuaire($id_annuaire); |
| |
| // cas du champ texte, à priori, rien de particulier |
| case 'text': |
| $valeur_modifiee = $valeur; |
| break; |
| $valeurs_get = $valeurs_recherchees; |
| |
| // cas du champ password : on le crypte |
| case 'password': |
| $valeur_modifiee = $this->encrypterMotDePasse($valeur); |
| break; |
| $valeurs_mappees = array(); |
| $valeurs = array(); |
| |
| // cas du champ checkbox |
| case 'checkbox': |
| // Si c'est un groupe checkbox, alors c'est une liste de checkbox liée à une ontologie |
| if(is_array($valeur)) { |
| // on stocke les valeurs d'ontologies liées au cases cochées |
| $valeur_modifiee = implode(Config::get('separateur_metadonnee'), array_keys($valeur)); |
| // on itère sur le tableau de valeur pour récupérer les métadonnées; |
| foreach($valeurs_recherchees as $nom_champ => $valeur) { |
| |
| // pour chaque valeur |
| // on extrait l'id du champ |
| $ids_champ = mb_split("_",$nom_champ); |
| |
| if(count($ids_champ) == 2) { |
| |
| // l'identifiant du champ est la dernière valeur du tableau |
| $type = $ids_champ[0]; |
| $id_champ = $ids_champ[1]; |
| |
| // Si le champ fait partie des champs mappés |
| $cle_champ = array_search($id_champ, $tableau_mappage[1]); |
| if($cle_champ) { |
| // on ajoute sa clé correspondante dans l'annuaire mappé et sa valeur dans le tableau des champs mappés |
| $valeurs_mappees[$tableau_mappage[0][$cle_champ]] = $valeur; |
| // et on supprime sa valeur du tableau de valeurs pour ne pas la retrouver lors |
| // de l'insertion des métadonnées |
| } else { |
| // sinon on stocke 1 pour indique que la case est cochée (cas de la checkbox oui/non) |
| $valeur_modifiee = 1; |
| $valeurs_recherchees[$id_champ] = $valeur; |
| } |
| break; |
| // on retire la valeur du tableau pour ne pas la retrouver dans les deux recherches |
| } |
| |
| default: |
| $valeur_modifiee = $valeur; |
| break; |
| unset($valeurs_recherchees[$nom_champ]); |
| } |
| |
| return $valeur_modifiee; |
| } |
| $champ_id_annuaire = $tableau_mappage[0]['champ_id']; |
| |
| private function verifierEtRemplacerValeurChampPourAffichage($type, $valeur) { |
| // on recherche dans les métadonnées |
| $this->chargerModele('MetadonneeModele'); |
| // le résultat est un ensemble d'identifiants |
| $resultat_metadonnees = $this->MetadonneeModele->rechercherDansValeurMetadonnees($id_annuaire,$valeurs_recherchees, $exclusive); |
| |
| $valeur_modifiee = $valeur; |
| // on recherche les infos dans la table annuaire mappée |
| // en incluant ou excluant les id déjà trouvées dans les metadonnées |
| // suivant le critères d'exclusivité ou non |
| $resultat_annuaire_mappe = $this->AnnuaireModele->rechercherInscritDansAnnuaireMappe($id_annuaire,$valeurs_mappees, $resultat_metadonnees, $exclusive); |
| |
| /*switch($type) { |
| $resultat_recherche = $resultat_annuaire_mappe; |
| |
| // cas du champ texte, à priori, rien de particulier |
| case 'text': |
| $valeur_modifiee = $valeur; |
| break; |
| $nb_resultats = count($resultat_recherche); |
| |
| // cas du champ checkbox |
| case 'checkbox': |
| // Si c'est un groupe checkbox, alors c'est une liste de checkbox liée à une ontologie |
| if(is_array($valeur)) { |
| // on stocke les valeurs d'ontologies liées au cases cochées |
| $valeur_modifiee = implode(Config::get('separateur_metadonnee'), array_keys($valeur)); |
| } else { |
| // sinon on stocke 1 pour indique que la case est cochée (cas de la checkbox oui/non) |
| $valeur_modifiee = 1; |
| } |
| break; |
| // on renvoie une liste identique à celle de la liste des inscrits |
| $donnees['resultats_recherche'] = $resultat_recherche; |
| $donnees['tableau_mappage'] = $tableau_mappage[0]; |
| $donnees['id_annuaire'] = $id_annuaire; |
| $donnees['nb_resultats'] = $nb_resultats; |
| |
| default: |
| $valeur_modifiee = $valeur; |
| break; |
| }*/ |
| $url_base = clone(Registre::getInstance()->get('base_url_application')); |
| |
| return $valeur_modifiee; |
| $url_pagination = new URL($url_base); |
| |
| $valeurs_get['id_annuaire'] = $id_annuaire; |
| $valeurs_get['m'] = 'annuaire_recherche_inscrit'; |
| $url_pagination->setVariablesRequete($valeurs_get); |
| |
| $donnees['pagination'] = $this->paginer($numero_page,$taille_page,$nb_resultats,$url_pagination); |
| $vue_resultat_recherche = $this->getVue(Config::get('dossier_squelettes_annuaires').'annuaire_resultat_recherche', $donnees); |
| |
| return $this->afficherFormulaireRecherche($id_annuaire, $valeurs_recherchees).$vue_resultat_recherche; |
| } |
| |
| |
| /** --------------------------------- Fonction privées -------------------------------------------*/ |
| |
| /** |
| * Renvoie vrai ou faux suivant qu'un mail donné en paramètre est syntaxiquement valide (ne vérifie pas l'existence |
| * de l'adresse) |
| * @param string $mail le mail à tester |
| * @return boolean vrai ou faux suivant que le mail est valide ou non |
| * En cas de tentative d'inscription, envoie un mail contenant un lien de confirmation à l'utilisateur |
| * @param string $adresse_mail adresse mail |
| * @param string $nom nom |
| * @param string $prenom prénom |
| * @param string $code_confirmation_inscription code de confirmation à inclure dans le mail |
| * |
| * @return boolean le succès ou l'échec de l'envoi du mail |
| */ |
| private function mailValide($mail) { |
| private function envoyerMailConfirmationInscription($adresse_mail, $nom, $prenom, $code_confirmation_inscription) { |
| |
| $regexp_mail = '/^[_a-z0-9-]+(\.[_a-z0-9-]+)*@[a-z0-9-]+(\.[a-z0-9-]+)*(\.[a-z]{2,3})$/'; |
| return preg_match($regexp_mail, $mail); |
| $base_url = clone(Registre::getInstance()->get('base_url_application')); |
| |
| $base_url->setVariableRequete('m','annuaire_inscription_confirmation'); |
| $base_url->setVariableRequete('id',$code_confirmation_inscription); |
| |
| $donnees = array('nom' => $nom, 'prenom' => $prenom, 'lien_confirmation_inscription' => $base_url->getURL()); |
| $contenu_mail = $this->getVue(Config::get('dossier_squelettes_mails').'mail_confirmation_inscription',$donnees); |
| |
| // Pour envoyer un mail HTML, l'en-tête Content-type doit être défini |
| $entetes = 'MIME-Version: 1.0' . "\r\n"; |
| $entetes .= 'Content-type: text/html; charset='.Config::get('appli_encodage'). "\r\n"; |
| // En-têtes additionnels |
| $entetes .= 'To: '.$adresse_mail."\r\n"; |
| $entetes .= 'From: '.Config::get('adresse_mail_annuaire')."\r\n"; |
| |
| return mail($adresse_mail,'Inscription à l\'annuaire',$contenu_mail, $entetes); |
| |
| } |
| |
| /** En cas d'oubli de mot de passe, régénère le mot de passe et envoie un mail à l'utilisateur |
| * @param int $id_annuaire l'identifiant d'annuaire |
| * @param string $adresse_mail adresse mail |
| * @return boolean le succès ou l'échec de l'envoi du mail |
| */ |
| private function envoyerMailOubliMdp($id_annuaire,$mail, $nouveau_mdp) { |
| |
| $base_url = clone(Registre::getInstance()->get('base_url_application')); |
| |
| $base_url->setVariableRequete('m','annuaire_fiche_utilisateur_consultation'); |
| $base_url->setVariableRequete('id',1); |
| |
| $donnees['nouveau_mdp'] = $nouveau_mdp; |
| $donnees['lien_profil'] = $base_url; |
| |
| $contenu_mail = $this->getVue(Config::get('dossier_squelettes_mails').'mail_oubli_mdp',$donnees); |
| |
| // Pour envoyer un mail HTML, l'en-tête Content-type doit être défini |
| $entetes = 'MIME-Version: 1.0' . "\r\n"; |
| $entetes .= 'Content-type: text/html; charset='.Config::get('appli_encodage'). "\r\n"; |
| // En-têtes additionnels |
| $entetes .= 'To: '.$mail."\r\n"; |
| $entetes .= 'From: '.Config::get('adresse_mail_annuaire')."\r\n"; |
| |
| return mail($mail,'Inscription à l\'annuaire',$contenu_mail, $entetes); |
| |
| } |
| |
| /** |
| * Renvoie un mot de passe crypté selon la fonction d'encryptage définie dans le fichier de configuration |
| * (si celle-ci n'existe pas on utilise une fonction par défaut) |
| * @param string $pass le mot de passe à encrypter |
| * @return string le mot de passe encrypté |
| * Insère les données dans la table d'inscription temporaire et crée un code de confirmation (à insérer dans le mail) |
| * @param Array $valeurs les valeurs à insérer |
| */ |
| private function encrypterMotDePasse($pass) { |
| private function InsererDansTableTemporaireEtCreerCodeConfirmationInscription($valeurs) { |
| |
| $fonction = Config::get('pass_crypt_fonct'); |
| // Le code de confirmation est constitué des 8 premiers caractères de l'identifiant de session |
| $code_confirmation = substr(session_id(), 0, 8) ; |
| |
| if(function_exists($fonction)) { |
| return $fonction($pass); |
| } else { |
| return md5($pass); |
| $this->chargerModele('AnnuaireModele'); |
| |
| if(!$this->AnnuaireModele->ajouterNouvelleInscriptionTemporaire($code_confirmation, $valeurs)) { |
| return false; |
| } |
| |
| return $code_confirmation; |
| } |
| |
| |
| /**--------------------------- Fonctions de vérification et de correspondance des champs --------------------*/ |
| |
| /** |
| * Renvoie les champs de mappage correspondant à un annuaire donné |
| * @param int $id_annuaire l'indentifant de l'annuaire pour lequel on veut ces informations |
| * @return Array un tableau de mappage des champs |
| * |
| */ |
| private function obtenirChampsMappageAnnuaire($id_annuaire) { |
| |
| $this->chargerModele('AnnuaireModele'); |
| $tableau_mappage = $this->AnnuaireModele->obtenirChampsMappageAnnuaire($id_annuaire); |
| |
| return $tableau_mappage; |
| } |
| |
| /** |
| * Renvoie le formulaire demandé s'il existe, sinon faux |
| * @param string $nom_formulaire le nom du formulaire demandé (qui est normalement le code d'un annuaire) |
| * @return boolean true si le formulaire existe, false sinon |
| 560,10 → 871,20 |
|---|
| */ |
| private function formulaireExiste($nom_formulaire) { |
| |
| return file_exists(Config::get('chemin_squelettes').Config::get('dossier_squelettes_formulaires').$nom_formulaire.'_inscription.tpl.html'); |
| return $this->templateExiste($nom_formulaire.'_inscription', Config::get('dossier_squelettes_formulaires')); |
| } |
| |
| /** |
| * Renvoie le template demandé s'il existe, sinon faux |
| * @param string $nom_formulaire le nom du formulaire demandé (qui est normalement le code d'un annuaire) |
| * @param string $dossier le nom du dossier sous dossier demandé |
| * @return boolean true si le formulaire existe, false sinon |
| */ |
| private function templateExiste($nom_template, $dossier = '/') { |
| return file_exists(Config::get('chemin_squelettes').$dossier.$nom_template.'.tpl.html'); |
| } |
| |
| /** |
| * Renvoie un formulaire d'inscription minimal auto-généré |
| * @param string $donnees les donnée à inclure dans le formulaire |
| * @return string la vue contenant le formulaire généré |
| 584,12 → 905,16 |
|---|
| /** |
| * Renvoie le template de pagination, considérant des éléments donnés en paramètre |
| */ |
| private function paginer($numero_page, $taille_page, $total, $url_base = '') { |
| private function paginer($numero_page, $taille_page = 1, $total, $url_base = '') { |
| |
| // TODO, faire plus complexe, tri alphabétique etc... |
| $page_precedente = $numero_page-1; |
| $page_suivante = $numero_page+1; |
| |
| if($taille_page <= 0) { |
| $taille_page = 1; |
| } |
| |
| $nombre_pages = round($total/$taille_page,'PHP_ROUND_HALF_DOWN') ; |
| |
| |
| 608,6 → 933,9 |
|---|
| |
| } |
| |
| |
| /** --- Fonction pour les images ------------------------------------------------------------------------*/ |
| |
| public function afficherFormulaireUploadImage($id_annuaire,$id_utilisateur) { |
| |
| $donnees['aa_id_annuaire'] = $id_annuaire; |
| 625,7 → 953,7 |
|---|
| * Ajoute une image uploadée à travers le formulaire |
| * |
| */ |
| public function ajouterImageUtilisateur($id_annuaire, $id_utilisateur, $fichier_a_stocker) { |
| public function ajouterImageUtilisateur($id_annuaire, $id_utilisateur, $fichier_a_stocker, $retourner_booleen = false) { |
| |
| foreach($fichier_a_stocker as $nom_champ => $fichier) { |
| |
| 654,8 → 982,11 |
|---|
| } |
| } |
| |
| return true ; |
| |
| if($retourner_booleen) { |
| return true; |
| } else { |
| return $this->afficherFicheUtilisateur($id_annuaire, $id_utilisateur) ; |
| } |
| } |
| } |
| ?> |