| /tags/v1.5-belier/controleurs/RSSControleur.php |
|---|
| New file |
| 0,0 → 1,60 |
| <?php |
| /** |
| * PHP Version 5 |
| * |
| * @category PHP |
| * @package annuaire |
| * @author aurelien <aurelien@tela-botanica.org> |
| * @copyright 2010 Tela-Botanica |
| * @license http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt Licence CECILL |
| * @version SVN: <svn_id> |
| * @link /doc/annuaire/ |
| */ |
| class RssControleur extends AppControleur { |
| public function obtenirDerniersInscritsRSS($id_annuaire = 1, $admin = false) { |
| $annuaire_controleur = new AnnuaireControleur(); |
| $tableau_valeurs = $annuaire_controleur->obtenirTableauDerniersInscrits($id_annuaire); |
| $donnees['derniers_inscrits'] = $tableau_valeurs; |
| $donnees['id_annuaire'] = $id_annuaire; |
| if($admin) { |
| $retour_rss = $this->getVue(Config::get('dossier_squelettes_rss').'derniers_inscrits_admin',$donnees); |
| } else { |
| $retour_rss = $this->getVue(Config::get('dossier_squelettes_rss').'derniers_inscrits',$donnees); |
| } |
| return $retour_rss; |
| } |
| public function obtenirDernieresModificationsProfil($id_annuaire = 1, $limite = 10) { |
| $stat_controleur = new StatistiqueControleur(); |
| $tableau_id_dernieres_modifs = $stat_controleur->obtenirDerniersEvenementsStatistique($id_annuaire, 'modification', $limite); |
| $dernieres_modif = array(); |
| foreach($tableau_id_dernieres_modifs as $modif) { |
| $id_utilisateur = $modif['id_utilisateur']; |
| $date_modif = $modif['date_evenement']; |
| $id_infos_date = array('id_utilisateur' => $id_utilisateur, |
| 'informations' => $this->obtenirValeursUtilisateur($id_annuaire, $id_utilisateur), |
| 'date_evenement' => AppControleur::formaterDateMysqlVersDateAnnuaire($date_modif)); |
| $dernieres_modif[] = $id_infos_date; |
| } |
| $donnees['dernieres_modifications'] = $dernieres_modif; |
| $donnees['id_annuaire'] = $id_annuaire; |
| $retour_rss = $this->getVue(Config::get('dossier_squelettes_rss').'dernieres_modifications',$donnees); |
| return $retour_rss; |
| } |
| } |
| ?> |
| /tags/v1.5-belier/controleurs/CartoControleur.php |
|---|
| New file |
| 0,0 → 1,425 |
| <?php |
| // declare(encoding='UTF-8'); |
| /** |
| * classe Controleur du module Carte. |
| * |
| * @package Collection |
| * @category Php5 |
| * @author Jean-Pascal MILCENT <jpm@tela-botanica.org> |
| * @author Aurélien Peronnet <aurelien@tela-botanica.org> |
| * @copyright 2010 Tela-Botanica |
| * @license http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt Licence CECILL |
| * @license http://www.gnu.org/licenses/gpl.html Licence GNU-GPL |
| */ |
| class CartoControleur extends AppControleur { |
| // identifiant de la france pour l'accès direct |
| private $id_france = 'fr'; |
| // nom du fond de carte en cours |
| private $nom_fond = ''; |
| private $niveau = 0; |
| // contient le tableau de données sur les continents une fois chargé |
| private $donnees_continents = array(); |
| // contient le tableau de données sur les pays une fois chargé |
| private $donnees_pays = array(); |
| // contient le tableau de données sur les departements une fois chargé |
| private $donnees_departements = array(); |
| // contient le nombre total d'inscrits dans la zone en cours de consultation |
| private $total_inscrits_zone = 0; |
| //+----------------------------------------------------------------------------------------------------------------+ |
| // Méthodes |
| /** |
| * Fonction d'affichage par défaut, elle appelle la cartographie |
| */ |
| public function executerActionParDefaut() { |
| return $this->cartographier(1); |
| } |
| /** |
| * Cartographier un annuaire. |
| * @param int $id_annuaire l'identitifiant de l'annuaire à cartographier |
| * @param int $continent l'identitifiant du continent sur lequel on se trouve |
| * @param string $pays l'identitifiant du pays sur lequel on se trouve (normalement seulement la france si présent) |
| * @return string la vue correspondante |
| */ |
| public function cartographier($id_annuaire, $continent= null , $pays = null) { |
| // Initialisation de variable |
| $donnees = array(); |
| // la présence d'un pays (non) et d'un continent (ou non) détermine le niveau de carte à afficher |
| $this->niveau = $this->calculerNiveau($continent, $pays); |
| // suivant le niveau, continent et pays, on renvoie un template html différent |
| $fond = $this->renvoyerPrefixePourNiveau($this->niveau, $continent, $pays); |
| $carte = ''; |
| // chaque continent possède un fond de carte différent |
| if ($this->niveau == 1) { |
| $carte = $this->renvoyerSuffixePourContinent($this->niveau, $continent, $pays); |
| } |
| // Création de la carte |
| $options = array( |
| 'carte_nom' => $fond.$carte, |
| 'formule' => Cartographie::FORMULE_PROPORTIONNEL, |
| 'couleur_claire' => Config::get('carte_couleur_claire'), |
| 'couleur_foncee' => Config::get('carte_couleur_foncee'), |
| 'fond_fichier' => Config::get('carte_base_nom_'.$fond).$carte, |
| 'fond_dossier' => Application::getChemin().Config::get('carte_fonds_chemin'), |
| 'stock_dossier' => Config::get('carte_stockage_chemin'), |
| 'stock_url' => Config::get('carte_stockage_url'), |
| 'debug' => Config::get('carte_mode_debug')); |
| $cartographie = Composant::fabrique('cartographie', $options); |
| $this->nom_fond = Config::get('carte_base_nom_'.$fond).$carte; |
| // Construction des données nécessaires à la cartographie |
| $zones = $cartographie->getCarteZones(); |
| $this->chargerZonesNbre($id_annuaire,$zones, $this->niveau); |
| $this->chargerZonesUrls($id_annuaire, $zones, $continent, $pays, $this->niveau); |
| $navigation = new NavigationControleur(); |
| $donnees_navigation = $this->obtenirUrlsNavigation($id_annuaire, $continent, $pays, null); |
| $donnees['infos_pays'] = $donnees_navigation; |
| $donnees['navigation'] = $navigation->afficherBandeauNavigationCartographie($donnees_navigation); |
| $donnees['nb_resultats'] = $this->total_inscrits_zone; |
| $cartographie->setCarteZones($zones); |
| $cartographie->creerCarte(); |
| $donnees['map'] = $cartographie->getImageMap(); |
| $resultat = $this->getVue('cartes/'.$fond, $donnees); |
| return $resultat; |
| } |
| /** |
| * Charge le nombre d'inscrit par zone pour un annuaire donné |
| * @param int $id_annuaire l'identifiant de l'annuaire |
| * @param array $zones les zones à cartographier (attention, passage par référence, donc les zones sont modifiées) |
| * @param int $niveau le niveau de la carto (monde, continent, ou pays) |
| */ |
| private function chargerZonesNbre($id_annuaire, &$zones, $niveau = 0) { |
| $metaModele = $this->getModele('AnnuaireModele'); |
| // on charge les inscrits pour le niveau donné |
| $zones_infos = $this->chargerNombreInscritsParNiveauGeographique($id_annuaire, $niveau); |
| foreach ($zones as $id => &$infos) { |
| // si l'on a des données pour la zone, on renseigne le nombre d'inscrits |
| if (isset($zones_infos[$id])) { |
| $nbre = $zones_infos[$id]; |
| $infos['info_nombre'] = $nbre; |
| $this->total_inscrits_zone += $nbre; |
| } else { |
| // sinon on le met à 0 |
| $infos['info_nombre'] = 0; |
| } |
| } |
| } |
| /** |
| * Charge les des zones pour un annuaire donné |
| * @param int $id_annuaire l'identifiant de l'annuaire |
| * @param array $zones les zones à cartographier (attention, passage par référence, donc les zones sont modifiées) |
| * @param int $continent l'identitifiant du continent sur lequel on se trouve |
| * @param string $pays l'identitifiant du pays sur lequel on se trouve (normalement seulement la france si présent) |
| * @param int $niveau le niveau de la carto (monde, continent, ou pays) |
| */ |
| private function chargerZonesUrls($id_annuaire, &$zones, $continent = null, $pays = null, $niveau = 0) { |
| $url = new URL(Config::get('url_base')); |
| $url->setVariableRequete('id_annuaire', $id_annuaire); |
| foreach ($zones as $id => &$infos) { |
| switch ($niveau) { |
| // niveau 0 de la carte : on affiche tous les continents |
| // l'url va pointer vers un continent en particulier |
| case 0: |
| $url->setVariableRequete('m', 'annuaire_afficher_carte'); |
| $url->setVariableRequete('continent', $id); |
| break; |
| // niveau 1, on est sur un continent en particulier : on affiche le détail du continent demandé |
| // l'url pointe sur des pays |
| case 1: |
| $url->setVariableRequete('continent', $continent); |
| // si le pays c'est la france alors l'url pointera vers la carte des départements |
| if($id == $this->id_france) { |
| $url->setVariableRequete('m', 'annuaire_afficher_carte'); |
| } else { |
| // sinon l'url pointe vers la liste des inscrits de ce pays |
| $url->setVariableRequete('m', 'annuaire_inscrits_carto'); |
| } |
| $url->setVariableRequete('pays', $id); |
| break; |
| // niveau 2, si on a cliqué sur la france pour afficher les départements : |
| case 2: |
| $url->setVariableRequete('m','annuaire_inscrits_carto'); |
| $url->setVariableRequete('continent', $continent); |
| $url->setVariableRequete('pays', $pays); |
| $url->setVariableRequete('departement', $id); |
| break; |
| } |
| $infos['url'] = sprintf($url, $id); |
| } |
| } |
| /** |
| * Renvoie le niveau auquel on se trouve suivant la présence ou non de certains paramètres |
| * @param int $continent l'identitifiant du continent sur lequel on se trouve |
| * @param string $pays l'identitifiant du pays sur lequel on se trouve (normalement seulement la france si présent) |
| */ |
| private function calculerNiveau($continent, $pays) { |
| // le niveau 0 c'est la carte de base |
| $niveau = 0; |
| // le niveau 1 on consulte un continent en particulier (ex. Amérique du Sud) |
| if($continent != null) { |
| $niveau = 1; |
| } |
| // le niveau 2 c'est un pays en particulier (ce cas là n'arrive que pour la france) |
| if($pays != null) { |
| $niveau = 2; |
| } |
| return $niveau; |
| } |
| /** |
| * Renvoie le type de template à utiliser suivant le niveau de certains paramètres |
| * @param int $niveau le niveau de la carto |
| * @return string le type de template |
| */ |
| private function renvoyerPrefixePourNiveau($niveau) { |
| switch ($niveau) { |
| case 0: |
| $fond = 'continents'; |
| break; |
| case 1: |
| $fond = 'pays'; |
| break; |
| case 2 : |
| $fond = 'france'; |
| break; |
| default: |
| $fond = ''; |
| break; |
| } |
| return $fond; |
| } |
| /** |
| * Renvoie le suffixe de fond de carte à utiliser pour un continent donné |
| * @param int $niveau le niveau de la carto |
| * @param int $niveau l'identifiant de continent |
| * @return string le suffixe |
| */ |
| private function renvoyerSuffixePourContinent($niveau, $continent) { |
| switch ($continent) { |
| case 1: |
| $carte = '_afrique'; |
| break; |
| case 2: |
| $carte = '_nord_amerique'; |
| break; |
| case 3: |
| $carte = '_asie'; |
| break; |
| case 4: |
| $carte = '_europe'; |
| break; |
| case 5: |
| $carte = '_oceanie'; |
| break; |
| case 6: |
| $carte = '_sud_amerique'; |
| break; |
| case 7: |
| $carte = '_moyen_orient'; |
| break; |
| default: |
| $carte = ''; |
| break; |
| } |
| return $carte; |
| } |
| /** |
| * renvoie tous les noms templates pour chaque zone du monde |
| * @return array un tableau associatif indexé par les identifiants de zone et contenant les noms de templates |
| */ |
| private function renvoyerTousTemplates() { |
| return array(1 => 'pays_afrique', 2 => 'pays_nord_amerique', 3 => 'pays_asie', 4 => 'pays_europe', 5 => 'pays_oceanie', 6 => 'pays_sud_amerique', 7 => 'pays_moyen_orient'); |
| } |
| /** |
| * Charge la liste des inscrits par zone pour un niveau géographique donné |
| * @param int $id_annuaire l'identifiant de l'annuaire |
| * @param int $niveau le niveau où l'on se situe |
| * @return array un tableau associatif indexé par les identifiants de zone et contenant le nombre d'inscrits pour chaque zone |
| */ |
| private function chargerNombreInscritsParNiveauGeographique($id_annuaire, $niveau) { |
| if ($niveau == 0) { |
| // si on est au niveau des continents |
| $zones_ids = array(); |
| // il faut faire la somme des inscrits par zones géographique |
| $templates = $this->renvoyerTousTemplates(); |
| } else { |
| // sinon on appelle la fonction pour la zone demandée |
| $zones_ids = $this->chargerZonesParCsv(Application::getChemin().Config::get('carte_fonds_chemin').$this->nom_fond); |
| } |
| $annuaire_controleur = new AnnuaireControleur(); |
| $nb_inscrits = array(); |
| switch ($niveau) { |
| case 0 : // niveau de la carte du monde |
| // pour chacun des continents, on fait la somme des membres de sa zone |
| foreach ($templates as $id_continent => $template) { |
| $zones_continent_ids = $this->chargerZonesParCsv(Application::getChemin().Config::get('carte_fonds_chemin').$template); |
| $nb_inscrits[$id_continent] = array_sum($annuaire_controleur->chargerNombreAnnuaireListeInscritsParPays($id_annuaire, $zones_continent_ids)); |
| } |
| break; |
| case 1 : // niveau de la carte des pays d'un continent |
| $nb_inscrits = $annuaire_controleur->chargerNombreAnnuaireListeInscritsParPays($id_annuaire, $zones_ids); |
| break; |
| case 2 : // détail d'un pays |
| $nb_inscrits = $annuaire_controleur->chargerNombreAnnuaireListeInscritsParDepartement($id_annuaire); |
| break; |
| } |
| return $nb_inscrits; |
| } |
| public function obtenirUrlsNavigation($id_annuaire ,$continent = null, $pays = null, $departement = null) { |
| $url_carte_monde = new URL(Config::get('url_base')); |
| $url_carte_monde->setVariableRequete('id_annuaire', $id_annuaire); |
| $url_carte_monde->setVariableRequete('m', 'annuaire_afficher_carte'); |
| $donnees = array(); |
| $donnees['url_carte_monde'] = $url_carte_monde; |
| $donnees['nom_carte_monde'] = 'Carte du monde'; |
| if ($continent != null && trim($continent) != '') { |
| $infos_continents = $this->chargerInformationsContinentCsv(); |
| $url_continent = new URL(Config::get('url_base')); |
| $url_continent->setVariableRequete('id_annuaire', $id_annuaire); |
| $url_continent->setVariableRequete('m', 'annuaire_afficher_carte'); |
| $url_continent->setVariableRequete('continent', $continent); |
| $donnees['url_continent'] = $url_continent; |
| $donnees['nom_continent'] = $infos_continents[$continent][2]; |
| } |
| if ($pays != null && trim($pays) != '') { |
| $templates_continents = $this->renvoyerTousTemplates(); |
| $infos_continents = $this->chargerInformationsPaysDuContinentsCsv($templates_continents[$continent]); |
| $infos_pays = $infos_continents[$pays]; |
| $url_pays = new URL(Config::get('url_base')); |
| $url_pays->setVariableRequete('id_annuaire', $id_annuaire); |
| if ($pays == $this->id_france) { |
| $url_pays->setVariableRequete('m', 'annuaire_afficher_carte'); |
| } else { |
| // sinon l'url pointe vers la liste des inscrits de ce pays |
| $url_pays->setVariableRequete('m', 'annuaire_inscrits_carto'); |
| } |
| $url_pays->setVariableRequete('continent', $continent); |
| $url_pays->setVariableRequete('pays', $pays); |
| $donnees['url_pays'] = $url_pays; |
| $donnees['nom_pays'] = $infos_pays[2]; |
| } |
| if ($departement != null && trim($departement) != '') { |
| $infos_departement = $this->chargerInformationsDepartementsFranceCsv(); |
| $url_departement = new URL(Config::get('url_base')); |
| $url_departement->setVariableRequete('id_annuaire', $id_annuaire); |
| $url_departement->setVariableRequete('m', 'annuaire_afficher_carte'); |
| $url_departement->setVariableRequete('continent', $continent); |
| $url_departement->setVariableRequete('departement', $departement); |
| $url_departement->setVariableRequete('pays', $pays); |
| $donnees['url_departement'] = $url_departement; |
| $donnees['nom_departement'] = $infos_departement[$departement][2]; |
| } |
| $donnees['nb_resultats'] = $this->total_inscrits_zone; |
| return $donnees; |
| } |
| public function chargerInformationsContinentCsv() { |
| $nom_csv = Application::getChemin().Config::get('carte_fonds_chemin').'continents'; |
| return $this->chargerInformationsCompletesParCsv($nom_csv); |
| } |
| public function chargerInformationsPaysDuContinentsCsv($continent) { |
| $nom_csv = Application::getChemin().Config::get('carte_fonds_chemin').$continent; |
| return $this->chargerInformationsCompletesParCsv($nom_csv); |
| } |
| public function chargerInformationsDepartementsFranceCsv() { |
| $nom_csv = Application::getChemin().Config::get('carte_fonds_chemin').'france'; |
| return $this->chargerInformationsCompletesParCsv($nom_csv); |
| } |
| public function chargerInformationsCompletesParCsv($nom_csv) { |
| $fichier_csv = $nom_csv.'.csv'; |
| $infos = array(); |
| if (($handle = fopen($fichier_csv, 'r')) !== false) { |
| $ligne = 0; |
| while (($donnees = fgetcsv($handle, 1000, ',')) !== false) { |
| if($ligne != 0 && trim($donnees[0]) != '') { |
| $infos[$donnees[0]] = $donnees; |
| } |
| $ligne++; |
| } |
| fclose($handle); |
| } |
| return $infos; |
| } |
| /** |
| * Récupère les identifiants de zone dans un fichier csv donné |
| * @param string $nom_csv chemin vers le fichier csv (sans extension) qui contient les données |
| * @return array un tableau contenant les identifiants des zones |
| */ |
| private function chargerZonesParCsv($nom_csv) { |
| $fichier_csv = $nom_csv.'.csv'; |
| $zones_id = array(); |
| if (($handle = fopen($fichier_csv, 'r')) !== false) { |
| $ligne = 0; |
| while (($donnees = fgetcsv($handle, 1000, ',')) !== false) { |
| if($ligne != 0 && trim($donnees[0]) != '') { |
| $zones_id[] = "'".$donnees[0]."'"; |
| } |
| $ligne++; |
| } |
| fclose($handle); |
| } |
| return $zones_id; |
| } |
| } |
| Property changes: |
| Added: svnkit:entry:sha1-checksum |
| +be06e5e37b1d0280628ea8db298296154bfefe64 |
| \ No newline at end of property |
| /tags/v1.5-belier/controleurs/MappageControleur.php |
|---|
| New file |
| 0,0 → 1,182 |
| <?php |
| /** |
| * PHP Version 5 |
| * |
| * @category PHP |
| * @package annuaire |
| * @author aurelien <aurelien@tela-botanica.org> |
| * @copyright 2010 Tela-Botanica |
| * @license http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt Licence CECILL |
| * @version SVN: <svn_id> |
| * @link /doc/annuaire/ |
| */ |
| class MappageControleur extends AppControleur { |
| private $id_liste_champs = 30768; |
| /** |
| * Charge la vue contenant les informations d'un annuaire géré par l'application |
| * @param int $id l'annuaire dont on veut consulter les informations |
| * @return string la vue contenant les informations |
| */ |
| public function chargerAnnuaire($id) { |
| $this->chargerModele('AnnuaireModele'); |
| $this->chargerModele('MetadonneeModele'); |
| $data['erreurs'] = array(); |
| $data['annuaire'] = $this->AnnuaireModele->chargerAnnuaire($id,true); |
| $data['metadonnees'] = $this->MetadonneeModele->chargerListeMetadonneeAnnuaire($id); |
| $annuaire = $this->getVue(Config::get('dossier_squelettes_gestion_annuaires').'annuaire', $data); |
| return $annuaire; |
| } |
| /**--------Fonctions de gestion des champs de mappage associées à un annuaire et des formaulaires associés --------*/ |
| /** |
| * Affiche le formulaire d'ajout d'une metadonnee |
| * @param Array $valeurs les valeurs à inclure dans le formulaire (dans le cas du retour erreur) |
| * @return string la vue contenant le formulaire |
| */ |
| public function afficherFormulaireAjoutMappage($id_annuaire, $donnees = array()) { |
| $this->chargerModele('MetadonneeModele'); |
| $this->chargerModele('GestionAnnuaireModele'); |
| $champs_mappage = $this->obtenirChampsMappageAnnuaire($id_annuaire); |
| $liste_champs_mappage = array('champ_id' => 'Champ identifiant', |
| 'champ_pass' => 'Champ mot de passe', |
| 'champ_nom' => 'Champ nom', |
| 'champ_prenom' => 'Champ prénom' , |
| 'champ_mail' => 'Champ mail', |
| 'champ_pays' => 'Champ pays', |
| 'champ_code_postal' => 'Champ code postal', |
| 'champ_adresse' => 'Champ adresse', |
| 'champ_adresse_comp' => 'Champ adresse complémentaire', |
| 'champ_adresse_comp' => 'Champ adresse complémentaire'); |
| $champs_metadonnees = $this->MetadonneeModele->chargerListeMetadonneeAnnuaire($id_annuaire); |
| $champs_annuaire = $this->GestionAnnuaireModele->obtenirListeNomsChampsAnnuaireParIdAnnuaire($id_annuaire); |
| $roles_deja_affectes = array_intersect_key($liste_champs_mappage, $champs_mappage[0]); |
| //Debug::printr($champs_mappage[0]); |
| //Debug::printr($liste_champs_mappage); |
| $champs_deja_mappe_annuaire = array_intersect_key($champs_mappage[0], $liste_champs_mappage); |
| $champs_deja_mappe_metadonnees = array_intersect_key($champs_mappage[1], $liste_champs_mappage); |
| // on retire les roles déjà affectés dans la liste des roles |
| $liste_champs_mappage = array_diff_key($liste_champs_mappage, $roles_deja_affectes); |
| // on retire les champs de l'annuaire qui sont déjà mappés |
| $champs_annuaire = array_diff($champs_annuaire, $champs_deja_mappe_annuaire); |
| // on retire les champ de metadonnées qui mappent déjà un champ |
| $champs_metadonnees = array_diff_key($champs_metadonnees, array_flip($champs_deja_mappe_metadonnees)); |
| $data['champs_mappage'] = $liste_champs_mappage; |
| $data['champs_metadonnees'] = $champs_metadonnees; |
| $data['champs_annuaire'] = $champs_annuaire; |
| $data['id_annuaire'] = $id_annuaire; |
| $mappage_ajout = $this->getVue(Config::get('dossier_squelettes_metadonnees').'mappage_ajout',$data); |
| return $mappage_ajout; |
| } |
| /** |
| * Affiche le formulaire de modification d'une metadonnee |
| * @param Array $valeurs les valeurs à inclure dans le formulaire |
| * @return string la vue contenant le formulaire |
| */ |
| public function afficherFormulaireModificationMappage($id_mappage) { |
| if(!isset($valeurs['amc_nom'])) { |
| $valeurs['amc_nom'] = ''; |
| } |
| if(!isset($valeurs['amc_abreviation'])) { |
| $valeurs['amc_abreviation'] = ''; |
| } |
| if(!isset($valeurs['amc_description'])) { |
| $valeurs['amc_description'] = ''; |
| } |
| $data['valeur'] = $valeurs; |
| $this->chargerModele('MetadonneeModele'); |
| $data['valeur'] = $this->MetadonneeModele->chargerInformationsMetadonnee($valeurs['amc_id_champ']); |
| $data['types'] = $this->MetadonneeModele->chargerListeDesTypesDeChamps(); |
| $data['listes'] = $this->MetadonneeModele->chargerListeDesListes(); |
| $metadonnee_modification = $this->getVue(Config::get('dossier_squelettes_metadonnees').'metadonnee_modification',$data); |
| return $metadonnee_modification; |
| } |
| /** |
| * Ajoute un nouveau champ de mappage à un annuaire |
| * @param Array $valeurs les valeurs à ajouter |
| * @return string la vue contenant l'annuaire associé, ou le formulaire en cas d'échec |
| */ |
| public function ajouterNouveauMappage($valeurs) { |
| $this->ChargerModele('MappageModele'); |
| if(isset($valeurs['id_annuaire']) |
| && isset($valeurs['at_valeur']) |
| && isset($valeurs['at_ressource']) |
| && isset($valeurs['at_action'])) { |
| $id_annuaire = $valeurs['id_annuaire']; |
| $id_champ_metadonnee = $valeurs['at_valeur']; |
| $nom_champ_annuaire = $valeurs['at_ressource']; |
| $role = $valeurs['at_action']; |
| $this->MappageModele->ajouterNouveauMappage($id_annuaire, $nom_champ_annuaire, $role, $id_champ_metadonnee); |
| } else { |
| return $this->afficherFormulaireAjoutMappage($valeurs); |
| } |
| return $this->chargerAnnuaire($valeurs['id_annuaire']); |
| } |
| /** |
| * Modifie un champ de mapagge associé à un annuaire |
| * @param Array $valeurs les valeurs à modifier |
| * @return string la vue contenant l'annuaire associé, ou le formulaire en cas d'échec |
| */ |
| public function modifierMappage($valeurs) { |
| if(isset($valeurs['amc_id_champ']) |
| && isset($valeurs['amc_nom']) |
| && isset($valeurs['amc_abreviation']) |
| && isset($valeurs['amc_description']) |
| && isset($valeurs['amc_ce_annuaire']) |
| && isset($valeurs['amc_ce_type_affichage'])) { |
| $this->chargerModele('MetadonneeModele'); |
| $this->MetadonneeModele->modifierMetadonnee($valeurs); |
| } else { |
| return $this->afficherFormulaireModificationMetadonnee($valeurs); |
| } |
| return $this->chargerAnnuaire($valeurs['amc_ce_annuaire']); |
| } |
| /** |
| * Supprime un champ de métadonnée associé à un annuaire |
| * @return string la vue contenant l'annuaire associé, ou le formulaire en cas d'échec |
| */ |
| public function supprimerMappage($id_annuaire, $id_mappage) { |
| if($id_metadonnee != '') { |
| $this->chargerModele('MetadonneeModele'); |
| $this->MetadonneeModele->supprimerMetadonneeParId($id_metadonnee); |
| } else { |
| return false; |
| } |
| return $this->chargerAnnuaire($id_annuaire); |
| } |
| } |
| ?> |
| /tags/v1.5-belier/controleurs/OpenIdControleur.php |
|---|
| New file |
| 0,0 → 1,18 |
| <?php |
| /** |
| * PHP Version 5 |
| * |
| * @category PHP |
| * @package annuaire |
| * @author aurelien <aurelien@tela-botanica.org> |
| * @copyright 2010 Tela-Botanica |
| * @license http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt Licence CECILL |
| * @version SVN: <svn_id> |
| * @link /doc/annuaire/ |
| */ |
| class OpenIdControleur extends AppControleur { |
| } |
| ?> |
| /tags/v1.5-belier/controleurs/MetadonneeControleur.php |
|---|
| New file |
| 0,0 → 1,158 |
| <?php |
| /** |
| * PHP Version 5 |
| * |
| * @category PHP |
| * @package annuaire |
| * @author aurelien <aurelien@tela-botanica.org> |
| * @copyright 2010 Tela-Botanica |
| * @license http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt Licence CECILL |
| * @version SVN: <svn_id> |
| * @link /doc/annuaire/ |
| */ |
| class MetadonneeControleur extends AppControleur { |
| /** |
| * Charge la vue contenant les informations d'un annuaire donné en paramètre |
| * @param int $id l'identifiant de l'annuaire |
| * @return string la vue contenant les informations sur l'annuaire |
| */ |
| public function chargerAnnuaire($id) { |
| $this->chargerModele('AnnuaireModele'); |
| $this->chargerModele('MetadonneeModele'); |
| $data['erreurs'] = array(); |
| $data['champs_mappage'] = $this->obtenirChampsMappageAnnuaire($id); |
| $data['annuaire'] = $this->AnnuaireModele->chargerAnnuaire($id, true); |
| $data['metadonnees'] = $this->MetadonneeModele->chargerListeMetadonneeAnnuaire($id); |
| $annuaire = $this->getVue(Config::get('dossier_squelettes_gestion_annuaires').'annuaire', $data); |
| return $annuaire; |
| } |
| /**--------Fonctions de gestion des métadonnées associées à un annuaire--------*/ |
| /** |
| * Affiche le formulaire d'ajout d'une metadonnee |
| * @param Array $valeurs les valeurs à inclure dans le formulaire (dans le cas du retour erreur) |
| * @return string la vue contenant le formulaire |
| */ |
| public function afficherFormulaireAjoutMetadonnee($valeurs) { |
| if(!isset($valeurs['amc_nom'])) { |
| $valeurs['amc_nom'] = ''; |
| } |
| if(!isset($valeurs['amc_abreviation'])) { |
| $valeurs['amc_abreviation'] = ''; |
| } |
| if(!isset($valeurs['amc_description'])) { |
| $valeurs['amc_description'] = ''; |
| } |
| $data['valeur'] = $valeurs; |
| $this->chargerModele('MetadonneeModele'); |
| $data['types'] = $this->MetadonneeModele->chargerListeDesTypesDeChamps(); |
| $data['listes'] = $this->MetadonneeModele->chargerListeDesListes(); |
| $metadonnee_ajout = $this->getVue(Config::get('dossier_squelettes_metadonnees').'metadonnee_ajout',$data); |
| return $metadonnee_ajout; |
| } |
| /** |
| * Affiche le formulaire de modification d'une metadonnee |
| * @param Array $valeurs les valeurs à inclure dans le formulaire |
| * @return string la vue contenant le formulaire |
| */ |
| public function afficherFormulaireModificationMetadonnee($valeurs) { |
| if(!isset($valeurs['amc_nom'])) { |
| $valeurs['amc_nom'] = ''; |
| } |
| if(!isset($valeurs['amc_abreviation'])) { |
| $valeurs['amc_abreviation'] = ''; |
| } |
| if(!isset($valeurs['amc_description'])) { |
| $valeurs['amc_description'] = ''; |
| } |
| $data['valeur'] = $valeurs; |
| $this->chargerModele('MetadonneeModele'); |
| $data['valeur'] = $this->MetadonneeModele->chargerInformationsMetadonnee($valeurs['amc_id_champ']); |
| $data['types'] = $this->MetadonneeModele->chargerListeDesTypesDeChamps(); |
| $data['listes'] = $this->MetadonneeModele->chargerListeDesListes(); |
| $metadonnee_modification = $this->getVue(Config::get('dossier_squelettes_metadonnees').'metadonnee_modification',$data); |
| return $metadonnee_modification; |
| } |
| /** |
| * Ajoute un nouveau champ de métadonnée à un annuaire |
| * @param Array $valeurs les valeurs à ajouter |
| * @return string la vue contenant l'annuaire associé, ou le formulaire en cas d'échec |
| */ |
| public function ajouterNouvelleMetadonnee($valeurs) { |
| if(isset($valeurs['amc_nom']) |
| && isset($valeurs['amc_abreviation']) |
| && isset($valeurs['amc_description']) |
| && isset($valeurs['amc_ce_annuaire']) |
| && isset($valeurs['amc_ce_type_affichage'])) { |
| $this->chargerModele('MetadonneeModele'); |
| $this->MetadonneeModele->ajouterNouvelleMetadonnee($valeurs); |
| } else { |
| return $this->afficherFormulaireAjoutMetadonnee($valeurs); |
| } |
| return $this->chargerAnnuaire($valeurs['amc_ce_annuaire']); |
| } |
| /** |
| * Modifie un champ de métadonnée associé à un annuaire |
| * @param Array $valeurs les valeurs à modifier |
| * @return string la vue contenant l'annuaire associé, ou le formulaire en cas d'échec |
| */ |
| public function modifierMetadonnee($valeurs) { |
| if(isset($valeurs['amc_id_champ']) |
| && isset($valeurs['amc_nom']) |
| && isset($valeurs['amc_abreviation']) |
| && isset($valeurs['amc_description']) |
| && isset($valeurs['amc_ce_annuaire']) |
| && isset($valeurs['amc_ce_type_affichage'])) { |
| $this->chargerModele('MetadonneeModele'); |
| $this->MetadonneeModele->modifierMetadonnee($valeurs); |
| } else { |
| return $this->afficherFormulaireModificationMetadonnee($valeurs); |
| } |
| return $this->chargerAnnuaire($valeurs['amc_ce_annuaire']); |
| } |
| /** |
| * Supprime un champ de métadonnée associé à un annuaire |
| * @return string la vue contenant l'annuaire associé, ou le formulaire en cas d'échec |
| */ |
| public function supprimerMetadonnee($id_annuaire, $id_metadonnee) { |
| if($id_metadonnee != '') { |
| $this->chargerModele('MetadonneeModele'); |
| $this->MetadonneeModele->supprimerMetadonneeParId($id_metadonnee); |
| } else { |
| return false; |
| } |
| return $this->chargerAnnuaire($id_annuaire); |
| } |
| public function obtenirIdChampMetadonneeParAbreviation($id_annuaire, $abreviation) { |
| if(!$id_annuaire || !$abreviation) { |
| return false; |
| } else { |
| $this->chargerModele('MetadonneeModele'); |
| return $this->MetadonneeModele->obtenirIdChampMetadonneeParAbreviation($id_annuaire, $abreviation); |
| } |
| } |
| } |
| ?> |
| /tags/v1.5-belier/controleurs/StatistiqueControleur.php |
|---|
| New file |
| 0,0 → 1,344 |
| <?php |
| /** |
| * PHP Version 5 |
| * |
| * @category PHP |
| * @package annuaire |
| * @author aurelien <aurelien@tela-botanica.org> |
| * @copyright 2010 Tela-Botanica |
| * @license http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt Licence CECILL |
| * @version SVN: <svn_id> |
| * @link /doc/annuaire/ |
| */ |
| class StatistiqueControleur extends AppControleur { |
| private $statistiques = null; |
| private $champ_pays = '12'; |
| private $champ_rapport_activite_bota = '102'; |
| private $champ_experience_bota = '4'; |
| private $tab_mois = array('Jan','Fev','Mar','Avr','Mai','Juin','Juil','Aout','Sep','Oct','Nov','Dec'); |
| public function StatistiqueControleur() { |
| $this->__construct(); |
| $this->statistiques = Composant::fabrique('statistiques', array()); |
| } |
| public function obtenirStatistiquesInscritsParContinents($id_annuaire) { |
| $cartographe = new CartoControleur(); |
| $annuaire_controleur = new AnnuaireControleur(); |
| $continents = array( |
| 'Afrique (%1.2f%%)' => 'pays_afrique', |
| 'Amerique du nord (%1.2f%%)' => 'pays_nord_amerique', |
| 'Asie (%1.2f%%)' => 'pays_asie', |
| 'Europe (%1.2f%%)' => 'pays_europe', |
| 'Oceanie (%1.2f%%)' => 'pays_oceanie', |
| 'Amerique du sud (%1.2f%%)' => 'pays_sud_amerique', |
| 'Moyen Orient (%1.2f%%)' => 'pays_moyen_orient'); |
| // pour chacun des continents, on fait la somme des membres de sa zone |
| foreach($continents as $id_continent => $continent) { |
| $zones_continent_ids = $cartographe->chargerInformationsPaysDuContinentsCsv($continent); |
| $zones_continent_ids = array_map(array($this,'miniQuote'), array_keys($zones_continent_ids)); |
| $nb_inscrits[$id_continent] = array_sum($annuaire_controleur->chargerNombreAnnuaireListeInscritsParPays($id_annuaire, $zones_continent_ids)); |
| } |
| $graph = $this->statistiques->genererGraphique(Statistiques::GRAPH_CAMEMBERT,$nb_inscrits,'', array(650, 500)); |
| return $this->dessinerGraph($graph); |
| } |
| public function obtenirStatistiquesInscritsEurope($id_annuaire) { |
| $cartographe = new CartoControleur(); |
| $annuaire_controleur = new AnnuaireControleur(); |
| $cartographe = new CartoControleur(); |
| $ids_zones_europe = $cartographe->chargerInformationsPaysDuContinentsCsv('pays_europe'); |
| $codes_zones_europe = array_map(array($this, 'miniQuote'), array_keys($ids_zones_europe)); |
| $titre_zone = $this->convertirPourLegende($zone[2]); |
| $nb_inscrits_par_code = $annuaire_controleur->chargerNombreAnnuaireListeInscritsParPays($id_annuaire, $codes_zones_europe); |
| $nb_inscrits_par_legende = array(); |
| $inscrits_france = $nb_inscrits_par_code['fr']; |
| unset($nb_inscrits_par_code['fr']); |
| $somme_autres_pays = 0; |
| foreach ($nb_inscrits_par_code as $code_pays => $inscrits_pays) { |
| $label_pays = $this->convertirPourLegende($ids_zones_europe[$code_pays][2].' (%1.2f%%)'); |
| $nb_inscrits_par_legende[$label_pays] = $inscrits_pays; |
| $somme_autres_pays += $inscrits_pays; |
| } |
| $tableau_france_autres = array('France (%1.2f%%)' => $inscrits_france, 'Autres (%1.2f%%)' => $somme_autres_pays); |
| $graph_france = $this->statistiques->genererGraphique(Statistiques::GRAPH_CAMEMBERT, $tableau_france_autres, '', array(320, 200)); |
| $graph_autres = $this->statistiques->genererGraphique(Statistiques::GRAPH_CAMEMBERT, $nb_inscrits_par_legende, '', array(930, 900)); |
| $graph = $this->statistiques->combinerGraphiques($graph_france, $graph_autres, array(940, 1110)); |
| return $this->dessinerGraph($graph); |
| } |
| public function obtenirStatistiquesParPays($id_annuaire) { |
| $controleur = new AnnuaireControleur(); |
| //$controleur = new AnnuaireControleur(); |
| $modele_meta = new MetadonneeModele(); |
| $modele_onto = new OntologieModele(); |
| $id_champ = 12; |
| $valeurs = $modele_meta->obtenirNombreValeurMetadonnee($id_champ); |
| $id_onto = $modele_meta->obtenirOntologieLieeAChampParId($id_champ); |
| $legendes = $modele_onto->chargerListeOntologie($id_onto); |
| $valeurs_a_stat_code = array(); |
| $valeurs_a_stat_legende = array(); |
| foreach ($valeurs as $valeur) { |
| $valeurs_a_stat_code[$valeur['amv_valeur']] = $valeur['nb']; |
| } |
| foreach ($legendes as $legende) { |
| $legende_nom = $legende['amo_nom']; |
| $legende_code = $legende['amo_id_ontologie']; |
| if (isset($valeurs_a_stat_code[$legende_code])) { |
| $valeurs_a_stat_legende[$legende_nom] = $valeurs_a_stat_code[$legende_code]; |
| } |
| } |
| $graph = $this->statistiques->genererGraphique(Statistiques::GRAPH_CAMEMBERT,$valeurs_a_stat_legende); |
| return $this->dessinerGraph($graph); |
| } |
| public function obtenirStatistiquesParCritere($id_annuaire, $code_champ, $titre = '') { |
| $modele_meta = new MetadonneeModele(); |
| $modele_onto = new OntologieModele(); |
| $id_champ = $modele_meta->renvoyerIdChampMetadonneeParAbreviation($id_annuaire, $code_champ); |
| $valeurs = $modele_meta->obtenirNombreValeurMetadonnee($id_champ); |
| $id_onto = $modele_meta->obtenirOntologieLieeAChampParId($id_champ); |
| $legendes = $modele_onto->chargerListeOntologie($id_onto); |
| $valeurs_a_stat_code = array(); |
| $valeurs_a_stat_legende = array(); |
| $titre = $this->convertirPourLegende($titre); |
| foreach ($valeurs as $valeur) { |
| $valeurs_a_stat_code[$valeur['amv_valeur']] = $valeur['nb']; |
| } |
| foreach ($legendes as $legende) { |
| $legende_nom = $this->convertirPourLegende($legende['amo_nom']); |
| $legende_code = $legende['amo_id_ontologie']; |
| if (isset($valeurs_a_stat_code[$legende_code])) { |
| $valeurs_a_stat_legende[$legende_nom] = $valeurs_a_stat_code[$legende_code]; |
| } |
| } |
| $graph = $this->statistiques->genererGraphique(Statistiques::GRAPH_CAMEMBERT,$valeurs_a_stat_legende, $titre, array(650, 400)); |
| return $this->dessinerGraph($graph); |
| } |
| public function obtenirStatistiquesPourAnnee($id_annuaire, $annee = null) { |
| $annee = ($annee == null) ? date("Y") : $annee; |
| $annuaire_modele = new AnnuaireModele(); |
| $valeurs_a_stat_code = array(); |
| $valeurs_a_stat_legende = array(); |
| $annee_debut = $annee; |
| $mois = 1; |
| $annee = $annee; |
| $tps_debut = mktime(0,0,0,1,1,$annee); |
| $tps_courant = $tps_debut; |
| $annee_courante = date("Y"); |
| if ($annee_fin == $annee_courante) { |
| $tps_fin = time();// jour courant |
| } else { |
| $tps_fin = mktime(0,0,0,1,1,$annee+1); |
| } |
| //Requete par mois |
| $i = 1; |
| while ($tps_courant <= $tps_fin) { |
| if ($mois/12 > 1) { |
| $mois = 1; |
| $annee = $annee+1; |
| } |
| $tps_mois_suivant = mktime(0,0,0,$mois+1,1,$annee); |
| $nb_inscrits_dans_intervalle = $annuaire_modele->obtenirNombreInscriptionsDansIntervalleDate($id_annuaire, $tps_debut, $tps_courant); |
| $valeurs_a_stat_legende[$this->tab_mois[$mois-1].' '.$annee] = $nb_inscrits_dans_intervalle; |
| $tps_courant = $tps_mois_suivant; |
| $mois++; |
| $i++; |
| } |
| $nom_axeX = 'Mois depuis le 1er janvier '.$annee; |
| $graph = $this->statistiques->genererGraphique(Statistiques::GRAPH_COURBE,$valeurs_a_stat_legende, '', array(500,490), $nom_axeX, ''); |
| return $this->dessinerGraph($graph); |
| } |
| public function obtenirStatistiquesParAnnees($id_annuaire, $annee_fin = '') { |
| $annuaire_modele = new AnnuaireModele(); |
| $valeurs_a_stat_code = array(); |
| $valeurs_a_stat_legende = array(); |
| $annee_debut = 2002; |
| $mois = 4; |
| $annee = 2002; |
| $tps_debut = mktime(0,0,0,$mois,1,$annee); |
| $tps_courant = $tps_debut; |
| if ($annee_fin != '') { |
| $tps_fin = mktime(0,0,0,1,1,$annee_fin); |
| } else { |
| $tps_fin = time();// jour courant |
| } |
| //Requete par mois |
| $i = 1; |
| while ($tps_courant <= $tps_fin) { |
| if (($mois)/12 > 1) { |
| $mois = 1; |
| $annee = $annee+1; |
| } |
| $tps_mois_suivant = mktime(0,0,0,$mois+1,1,$annee); |
| $nb_inscrits_dans_intervalle = $annuaire_modele->obtenirNombreInscriptionsDansIntervalleDate($id_annuaire, $tps_debut, $tps_courant); |
| $valeurs_a_stat_legende[$this->tab_mois[$mois-1].' '.$annee] = $nb_inscrits_dans_intervalle; |
| $tps_courant = $tps_mois_suivant; |
| $mois++; |
| $i++; |
| } |
| $nom_axeX = 'Mois depuis le 1er avril 2002'; |
| $graph = $this->statistiques->genererGraphique(Statistiques::GRAPH_COURBE,$valeurs_a_stat_legende, '', array(500,490), $nom_axeX, ''); |
| return $this->dessinerGraph($graph); |
| } |
| public function obtenirStatistiquesModificationsProfil($id_annuaire, $annee_fin = '') { |
| $modele = new StatistiqueModele(); |
| $valeurs_a_stat_code = array(); |
| $valeurs_a_stat_legende = array(); |
| $annee_debut = 2010; |
| $mois = 1; |
| $annee = 2010; |
| $tps_debut = mktime(0,0,0,$mois,1,$annee); |
| $tps_courant = $tps_debut; |
| if($annee_fin != '') { |
| $tps_fin = mktime(0,0,0,1,1,$annee_fin); |
| } else { |
| $today = date_parse(date('Y-m-d H:i:s')); |
| $annee_fin_today = $today['year']; |
| $mois_fin_today = $today['month']; |
| if($annee_debut == $annee_fin_today) { |
| $tps_fin = mktime(0,0,0,$mois_fin_today+1,1,$annee_fin_today); |
| } else { |
| $tps_fin = time();// jour courant |
| } |
| } |
| //Requete par mois |
| $i = 1; |
| while ($tps_courant <= $tps_fin) { |
| if (($mois)/12 > 1) { |
| $mois = 1; |
| $annee = $annee+1; |
| } |
| $tps_mois_suivant = mktime(0,0,0,$mois+1,1,$annee); |
| $nb_modif_dans_intervalle = $modele->obtenirEvenementsDansIntervalle($id_annuaire,'modification', $tps_debut, $tps_courant); |
| $valeurs_a_stat_legende[$this->tab_mois[$mois-1].' '.$annee] = $nb_modif_dans_intervalle; |
| $tps_courant = $tps_mois_suivant; |
| $mois++; |
| $i++; |
| } |
| $nom_axeX = 'Mois depuis le 1er juillet 2010'; |
| $graph = $this->statistiques->genererGraphique(Statistiques::GRAPH_COURBE,$valeurs_a_stat_legende, '', array(500,490), $nom_axeX, ''); |
| return $this->dessinerGraph($graph); |
| } |
| public function ajouterEvenementStatistique($id_annuaire, $id_utilisateur, $type) { |
| $this->chargerModele('StatistiqueModele'); |
| $this->StatistiqueModele->ajouterEvenementStatistique($id_annuaire, $id_utilisateur, $type); |
| } |
| public function obtenirDerniersEvenementsStatistique($id_annuaire, $type) { |
| $this->chargerModele('StatistiqueModele'); |
| return $this->StatistiqueModele->obtenirDerniersEvenementsStatistique($id_annuaire, $type); |
| } |
| private function dessinerGraph($graph) { |
| return $this->statistiques->dessinerGraph($graph); |
| } |
| private function convertirPourLegende($texte) { |
| if (trim($texte) == '') { |
| $texte = '' ; |
| } |
| $texte = str_replace( |
| array( |
| 'à', 'â', 'ä', 'á', 'ã', 'å', |
| 'î', 'ï', 'ì', 'í', |
| 'ô', 'ö', 'ò', 'ó', 'õ', 'ø', |
| 'ù', 'û', 'ü', 'ú', |
| 'é', 'è', 'ê', 'ë', |
| 'ç', 'ÿ', 'ñ', |
| 'À', 'Â', 'Ä', 'Á', 'Ã', 'Å', |
| 'Î', 'Ï', 'Ì', 'Í', |
| 'Ô', 'Ö', 'Ò', 'Ó', 'Õ', 'Ø', |
| 'Ù', 'Û', 'Ü', 'Ú', |
| 'É', 'È', 'Ê', 'Ë', |
| 'Ç', 'Ÿ', 'Ñ', |
| ), |
| array( |
| 'a', 'a', 'a', 'a', 'a', 'a', |
| 'i', 'i', 'i', 'i', |
| 'o', 'o', 'o', 'o', 'o', 'o', |
| 'u', 'u', 'u', 'u', |
| 'e', 'e', 'e', 'e', |
| 'c', 'y', 'n', |
| 'A', 'A', 'A', 'A', 'A', 'A', |
| 'I', 'I', 'I', 'I', |
| 'O', 'O', 'O', 'O', 'O', 'O', |
| 'U', 'U', 'U', 'U', |
| 'E', 'E', 'E', 'E', |
| 'C', 'Y', 'N', |
| ),$texte); |
| return $texte; |
| } |
| private function miniQuote($chaine) { |
| return "'".$chaine."'"; |
| } |
| } |
| ?> |
| /tags/v1.5-belier/controleurs/AppControleur.php |
|---|
| New file |
| 0,0 → 1,586 |
| <?php |
| /** |
| * PHP Version 5 |
| * |
| * @category PHP |
| * @package annuaire |
| * @author aurelien <aurelien@tela-botanica.org> |
| * @copyright 2010 Tela-Botanica |
| * @license http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt Licence CECILL |
| * @version SVN: <svn_id> |
| * @link /doc/annuaire/ |
| */ |
| /** |
| * |
| * Classe mère des controleurs de l'application, abstraite, elle contient |
| * les fonctions utiles à tous les controleurs |
| * @author aurelien |
| * |
| */ |
| abstract class AppControleur extends Controleur { |
| /** |
| * (fonction héritée de la classe Controleur) |
| * Avant chaque chargement de vue, on ajoute l'url de la page dans |
| * les variables à insérer. |
| * @param Array $donnes les données à insérer dans la vue |
| * @return Array $donnees les données modifiées |
| */ |
| public function preTraiterDonnees($donnees) { |
| // ajout de l'url de l'appli |
| $donnees['base_url'] = new Url(Config::get('base_url_application')); |
| $donnees['base_url_styles'] = $this->getUrlBase(); |
| $donnees['url_cette_page'] = $this->getUrlCettePage() ; |
| $donnees['base_url_application'] = $this->getUrlBaseComplete(); |
| $this->chargerModele('AnnuaireModele'); |
| //ajout des variables d'identification |
| $donnees['est_admin'] = Registre::getInstance()->get('est_admin'); |
| $donnees['identification_id'] = Registre::getInstance()->get('identification_id'); |
| $donnees['identification_mail'] = Registre::getInstance()->get('identification_mail'); |
| $format = Config::get('date_format_simple'); |
| if($format) { |
| $donnees['format_date_simple'] = $format; |
| } else { |
| $donnees['format_date_simple'] = 'd/m/Y'; |
| } |
| return $donnees; |
| } |
| public function getUrlBase() { |
| $base_vrai_chemin = str_replace(realpath($_SERVER['DOCUMENT_ROOT']),'',realpath(Application::getChemin())); |
| $base_vrai_chemin .= '/'; |
| return new Url($base_vrai_chemin); |
| } |
| public function getUrlBaseComplete() { |
| return new Url('http://'.$_SERVER['SERVER_NAME'].str_replace(realpath($_SERVER['DOCUMENT_ROOT']),'',realpath(Application::getChemin()))); |
| } |
| public function getUrlCettePage() { |
| return $_SERVER['SERVER_NAME'].$_SERVER['REQUEST_URI']; |
| } |
| public static function getUrlConfirmationInscriptionAdmin($code_confirmation_inscription) { |
| $url_cette_page = 'http://'.$_SERVER['SERVER_NAME'].str_replace('annuaire_utilisateur','annuaire_admin',$_SERVER['REQUEST_URI']); |
| $base_url = new URL($url_cette_page); |
| $base_url->setVariablesRequete(array()); |
| $base_url->setVariableRequete('m','annuaire_inscription_confirmation_admin'); |
| $base_url->setVariableRequete('id',$code_confirmation_inscription); |
| return $base_url->getURL(); |
| } |
| public static function getUrlConfirmationInscription($code_confirmation_inscription) { |
| $url_cette_page = 'http://'.$_SERVER['SERVER_NAME'].$_SERVER['REQUEST_URI']; |
| $base_url = new URL($url_cette_page); |
| $base_url->setVariablesRequete(array()); |
| $base_url->setVariableRequete('m','annuaire_inscription_confirmation'); |
| $base_url->setVariableRequete('id',$code_confirmation_inscription); |
| return $base_url->getURL(); |
| } |
| public static function getUrlSuppressionInscriptionTemporaire($id_annuaire, $code_donnee_temporaire) { |
| $url_cette_page = 'http://'.$_SERVER['SERVER_NAME'].$_SERVER['REQUEST_URI']; |
| $base_url = new URL($url_cette_page); |
| $base_url->setVariablesRequete(array()); |
| $base_url->setVariableRequete('m','annuaire_suppression_inscription_temp'); |
| $base_url->setVariableRequete('id',$code_donnee_temporaire); |
| $base_url->setVariableRequete('id_annuaire',$id_annuaire); |
| return $base_url->getURL(); |
| } |
| public static function getUrlConsultationProfil($id_annuaire, $id_utilisateur) { |
| $url_consultation_profil = new Url(Config::get('base_url_application')); |
| $url_consultation_profil->setVariableRequete('m','annuaire_fiche_utilisateur_consultation'); |
| $url_consultation_profil->setVariableRequete('id_annuaire',$id_annuaire); |
| $url_consultation_profil->setVariableRequete('id_utilisateur',$id_utilisateur); |
| return $url_consultation_profil; |
| } |
| public static function getUrlModificationProfil($id_annuaire, $id_utilisateur) { |
| $url_modification_profil = new Url(Config::get('base_url_application')); |
| $url_modification_profil->setVariableRequete('m','annuaire_formulaire_modification_inscription'); |
| $url_modification_profil->setVariableRequete('id_annuaire',$id_annuaire); |
| $url_modification_profil->setVariableRequete('id_utilisateur',$id_utilisateur); |
| return $url_modification_profil; |
| } |
| public static function getUrlOubliMotDePasse($id_annuaire,$id_utilisateur) { |
| $url_oubli_mdp = new Url(Config::get('base_url_application')); |
| $url_oubli_mdp->setVariableRequete('m','annuaire_afficher_formulaire_oubli_mdp'); |
| $url_oubli_mdp->setVariableRequete('id_annuaire',$id_annuaire); |
| $url_oubli_mdp->setVariableRequete('id_utilisateur',$id_utilisateur); |
| return $url_oubli_mdp; |
| } |
| public static function getUrlAjoutOuModificationImage($id_annuaire, $id_utilisateur) { |
| $url_ajout_modification_image = new Url(Config::get('base_url_application')); |
| $url_ajout_modification_image->setVariableRequete('m','annuaire_afficher_formulaire_ajout_image'); |
| $url_ajout_modification_image->setVariableRequete('id_annuaire',$id_annuaire); |
| $url_ajout_modification_image->setVariableRequete('id_utilisateur',$id_utilisateur); |
| return $url_ajout_modification_image; |
| } |
| /** |
| * Renvoie le template de pagination, considérant des éléments donnés en paramètre |
| * @param int $numero_page le numéro de page en cours |
| * @param int $taille_page la taille de page |
| * @param int $total le nombre total de pages |
| * @param object $url_base l'url de base de la page |
| * @param array $valeurs les valeurs à concatener à l'url |
| * @return string le html contenu la template de pagination rempli avec les infos |
| */ |
| protected function paginer($numero_page = 1, $taille_page = 50, $total, $url_base, $valeurs) { |
| $start = ($numero_page - 1)*$taille_page; |
| $limit = $taille_page; |
| $intervalle_pages = 5; |
| $page_en_cours = $numero_page; |
| $pages_avant_apres = (ceil($intervalle_pages /2) + 1); |
| $pages_debut_intervalle = 0; |
| $nb_pages = 0; |
| if ($page_en_cours < $pages_avant_apres) { |
| $pages_debut_intervalle = 1; |
| } else { |
| $pages_debut_intervalle = $page_en_cours - $pages_avant_apres + 2; |
| } |
| $pages_a_afficher = $intervalle_pages; |
| $intervalle_max = (($page_en_cours) * $limit); |
| foreach($valeurs as $cle => $variable) { |
| $url_base->setVariableRequete($cle,$variable); |
| } |
| $donnees['url_base_pagination'] = $url_base->getUrl().'&taille_page='.$taille_page.'&numero_page='; |
| $nb_pages = ceil($total/$limit); |
| if ($page_en_cours == $nb_pages) { |
| $intervalle_max = $total; |
| } |
| $donnees['pages_taille_intervalle'] = $intervalle_pages; |
| $donnees['pages_debut_intervalle'] = $pages_debut_intervalle; |
| $donnees['page_en_cours'] = $page_en_cours; |
| $donnees['intervalle_min'] = (($page_en_cours-1) * $limit); |
| $donnees['intervalle_max'] = $intervalle_max; |
| $donnees['nb_resultats'] = $total; |
| $donnees['nb_pages'] = $nb_pages; |
| $donnees['taille_page'] = $limit; |
| return $this->getVue(Config::get('dossier_squelettes_elements').'pagination',$donnees); |
| } |
| public function obtenirIdParMail($id_annuaire, $mail_utilisateur) { |
| $this->chargerModele('AnnuaireModele'); |
| $id = $this->AnnuaireModele->obtenirIdParMail($id_annuaire, $mail_utilisateur); |
| return $id; |
| } |
| public function utilisateurExiste($id_annuaire,$id, $utilise_mail = true) { |
| $this->chargerModele('AnnuaireModele'); |
| if($utilise_mail) { |
| $existe = $this->AnnuaireModele->utilisateurExisteParMail($id_annuaire,$id); |
| } else { |
| $existe = $this->AnnuaireModele->utilisateurExisteParId($id_annuaire,$id); |
| } |
| return $existe; |
| } |
| /** --------------------------------- Fonction de formatage de données communes aux classes ---------------------------------*/ |
| public static function formaterVersDateMysql($date) { |
| $format = Config::get('date_format_simple'); |
| if(!isset($format)) { |
| $format = 'd/m/Y'; |
| } |
| $recherche = array('d','m','Y'); |
| $remplacement = array('([0-9]{1,2})','([0-9]{1,2})','([0-9]{4})'); |
| $pattern_date_simple = str_replace($recherche, $remplacement, $format); |
| if(ereg($pattern_date_simple, $date)) { |
| $date_tab = split('/', $date); |
| $time = mktime(0,0,0,$date_tab[1],$date_tab[0],$date_tab[2]); |
| } else { |
| $time = strtotime($date); |
| } |
| return date('Y-m-d h:i:s', $time); |
| } |
| public static function formaterDateMysqlVersDateAnnuaire($date) { |
| $format = Config::get('date_format_simple'); |
| if(!isset($format)) { |
| $format = 'd/m/Y'; |
| } |
| $time = strtotime($date); |
| return date($format, $time); |
| } |
| public static function genererDateCouranteFormatMySql() { |
| return date('Y-m-d h:i:s'); |
| } |
| public static function genererDateCouranteFormatAnnuaire() { |
| $date_mysql_courante = self::genererDateCouranteFormatMySql(); |
| return self::formaterDateMysqlVersDateAnnuaire($date_mysql_courante); |
| } |
| public static function formaterMotPremiereLettreChaqueMotEnMajuscule($chaine) { |
| $encodage = Config::get('appli_encodage'); |
| return str_replace(' - ', '-', |
| mb_convert_case( |
| mb_strtolower( |
| str_replace('-', ' - ', $chaine), |
| $encodage |
| ), |
| MB_CASE_TITLE, |
| $encodage |
| ) |
| ); |
| } |
| public static function formaterMotEnMajuscule($chaine) { |
| return mb_convert_case($chaine, MB_CASE_UPPER, Config::get('appli_encodage')); |
| } |
| function aplatirTableauSansPreserverCles($tableau) { |
| $temp = array(); |
| foreach ($tableau as $cle => $valeur) { |
| if (is_array($valeur)) { |
| $temp = array_merge($temp,$this->aplatirTableauSansPreserverCles($valeur)); |
| } else { |
| $temp[] = $valeur; |
| } |
| } |
| return $temp; |
| } |
| /** --------------------------------- Fonction d'extraction des champs de mappage -------------------------------------------*/ |
| /** |
| * 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 |
| * |
| */ |
| protected function obtenirChampsMappageAnnuaire($id_annuaire) { |
| $this->chargerModele('AnnuaireModele'); |
| $tableau_mappage = $this->AnnuaireModele->obtenirChampsMappageAnnuaire($id_annuaire); |
| return $tableau_mappage; |
| } |
| protected function obtenirNomsChampsMappageAnnuaire($id_annuaire) { |
| $this->chargerModele('AnnuaireModele'); |
| $tableau_mappage = $this->AnnuaireModele->obtenirChampsMappageAnnuaire($id_annuaire); |
| $this->chargerModele('MetadonneeModele'); |
| $metadonnees = $this->MetadonneeModele->chargerListeMetadonneeAnnuaire($id_annuaire); |
| $tableau_nom_champs = array(); |
| foreach($metadonnees as $id_champ => $valeur) { |
| // Si le champ fait partie des champs mappés |
| $cle_champ_mappage = array_search($id_champ, $tableau_mappage[1]); |
| if($cle_champ_mappage) { |
| $tableau_nom_champs[$cle_champ_mappage] = $valeur['amc_abreviation']; |
| } |
| } |
| return $tableau_nom_champs; |
| } |
| /** --------------------------------- Fonction d'affichage des champs de metadonnées -------------------------------------------*/ |
| /** |
| * Charge et affiche le champ correspondant à la modification ou l'ajout d'un champ de metadonnée |
| * @param int $id_champ l'identifiant du champ demandé |
| * @return string la vue contenant le champ de formulaire correspondant |
| */ |
| public function afficherFormulaireChampMetadonnees($id_champ, $donnees) { |
| // si le champ est restreint à une valeur de liste |
| if($donnees['amc_ce_ontologie'] != 0) { |
| $this->chargerModele('OntologieModele'); |
| $donnees['liste_valeurs'] = $this->OntologieModele->chargerListeOntologie($donnees['amc_ce_ontologie']); |
| } |
| $donnees['amc_id_champ'] = $id_champ; |
| if(isset($donnees['amc_ce_template_affichage'])) { |
| $nom_type_champ = $donnees['amc_ce_template_affichage']; |
| } else { |
| $this->chargerModele('MetadonneeModele'); |
| $nom_type_champ = $this->MetadonneeModele->renvoyerTypeAffichageParId($donnees['amc_ce_type_affichage']); |
| } |
| return $this->getVue(Config::get('dossier_squelettes_champs').$nom_type_champ,$donnees); |
| } |
| /** --------------------------------- Fonction d'existence et de génération des formulaires -------------------------------------------*/ |
| public function annuaireAvoirFormulaireInscription($code_annuaire) { |
| return $this->templateExiste($code_annuaire.'_inscription','formulaires/'); |
| } |
| public function annuaireAvoirPageAccueilPostInscription($code_annuaire) { |
| return $this->templateExiste($code_annuaire.'_inscription_confirmation', Config::get('dossier_squelettes_annuaires')); |
| } |
| public function annuaireAvoirFicheUtilisateur($code_annuaire) { |
| return $this->templateExiste($code_annuaire.'_fiche','/fiches/'); |
| } |
| public function annuaireAvoirFormulaireModificationInscription($code_annuaire) { |
| return $this->templateExiste($code_annuaire.'_modification','/formulaires/'); |
| } |
| public function annuaireAvoirPagePostDesinscription($code_annuaire) { |
| return $this->templateExiste($code_annuaire.'_desinscription_confirmation','/annuaires/'); |
| } |
| public function annuaireAvoirFormulaireRecherche($code_annuaire) { |
| return $this->templateExiste($code_annuaire.'_recherche','/formulaires/'); |
| } |
| public function annuaireAvoirPageResultatRecherche($code_annuaire) { |
| return $this->templateExiste($code_annuaire.'_resultat_recherche', Config::get('dossier_squelettes_annuaires')); |
| } |
| /** |
| * Renvoie true si le template demandé 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 |
| */ |
| protected function templateExiste($nom_template, $dossier = '/') { |
| return file_exists(Config::get('chemin_squelettes').$dossier.$nom_template.'.tpl.html'); |
| } |
| /** |
| * Renvoie une fiche utilisateur minimale auto-générée |
| * @param string $donnees les données à inclure dans le formulaire |
| * @return string la vue contenant le formulaire généré |
| */ |
| protected function genererFicheInscrit($donnees) { |
| $formulaire_modele = $this->getVue(Config::get('dossier_squelettes_fiches').'fiche',$donnees); |
| if($formulaire_modele) { |
| return $formulaire_modele; |
| } else { |
| trigger_error("impossible de trouver le squelette de référence pour le formulaire"); |
| } |
| return false; |
| } |
| /** |
| * 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é |
| */ |
| protected function genererFormulaireInscription($donnees) { |
| $formulaire_modele = $this->getVue(Config::get('dossier_squelettes_formulaires').'inscription',$donnees); |
| if($formulaire_modele) { |
| return $formulaire_modele; |
| } else { |
| trigger_error("impossible de trouver le squelette de référence pour le formulaire"); |
| } |
| return false; |
| } |
| /** |
| * 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é |
| */ |
| protected function genererFormulaireModificationInscription($donnees) { |
| $formulaire_modele = $this->getVue(Config::get('dossier_squelettes_formulaires').'modification',$donnees); |
| if($formulaire_modele) { |
| return $formulaire_modele; |
| } else { |
| trigger_error("impossible de trouver le squelette de référence pour le formulaire"); |
| } |
| return false; |
| } |
| /** |
| * 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é |
| */ |
| protected function genererFormulaireRecherche($donnees) { |
| $formulaire_modele = $this->getVue(Config::get('dossier_squelettes_formulaires').'recherche',$donnees); |
| if($formulaire_modele) { |
| return $formulaire_modele; |
| } else { |
| trigger_error("impossible de trouver le squelette de référence pour le formulaire"); |
| } |
| return false; |
| } |
| /** --------------------------------- Fonction d'extraction d'informations utilisées entre autres par les web services -------------------------------------------*/ |
| public function obtenirValeursUtilisateur($id_annuaire, $id_utilisateur) { |
| $this->chargerModele('AnnuaireModele'); |
| $annuaire = $this->AnnuaireModele->chargerAnnuaire($id_annuaire, false); |
| $this->chargerModele('MetadonneeModele'); |
| $metadonnees = $this->MetadonneeModele->chargerListeMetadonneeAnnuaire($id_annuaire); |
| $tableau_mappage = $this->obtenirChampsMappageAnnuaire($id_annuaire); |
| $valeurs_annuaire = $this->AnnuaireModele->obtenirValeursUtilisateur($id_annuaire, $id_utilisateur,$tableau_mappage[0]); |
| $valeurs_metadonnees= $this->MetadonneeModele->chargerListeValeursMetadonneesUtilisateur($id_annuaire, $id_utilisateur); |
| foreach($tableau_mappage[0] as $cle => $nom_champ) { |
| if($cle != 'champ_id') { |
| $nom_champ_formulaire = $metadonnees[$tableau_mappage[1][$cle]]['amc_abreviation']; |
| $valeur = $valeurs_annuaire[$nom_champ] ; |
| if($cle == 'champ_nom') { |
| $valeur = AppControleur::formaterMotEnMajuscule($valeur); |
| } |
| if($cle == 'champ_prenom') { |
| $valeur = AppControleur::formaterMotPremiereLettreChaqueMotEnMajuscule($valeur); |
| } |
| if(isset($valeurs_metadonnees[$nom_champ_formulaire])) { |
| if(isset($valeurs_metadonnees[$nom_champ_formulaire]['amv_valeur']) && $valeurs_metadonnees[$nom_champ_formulaire]['amv_valeur'] != '') { |
| $valeur = $valeurs_metadonnees[$nom_champ_formulaire]['amv_valeur']; |
| } |
| $informations_champ = array('amv_valeur' => $valeur,'amc_id_champ' => $tableau_mappage[1][$cle]) ; |
| $valeurs_metadonnees[$nom_champ_formulaire] = array_merge($valeurs_metadonnees[$nom_champ_formulaire],$informations_champ); |
| } else { |
| $informations_champ = array('amv_valeur' => $valeur,'amc_id_champ' => $tableau_mappage[1][$cle]) ; |
| $valeurs_metadonnees[$nom_champ_formulaire] = $informations_champ; |
| } |
| } |
| } |
| foreach($valeurs_metadonnees as $nom_champ => $valeur) { |
| $verificateur = new VerificationControleur(); |
| $valeurs_metadonnees[$nom_champ] = $verificateur->verifierEtRemplacerValeurChampPourAffichage($valeur['amc_ce_type_affichage'],$valeur, 1); |
| } |
| return $valeurs_metadonnees; |
| } |
| public function obtenirInfosUtilisateur($id_annuaire,$id, $mail = true) { |
| $this->chargerModele('AnnuaireModele'); |
| if($mail) { |
| $id = $this->AnnuaireModele->obtenirIdParMail($id_annuaire,$id); |
| } |
| $champs_mappage = $this->AnnuaireModele->obtenirChampsMappageAnnuaire($id_annuaire); |
| $valeurs = $this->AnnuaireModele->obtenirValeursUtilisateur($id_annuaire,$id, $champs_mappage[0]); |
| // TODO: valeurs incomplètes, voir ce qu'on renvoie obligatoirement |
| // et ce qu'on ne renvoie pas |
| $valeurs = array('fullname' => $valeurs[$champs_mappage[0]['champ_prenom']].' '.$valeurs[$champs_mappage[0]['champ_nom']], |
| 'nickname' => $valeurs[$champs_mappage[0]['champ_nom']], |
| 'dob' => '', |
| 'email' => $valeurs[$champs_mappage[0]['champ_mail']], |
| 'gender' => '', |
| 'postcode' => $valeurs[$champs_mappage[0]['champ_code_postal']], |
| 'country' => '', |
| 'language' => 'fr', |
| 'timezone' => 'Europe/Paris'); |
| return $valeurs; |
| } |
| public function comparerIdentifiantMotDePasse($id_annuaire,$id_utilisateur,$mot_de_passe, $utilise_mail = true, $mdp_deja_crypte = true) { |
| $this->chargerModele('AnnuaireModele'); |
| if($utilise_mail) { |
| $id_utilisateur = $this->AnnuaireModele->obtenirIdParMail($id_annuaire,$id_utilisateur); |
| } |
| if(!$mdp_deja_crypte) { |
| $mot_de_passe = VerificationControleur::encrypterMotDePasseStatic($mot_de_passe); |
| } |
| return $this->AnnuaireModele->comparerIdentifiantMotDePasse($id_annuaire,$id_utilisateur,$mot_de_passe); |
| } |
| } |
| ?> |
| /tags/v1.5-belier/controleurs/VerificationControleur.php |
|---|
| New file |
| 0,0 → 1,644 |
| <?php |
| /** |
| * PHP Version 5 |
| * |
| * @category PHP |
| * @package annuaire |
| * @author aurelien <aurelien@tela-botanica.org> |
| * @copyright 2010 Tela-Botanica |
| * @license http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt Licence CECILL |
| * @version SVN: <svn_id> |
| * @link /doc/annuaire/ |
| * |
| */ |
| /** |
| * Controleur chargé de la vérification des formulaires |
| * Remplace aussi les valeurs lors des actions spéciales comme la modification du mail |
| * (l'inscription à la lettre d'actu se fait aussi ici même si ça n'est pas totalement sa place) |
| */ |
| class VerificationControleur extends AppControleur { |
| /** |
| * Vérifie que les valeurs des champs de mappage et les valeurs obligatoires d'un annuaire donné |
| * sont correctes |
| * @param int $id_annuaire l'identifiant de l'annuaire |
| * @param Array $valeurs les valeurs à vérifier |
| */ |
| public function verifierErreursChampsSelonType($id_annuaire, $valeurs, $tableau_mappage) { |
| $erreurs = array(); |
| $this->chargerModele('AnnuaireModele'); |
| $tableau_champs_obligatoire = $this->AnnuaireModele->obtenirChampsObligatoires($id_annuaire); |
| if(!$tableau_champs_obligatoire) { |
| $tableau_champs_obligatoire = array(); |
| } |
| foreach($valeurs as $id => $valeur_champ) { |
| $type = $valeur_champ['type']; |
| $valeur = $valeur_champ['valeur']; |
| $condition = $valeur_champ['condition']; |
| switch($type) { |
| case 'text': |
| if($this->estUnchampObligatoire($id, $tableau_champs_obligatoire) && trim($valeur) == '') { |
| $erreurs[$id] = 'Ce champ est obligatoire'; |
| } |
| break; |
| case 'mail': |
| if($this->estUnchampObligatoire($id, $tableau_champs_obligatoire) && trim($valeur) == '') { |
| $erreurs[$id] = 'Le mail est obligatoire '; |
| } |
| if($this->estUnchampObligatoire($id, $tableau_champs_obligatoire) && !$this->mailValide($valeur)) { |
| $erreurs[$id] = 'Le mail est invalide '; |
| } |
| if($this->AnnuaireModele->utilisateurExisteParMail($id_annuaire, $valeur)) { |
| $erreurs[$id] = 'Cet email est déjà utilisé par quelqu\'un d\'autre '; |
| } |
| break; |
| case 'select': |
| if($this->estUnchampObligatoire($id, $tableau_champs_obligatoire) && trim($valeur) == '') { |
| $erreurs[$id] = 'Ce champ est obligatoire'; |
| } |
| break; |
| case 'password': |
| if($this->estUnchampObligatoire($id, $tableau_champs_obligatoire) && trim($valeur) == '' |
| || $valeur != $condition) { |
| $erreurs[$id] = 'Le mot de passe est invalide'; |
| } |
| break; |
| // cas du champ checkbox |
| case 'checkbox': |
| if($this->estUnchampObligatoire($id, $tableau_champs_obligatoire) && trim($condition) != 'on') { |
| $erreurs[$id] = 'N\'oubliez pas de cocher cette case'; |
| } |
| break; |
| default: |
| break; |
| } |
| } |
| if(count($erreurs) == 0) { |
| $erreurs = false; |
| } |
| return $erreurs; |
| } |
| /** |
| * Vérifie les valeurs des champs pour la modification d'un formulaire |
| */ |
| public function verifierErreurChampModification($id_annuaire, $id_utilisateur, $type ,$valeur, $confirmation = false) { |
| $retour = array(true,false); |
| switch($type) { |
| case 'mail': |
| if(!$this->mailValide($valeur)) { |
| $retour[0] = false; |
| $retour[1] = 'mail invalide'; |
| break; |
| } |
| $this->chargerModele('AnnuaireModele'); |
| $ancien_mail = $this->AnnuaireModele->obtenirMailParId($id_annuaire,$id_utilisateur); |
| if($ancien_mail != $valeur && $this->AnnuaireModele->utilisateurExisteParMail($id_annuaire, $valeur)) { |
| $retour[0] = false; |
| $retour[1] = 'cet email est déjà utilisé par quelqu\'un d\'autre'; |
| } |
| break; |
| case 'password': |
| if(trim($valeur) != trim($confirmation)) { |
| $retour[0] = false; |
| $retour[1] = 'mot de passe invalide'; |
| } |
| } |
| return $retour; |
| } |
| public function remplacerValeurChampPourInsertion($type, $valeur, $mail_utilisateur) { |
| $valeur_modifiee = $valeur; |
| switch($type) { |
| // cas du champ texte, à priori, rien de particulier |
| case 'text': |
| $valeur_modifiee = $valeur; |
| break; |
| // cas du champ password : on le crypte |
| case 'password': |
| $valeur_modifiee = $this->encrypterMotDePasse($valeur); |
| break; |
| // 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 { |
| if($valeur == 'on') { |
| // sinon on stocke 1 pour indique que la case est cochée (cas de la checkbox oui/non) |
| $valeur_modifiee = 1; |
| } else { |
| $valeur_modifiee = 0; |
| } |
| } |
| break; |
| case 'lettre': |
| if($valeur == 'on') { |
| // sinon on stocke 1 pour indique que la case est cochée (cas de la checkbox oui/non) |
| $valeur_modifiee = 1; |
| // Si c'est une inscription à la lettre d'actualité, on appelle la fonction d'inscription |
| $lettre_controleur = new LettreControleur(); |
| $lettre_controleur->inscriptionLettreActualite($mail_utilisateur); |
| } else { |
| $valeur_modifiee = 0; |
| } |
| break; |
| default: |
| $valeur_modifiee = $valeur; |
| break; |
| } |
| return $valeur_modifiee; |
| } |
| public function remplacerValeurChampPourModification($id_annuaire, $id_utilisateur, $type, $valeur, $mail_utilisateur) { |
| $valeur_modifiee = $valeur; |
| switch($type) { |
| // cas du champ texte, à priori, rien de particulier |
| case 'text': |
| $valeur_modifiee = $valeur; |
| break; |
| // cas du champ password : on le crypte |
| case 'password': |
| $valeur_modifiee = $this->encrypterMotDePasse($valeur); |
| break; |
| // 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 { |
| if($valeur == 'on' || $valeur == '1') { |
| // sinon on stocke 1 pour indique que la case est cochée (cas de la checkbox oui/non) |
| $valeur_modifiee = 1; |
| } else { |
| $valeur_modifiee = 0; |
| } |
| } |
| break; |
| case 'lettre': |
| // Si c'est une inscription à la lettre d'actualité, on appelle la fonction d'inscription |
| $lettre_controleur = new LettreControleur(); |
| $this->chargerModele('AnnuaireModele'); |
| $ancien_mail = $this->AnnuaireModele->obtenirMailParId($id_annuaire, $id_utilisateur); |
| $changement_mail = false; |
| if($ancien_mail != $mail_utilisateur) { |
| $changement_mail = true; |
| } |
| if($valeur == 'on' || $valeur == '1') { |
| // on stocke 1 pour indique que la case est cochée (comme la checkbox oui/non) |
| $valeur_modifiee = 1; |
| // si le mail a changé on désinscrit l'ancien mail et on inscrit le nouveau |
| if($changement_mail) { |
| $lettre_controleur->ModificationInscriptionLettreActualite($ancien_mail, $mail_utilisateur); |
| } else { |
| $lettre_controleur->inscriptionLettreActualite($mail_utilisateur); |
| } |
| } else { |
| // sinon, si la case est vide |
| $valeur_modifiee = 0; |
| $mail_a_desinscrire = $mail_utilisateur; |
| if($changement_mail) { |
| $mail_a_desinscrire = $ancien_mail; |
| } |
| // on desinscrit l'utilisateur |
| $lettre_controleur->desinscriptionLettreActualite($mail_a_desinscrire); |
| } |
| break; |
| default: |
| $valeur_modifiee = $valeur; |
| break; |
| } |
| return $valeur_modifiee; |
| } |
| public function verifierEtRemplacerValeurChampPourAffichage($type, $valeur, $id_annuaire) { |
| if(!$type) { |
| $valeur_modifiee = array(); |
| $valeur_modifiee['amv_type'] = 'champ_annuaire'; |
| $valeur_modifiee['amv_valeur_affichage'] = $valeur; |
| } else { |
| if(!isset($valeur['amv_valeur'])) { |
| $valeur['amv_valeur'] = ''; |
| } |
| $valeur_modifiee = $valeur; |
| switch($type) { |
| // cas du champ texte, à priori, rien de particulier |
| case 'text': |
| $valeur_modifiee['amv_valeur_affichage'] = $this->remplacerLienHtml($valeur['amv_valeur']); |
| break; |
| // cas du champ texte long, à priori, rien de particulier |
| case 'textarea': |
| $valeur_modifiee['amv_valeur_affichage'] = $this->remplacerLienHtml($valeur['amv_valeur']); |
| break; |
| // cas du champ checkbox |
| case 'checkbox': |
| // si c'est un groupe checkbox, alors c'est une liste de checkbox liée à une ontologie |
| if(isset($valeur['amo_nom'])) { |
| if(is_array($valeur['amo_nom']) && count($valeur['amo_nom']) > 0) { |
| // on stocke les valeurs d'ontologies liées au cases cochées |
| $valeur_modifiee['amv_valeur_affichage'] = implode(', ', $valeur['amo_nom']); |
| } else { |
| $valeur_modifiee['amv_valeur_affichage'] = $valeur['amo_nom']; |
| } |
| } else { |
| // sinon on stocke 1 pour indique que la case est cochée (cas de la checkbox oui/non) |
| if($valeur['amv_valeur'] == 1) { |
| $valeur_modifiee['amv_valeur_affichage'] = 'oui'; |
| } else { |
| $valeur_modifiee['amv_valeur_affichage'] = 'non'; |
| } |
| } |
| break; |
| case 'select': |
| // TODO: si ça n'existe pas on va le chercher ? |
| if(isset($valeur['amo_nom'])) { |
| $valeur_modifiee['amv_valeur_affichage'] = $valeur['amo_nom']; |
| } else { |
| if(isset($valeur['amv_valeur'])) { |
| $ontologie_modele = new OntologieModele(); |
| $infos_onto = $ontologie_modele->chargerInformationsOntologie($valeur['amv_valeur']); |
| if(is_array($infos_onto) && !empty($infos_onto)) { |
| $valeur_modifiee['amv_valeur_affichage'] = $infos_onto['amo_nom']; |
| } else { |
| $valeur_modifiee['amv_valeur_affichage'] = ''; |
| } |
| } else { |
| $valeur_modifiee['amv_valeur_affichage'] = ''; |
| } |
| } |
| break; |
| case 'radio': |
| $valeur_modifiee['amv_valeur_affichage'] = $valeur['amo_nom']; |
| break; |
| case 'image': |
| // si c'est une image, on recherche son url véritable à partir de l'id donnée en paramètre |
| if(isset($valeur['amv_valeur']) && $valeur['amv_valeur'] != '') { |
| $this->chargerModele('ImageModele'); |
| $valeur_modifiee['amv_valeur_affichage'] = $this->ImageModele->obtenirEmplacementFichierParId($valeur['amv_valeur'],$id_annuaire, 'S'); |
| } |
| break; |
| // cas du champ lettre |
| case 'lettre': |
| // on affiche oui ou non |
| if($valeur_modifiee['amv_valeur'] == 1) { |
| $valeur_modifiee['amv_valeur_affichage'] = 'oui'; |
| } else { |
| $valeur_modifiee['amv_valeur_affichage'] = 'non'; |
| } |
| break; |
| // cas de la date, on la formate |
| case 'date': |
| //echo '|'.$valeur['amv_valeur'].'|'; |
| $format = Config::get('date_format_simple'); |
| if(!isset($format)) { |
| $format = 'd/m/Y'; |
| } |
| $time = strtotime($valeur['amv_valeur']); |
| if(!$time || $time == '') { |
| $valeur_modifiee['amv_valeur_affichage'] = $valeur['amv_valeur']; |
| } else { |
| $valeur_modifiee['amv_valeur_affichage'] = date($format, $time); |
| } |
| break; |
| default: |
| $valeur_modifiee['amv_valeur_affichage'] = $valeur['amv_valeur']; |
| break; |
| } |
| } |
| return $valeur_modifiee; |
| } |
| public function collecterValeurInscription($valeurs, $tableau_mappage) { |
| $valeurs_mappees = array(); |
| $valeurs_a_inserer = array(); |
| // on itère sur le tableau de valeur pour récupérer les champs de mappage; |
| foreach($valeurs as $nom_champ => $valeur) { |
| // pour chaque valeur |
| // on extrait l'id du champ |
| $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]; |
| } |
| // Si le champ fait partie des champs mappés |
| $cle_champ = array_search($id_champ, $tableau_mappage[1]); |
| // on ajoute sa clé correspondante dans le tableau des champs mappés |
| // qui sont les champs à vérifier |
| if($condition) { |
| $condition = $valeurs[$type.'_'.$id_champ]; |
| $valeurs_mappees[$id_champ] = array('valeur' => $valeur, 'type' => $type, 'condition' => $condition); |
| } else { |
| //$valeurs_mappees[$cle_champ] = $valeur; |
| $valeurs_mappees[$id_champ] = array('valeur' => $valeur, 'type' => $type, 'condition' => false); |
| } |
| if(!$condition) { |
| $valeurs_a_inserer[$nom_champ] = $valeur; |
| } |
| } |
| return array('valeurs_mappees' => $valeurs_mappees, 'valeurs_a_inserer' => $valeurs_a_inserer); |
| } |
| public function collecterValeursRechercheMoteur($valeurs_recherchees, $tableau_mappage) { |
| // on itère sur le tableau de valeur pour récupérer les métadonnées; |
| foreach($valeurs_recherchees as $nom_champ => $valeur) { |
| $ids_champ = mb_split("_",$nom_champ); |
| if(count($ids_champ) == 2) { |
| $type = $ids_champ[0]; |
| $id_champ = $ids_champ[1]; |
| $cle_champ = array_search($id_champ, $tableau_mappage[1]); |
| if($cle_champ && $cle_champ != 'champ_pays') { |
| $valeurs_mappees[$tableau_mappage[0][$cle_champ]] = $valeur; |
| } else { |
| if($cle_champ && $cle_champ == 'champ_pays' && !is_numeric($valeur)) { |
| $this->chargerModele('MetadonneeModele'); |
| $valeur = $this->MetadonneeModele->obtenirValeurPaysParAbbreviation($valeur); |
| } |
| $valeurs_recherchees[$id_champ] = $valeur; |
| } |
| $valeurs_get[$nom_champ] = $valeur; |
| } |
| unset($valeurs_recherchees[$nom_champ]); |
| } |
| return array('valeurs_mappees' => $valeurs_mappees, 'valeurs_recherchees' => $valeurs_recherchees, 'valeurs_get' => $valeurs_get); |
| } |
| public function convertirTableauRechercheVersChaine($id_annuaire, $valeurs_recherchees) { |
| $this->chargerModele('MetadonneeModele'); |
| $metadonnees = $this->MetadonneeModele->chargerListeMetadonneeAnnuaire($id_annuaire); |
| $champs = array(); |
| foreach($metadonnees as $id => $metadonnee) { |
| $id_champ_formulaire = $metadonnee['amc_ce_template_affichage'].'_'.$id; |
| if(isset($valeurs_recherchees[$id_champ_formulaire]) && $valeurs_recherchees[$id_champ_formulaire] != '') { |
| $valeur = $valeurs_recherchees[$id_champ_formulaire]; |
| $champs[] = array('label' => $metadonnee['amc_nom'], |
| 'valeur' => $this->convertirValeurChampRechercheVersTexte($metadonnee, $valeur) |
| ); |
| } |
| } |
| return $champs; |
| } |
| private function convertirValeurChampRechercheVersTexte($metadonnee, $valeur) { |
| if($metadonnee['amc_ce_ontologie'] != 0) { |
| $valeurs_onto = array(); |
| if(is_array($valeur)) { |
| foreach($valeur as $id => $element) { |
| $valeur_element = $this->MetadonneeModele->renvoyerCorrespondanceNomId($id, $metadonnee['amc_ce_ontologie']); |
| $valeurs_onto[] = $valeur_element['amo_nom']; |
| } |
| $valeur = implode(', ',$valeurs_onto); |
| } else { |
| if(is_numeric($valeur)) { |
| $valeurs_onto = $this->MetadonneeModele->renvoyerCorrespondanceNomId($valeur, $metadonnee['amc_ce_ontologie']); |
| $valeur = $valeurs_onto['amo_nom']; |
| } else { |
| $valeur_onto = $this->MetadonneeModele->renvoyerCorrespondanceNomParAbreviation($valeur, $metadonnee['amc_ce_ontologie']); |
| $valeur = $valeur_onto; |
| } |
| } |
| } |
| return $valeur; |
| } |
| /** |
| * 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 |
| */ |
| public function mailValide($mail) { |
| $regexp_mail = '/^[_a-z0-9-]+(\.[_a-z0-9-]+)*@[a-z0-9-]+(\.[a-z0-9-]+)*(\.[a-z]{2,3})$/'; |
| return preg_match($regexp_mail, strtolower($mail)); |
| } |
| /** |
| * 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é |
| */ |
| public function encrypterMotDePasse($pass) { |
| $fonction = Config::get('pass_crypt_fonct'); |
| if(function_exists($fonction)) { |
| return $fonction($pass); |
| } else { |
| return md5($pass); |
| } |
| } |
| //TODO: créer une class util |
| static function encrypterMotDepasseStatic($pass) { |
| $fonction = Config::get('pass_crypt_fonct'); |
| if(function_exists($fonction)) { |
| return $fonction($pass); |
| } else { |
| return md5($pass); |
| } |
| } |
| static function convertirTailleFichier($taille) { |
| if(!$taille) { |
| return "0 Mo"; |
| } |
| return number_format($taille*(1/1024)*(1/1024), 0).' Mo'; |
| } |
| public function genererMotDePasse() { |
| $pass = ""; |
| $chaine = "abcdefghkmnpqrstuvwxyzABCDEFGHKLMNPQRSTUVWXYZ23456789"; |
| srand((double)microtime()*1000000); |
| for($i = 0; $i < 10; $i++){ |
| $pass .= $chaine[rand()%strlen($chaine)]; |
| } |
| return $pass; |
| } |
| public static function champEstRempli($champ) { |
| return is_array($champ) && isset($champ['amv_valeur_affichage']) && trim($champ['amv_valeur_affichage']) != ''; |
| } |
| public static function AfficherSiChampRempli($champ, $chaine_format = '%s') { |
| $affichage = ''; |
| if (self::champEstRempli($champ)) { |
| $valeur = $champ['amv_valeur_affichage']; |
| $affichage = sprintf($chaine_format,$valeur); |
| } |
| return $affichage; |
| } |
| public static function AfficherChampSiAdmin($champ, $chaine_format = '%s') { |
| $affichage = ''; |
| if (Registre::getInstance()->get('est_admin')) { |
| $affichage = self::AfficherSiChampRempli($champ, $chaine_format); |
| } |
| return $affichage; |
| } |
| /** |
| * Suivant un identifiant de champ et un tableau, renvoie vrai ou faux suivant que le champs est obligatoire ou non |
| * @param int $id_champ l'identifiant de champ |
| * @param int $champ_obligatoire le tableau des champs obligatoires |
| */ |
| private function estUnchampObligatoire($id_champ, $champs_obligatoire) { |
| return in_array($id_champ, $champs_obligatoire) || in_array($id_champ, array_keys($champs_obligatoire)); |
| } |
| /** |
| * |
| */ |
| private function remplacerLienHtml($texte) { |
| $expr = "(http[\S\.\/:]*)"; |
| $matches = array(); |
| preg_match_all($expr, $texte, $matches); |
| foreach($matches as $match) { |
| foreach($match as $element) { |
| $str_lien = '<div><a class="info_resume" href="'.$element.'" >'.$element.'</a></div>'; |
| $texte = str_replace($element, $str_lien, $texte); |
| } |
| } |
| return $texte; |
| } |
| } |
| ?> |
| /tags/v1.5-belier/controleurs/MessageControleur.php |
|---|
| New file |
| 0,0 → 1,620 |
| <?php |
| /** |
| * PHP Version 5 |
| * |
| * @category PHP |
| * @package annuaire |
| * @author aurelien <aurelien@tela-botanica.org> |
| * @copyright 2010 Tela-Botanica |
| * @license http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt Licence CECILL |
| * @version SVN: <svn_id> |
| * @link /doc/annuaire/ |
| */ |
| Class MessageControleur extends AppControleur { |
| /** |
| * Les mails doivent ils être modérés ? |
| */ |
| private $moderer_mail = false; |
| /** |
| * Doit on envoyer une copie des message au modérateur |
| */ |
| private $moderation_copie = false; |
| /** |
| * Le ou les mails des modérateurs, si ce sont plusieurs mails, |
| * ils doivent être séparés par des virgules |
| */ |
| private $mail_moderateur = ''; |
| /** |
| * Nombre de destinataires au dessus duquel on modère les mails |
| */ |
| private $seuil_moderation = 10; |
| /** |
| * Adresse mail de l'expéditeur à partir laquelle sont envoyée les mails de modération |
| */ |
| private $adresse_mail_annuaire = ''; |
| /** |
| * Tableau recapitulatif de la derniere recherche effectuée pour envoyer un message |
| */ |
| private $criteres_recherche_effectuee = null; |
| /** |
| * Définit si les messages doivent être traités immédiatement (au risque de faire planter l'appli |
| * en cas de trop grand nombre de destinataires ou bien si un script "cronné" les traitera |
| */ |
| private $traitement_messages_differe = false; |
| /** |
| * |
| * Constructeur sans paramètres |
| */ |
| public function MessageControleur() { |
| $this->__construct(); |
| // doit on modérer ? |
| if (Config::get('moderer_mail') != null) { |
| $this->moderer_mail = Config::get('moderer_mail'); |
| } |
| // doit on envoyer des copies des messages ? |
| if (Config::get('moderation_copie') != null) { |
| $this->moderation_copie = Config::get('moderation_copie'); |
| } |
| // mail du modérateur pour l'envoi de messages au dessus d'un certain seuil |
| if ($this->moderer_mail && Config::get('mail_moderateur') != null) { |
| $this->mail_moderateur = Config::get('mail_moderateur'); |
| } |
| // seuil de modération |
| if ($this->moderer_mail && Config::get('seuil_moderation_messages') != null) { |
| $this->seuil_moderation = Config::get('seuil_moderation_messages'); |
| } |
| // adresse d'expéditeur |
| if (Config::get('adresse_mail_annuaire') != null) { |
| $this->adresse_mail_annuaire = Config::get('adresse_mail_annuaire'); |
| } |
| // adresse d'expéditeur |
| if (Config::get('traitement_messages_differe') != null) { |
| $this->traitement_messages_differe = Config::get('traitement_messages_differe'); |
| } |
| } |
| /** -------------------Fonctions pour l'inscription et l'oubli de mot de passe -----------------------*/ |
| /** |
| * 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) { |
| $lien_confirmation_inscription = AppControleur::getUrlConfirmationInscription($code_confirmation_inscription); |
| $donnees = array('nom' => $nom, 'prenom' => $prenom, 'lien_confirmation_inscription' => $lien_confirmation_inscription); |
| $contenu_mail = $this->getVue(Config::get('dossier_squelettes_mails').'mail_confirmation_inscription',$donnees); |
| // en attendant de gérer mieux l'envoi en mode texte |
| // remplacement du & dans les urls |
| $contenu_mail = str_replace('&', '&', $contenu_mail); |
| return $this->envoyerMail(Config::get('adresse_mail_annuaire'),$adresse_mail,'Inscription à l\'annuaire',$contenu_mail); |
| } |
| /** 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 |
| */ |
| public function envoyerMailOubliMdp($id_annuaire,$mail, $nouveau_mdp) { |
| $base_url = clone(Registre::getInstance()->get('base_url_application')); |
| $url_cette_page = 'http://'.$_SERVER['SERVER_NAME'].$_SERVER['REQUEST_URI']; |
| $url_base = $url_cette_page; |
| $base_url = new URL($url_base); |
| $base_url->setVariablesRequete(array()); |
| $base_url->setVariableRequete('m','annuaire_fiche_utilisateur_consultation'); |
| $base_url->setVariableRequete('id_annuaire',$id_annuaire); |
| $donnees['nouveau_mdp'] = $nouveau_mdp; |
| $donnees['lien_profil'] = $base_url; |
| $contenu_mail = $this->getVue(Config::get('dossier_squelettes_mails').'mail_oubli_mdp',$donnees); |
| return $this->envoyerMail(Config::get('adresse_mail_annuaire'),$mail,'Demande de réinitialisation de mot de passe',$contenu_mail); |
| } |
| /** -------------------Fonctions pour la messagerie entre utilisateurs -----------------------*/ |
| /** Effectue une recherche dans la base de données et envoie un mail à tous les inscrits correspondants, |
| * à l'adresse donnée en paramètre |
| * @param string $expediteur l'expediteur du message |
| * @param mixed $destinataires un string ou un tableau de mails qui contiennent les destinataire |
| * @param string $sujet sujet du mail |
| * @return boolean true ou false suivant le succès ou non de l'envoi |
| */ |
| public function envoyerMailParRequete($id_annuaire, $expediteur, $criteres, $sujet, $message) { |
| if (isset($criteres['exclusive'])) { |
| $exclusive = $criteres['exclusive']; |
| } else { |
| $exclusive = true; |
| } |
| unset($criteres['id_annuaire']); |
| unset($criteres['page']); |
| unset($criteres['taille_page']); |
| $collecteur = new VerificationControleur(); |
| $tableau_valeur_collectees = $collecteur->collecterValeursRechercheMoteur($criteres, $this->obtenirChampsMappageAnnuaire($id_annuaire)); |
| $this->criteres_recherche_effectuee = $collecteur->convertirTableauRechercheVersChaine($id_annuaire, $criteres); |
| $valeurs_recherchees = $tableau_valeur_collectees['valeurs_recherchees']; |
| $valeurs_mappees = $tableau_valeur_collectees['valeurs_mappees']; |
| $valeurs_get = $tableau_valeur_collectees['valeurs_get']; |
| if(isset($criteres['tous']) && $criteres['tous'] == 1) { |
| $this->chargerModele('AnnuaireModele'); |
| $resultat_annuaire_mappe = $this->AnnuaireModele->chargerAnnuaireListeInscrits($id_annuaire,0,0); |
| } else { |
| // 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); |
| // 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 |
| $this->chargerModele('AnnuaireModele'); |
| $resultat_annuaire_mappe = $this->AnnuaireModele->rechercherInscritDansAnnuaireMappe($id_annuaire,$valeurs_mappees, $resultat_metadonnees, $exclusive, 0, 0); |
| } |
| $resultat_recherche = $resultat_annuaire_mappe['resultat']; |
| $nb_resultats = $resultat_annuaire_mappe['total']; |
| $destinataires = $this->aplatirTableauSansPreserverCles($resultat_recherche); |
| return $this->envoyerMailDirectOuModere($id_annuaire, $expediteur, $destinataires, $sujet, $message); |
| } |
| /** Envoie un mail au format texte avec l'adresse de l'utilisateur donné en paramètre, |
| * à l'adresse donnée en paramètre |
| * |
| * ATTENTION : le sujet et le contenu envoyés à cette méthode doivent avoir le même encodage que l'application. |
| * |
| * @param string $expediteur l'expediteur du message |
| * @param mixed $destinataires un string ou un tableau de mails qui contiennent les destinataire |
| * @param string $sujet sujet du mail |
| * @return boolean true ou false suivant le succès ou non de l'envoi |
| */ |
| public function envoyerMailText($expediteur, $destinataires, $sujet, $message, $adresse_reponse = null) { |
| if (!is_array($destinataires)) { |
| $destinataires = array($destinataires); |
| } |
| // Définition d'un mail en texte simple |
| $entetes = |
| "X-Sender: <http://www.tela-botanica.org>\n". |
| "X-Mailer: PHP-ANNUAIRE-TXT\n". |
| "X-auth-smtp-user: annuaire@tela-botanica.org \n". |
| "X-abuse-contact: annuaire@tela-botanica.org \n". |
| "Date: ".date('r')."\n". |
| "From: $expediteur\n". |
| 'Content-Type: text/plain; charset="'.Config::get('appli_encodage').'";'."\n"; |
| if ($adresse_reponse !== null) { |
| $entetes .= 'Reply-To: '.$adresse_reponse."\n"; |
| } |
| $entetes .= "Content-Transfer-Encoding: 8bit;\n\n"; |
| $sujetEncode = mb_encode_mimeheader($this->encoderChainePourEnvoiMail($sujet), mb_internal_encoding(), "B", "\n"); |
| $contenu = $this->encoderChainePourEnvoiMail($message); |
| foreach ($destinataires as $destinataire) { |
| if (!mail($destinataire, $sujetEndode, $contenu, $entetes)) { |
| return false; |
| } |
| } |
| return true; |
| } |
| /** Envoie un mail avec l'adresse de l'utilisateur donné en paramètre, à l'adresse donnée en paramètre. |
| * ATTENTION : le sujet et le contenu envoyer à cette méthode doivent avoir le même encodage que l'application. |
| * |
| * @param string $expediteur l'expediteur du message |
| * @param mixed $destinataires un string ou un tableau de mails qui contiennent les destinataire |
| * @param string $sujet sujet du mail |
| * @return boolean true ou false suivant le succès ou non de l'envoi |
| */ |
| public function envoyerMail($expediteur, $destinataires, $sujet, $message_html, $message_texte = '', $adresse_reponse = null) { |
| if (!is_array($destinataires)) { |
| $destinataires = array($destinataires); |
| } |
| $message_html = $this->encoderChainePourEnvoiMail($message_html); |
| if ($message_texte == '') { |
| $message_texte = $this->filtrerChaine($message_html); |
| } |
| $encodage = Config::get('appli_encodage'); |
| $limite = "_----------=_parties_".md5(uniqid(rand())); |
| $eol = "\n"; |
| $entetes = ''; |
| // Définition d'un mail en texte simple et html |
| // multipart/alternative signifie même contenu de la forme la plus simple à la plus complexe |
| $entetes .= "X-Sender: <http://www.tela-botanica.org>".$eol. |
| "X-Mailer: PHP-ANNUAIRE-HTML".$eol. |
| "X-auth-smtp-user: annuaire@tela-botanica.org ".$eol. |
| "X-abuse-contact: annuaire@tela-botanica.org ".$eol. |
| 'Date: '.date('r').$eol. |
| 'From: '.$expediteur.$eol. |
| 'MIME-Version: 1.0'.$eol; |
| if ($adresse_reponse !== null) { |
| $entetes .= 'Reply-To: '.$adresse_reponse.$eol; |
| } |
| $entetes .= "Content-Type: multipart/alternative; boundary=\"$limite\";".$eol.$eol; |
| // message en texte simple |
| $contenu = "--$limite".$eol. |
| "Content-Type: text/plain; charset=\"$encodage\";".$eol. |
| "Content-Transfer-Encoding: 8bit;".$eol.$eol. |
| $message_texte.$eol.$eol. |
| // le message en html est préféré s'il est lisible |
| "--$limite".$eol. |
| "Content-Type: text/html; charset=\"$encodage\";".$eol. |
| "Content-Transfer-Encoding: 8bit;".$eol.$eol. |
| $message_html.$eol.$eol. |
| "--$limite--".$eol.$eol; |
| $sujetEncode = mb_encode_mimeheader($this->encoderChainePourEnvoiMail($sujet), $encodage, "B", "\n"); |
| $ok = true; |
| foreach ($destinataires as $destinataire) { |
| $ok = mail($destinataire, $sujetEncode, $contenu, $entetes); |
| if (!$ok) { |
| break; |
| } |
| } |
| return $ok; |
| } |
| /** |
| * ATTENTION : le sujet et le contenu envoyer à cette méthode doivent avoir le même encodage que l'application. |
| */ |
| public function envoyerMailAvecPieceJointe($expediteur, $destinataires, $sujet, $message, $piece_jointe = null, $nom_fichier, $type_mime = 'text/plain', $adresse_reponse = null) { |
| if (!is_array($destinataires)) { |
| $destinataires = array($destinataires); |
| } |
| $message_antislashe = $this->encoderChainePourEnvoiMail($message); |
| $message_texte = $this->filtrerChaine($message); |
| $message_html = nl2br($message_antislashe); |
| $limite = "_----------=_parties_".md5(uniqid (rand())); |
| $limite_partie_message = "_----------=_parties_".md5(uniqid (rand() + 1)); |
| // Définition d'un mail avec différents type de contenu |
| $entetes = "X-Sender: <http://www.tela-botanica.org>\n". |
| "X-Mailer: PHP-ANNUAIRE-PJ\n". |
| "X-auth-smtp-user: annuaire@tela-botanica.org \n". |
| "X-abuse-contact: annuaire@tela-botanica.org \n". |
| "Date: ".date('r')."\n". |
| "From: $expediteur\n". |
| 'MIME-Version: 1.0' . "\n"; |
| if ($adresse_reponse !== null) { |
| $entetes .= 'Reply-To: '.$adresse_reponse.$eol; |
| } |
| // Définition d'un type de contenu mixed (mail (texte + html) + piece jointe) |
| $entetes .= "Content-Type: multipart/mixed; boundary=\"$limite\";\n\n"; |
| // Première sous partie : contenu du mail |
| $contenu = "\n". |
| "--$limite\n". |
| // Définition d'un type de contenu alternatif pour l'envoi en html et texte |
| "Content-Type: multipart/alternative; boundary=\"$limite_partie_message\";\n". |
| // Version texte |
| "\n". |
| "--$limite_partie_message\n". |
| "Content-Type: text/plain; charset=\"".Config::get('appli_encodage')."\";\n". |
| "Content-Transfer-Encoding: 8bit;\n". |
| "\n". |
| "$message_texte\n". |
| // Version html |
| "--$limite_partie_message\n". |
| "Content-Type: text/html; charset=\"".Config::get('appli_encodage')."\";\n". |
| "Content-Transfer-Encoding: 8bit;\n". |
| "\n". |
| $message_html."\n". |
| "\n". |
| "--$limite_partie_message--\n". |
| "--$limite\n"; |
| // Seconde sous partie : pièce jointe |
| if ($piece_jointe != null) { |
| $attachment = chunk_split(base64_encode($piece_jointe)); |
| $contenu .= "Content-Type: $type_mime; name=\"$nom_fichier\"\n". |
| "Content-Transfer-Encoding: base64\n". |
| "Content-Disposition: attachment; filename=\"$nom_fichier\"\n". |
| "X-Attachment-Id: ".md5($attachment)."\n\n". |
| "$attachment\n". |
| "--$limite--\n"; |
| } |
| $sujetEncode = mb_encode_mimeheader($sujet, mb_internal_encoding(), "B", "\n"); |
| foreach ($destinataires as $destinataire) { |
| if (!mail($destinataire, $sujetEncode, $contenu, $entetes)) { |
| return false; |
| } |
| } |
| return true; |
| } |
| /** |
| * Avec des l'informations d'expéditions données en paramètres, décide si un mail peut être envoyé directement |
| * ou bien s'il doit être stocké et soumis à modération |
| * @param int $id_annuaire l'identifiant de l'annuaire à utiliser |
| * @param string $expediteur l'expéditeur du mail |
| * @param array $destinataires les destinataires du mail |
| * @param string $sujet sujet du message |
| * @param string $message corps du message |
| * @param string $donnees_sup tableau d'informations supplémentaires à joindre au message |
| */ |
| public function envoyerMailDirectOuModere($id_annuaire, $expediteur, $destinataires, $sujet = '', $message = '') { |
| $donnees['erreurs'] = false; |
| if (!Registre::getInstance()->get('est_admin')) { |
| $donnees['contenu_message'] = $this->filtrerChaine($message); |
| } else { |
| $donnees['contenu_message'] = nl2br($message); |
| } |
| $sujet = $this->filtrerChaine($sujet); |
| if (count($destinataires) == 0) { |
| $donnees['erreurs'] = true; |
| $donnees['pas_de_destinataire'] = true; |
| } |
| if (trim($sujet) == '') { |
| $donnees['erreurs'] = true; |
| $donnees['pas_de_sujet'] = true; |
| } else { |
| $donnees['sujet_message'] = $sujet; |
| } |
| if (trim($message) == '') { |
| $donnees['erreurs'] = true; |
| $donnees['pas_de_message'] = true; |
| } |
| if (!$donnees['erreurs']) { |
| $template_mail = 'mail_messagerie'; |
| if (Registre::getInstance()->get('est_admin')) { |
| $template_mail = 'mail_messagerie_admin'; |
| } |
| $destinataires_mail = $this->obtenirMailParTableauId($id_annuaire, $destinataires); |
| $message = $this->getVue(Config::get('dossier_squelettes_mails').$template_mail,$donnees); |
| // si on modere les mails et s'il y a trop de destinataires |
| if ($this->moderer_mail && count($destinataires_mail) >= $this->seuil_moderation) { |
| $stockage_mail = $this->stockerMailPourModeration($expediteur, $destinataires_mail, $sujet, $message); |
| $donnees['moderation'] = true; |
| if (!$stockage_mail) { |
| $donnees['erreurs'] = true; |
| } |
| } else { |
| // sinon, envoi direct |
| $envoi_mail_direct = $this->envoyerMail($expediteur, $destinataires_mail, $sujet, $message); |
| if ($this->moderation_copie) { |
| $this->envoyerCopieMessageAuModerateur($id_annuaire, $expediteur, $sujet, $destinataires_mail, $message); |
| } |
| if (!$envoi_mail_direct) { |
| $donnees['erreurs'] = true; |
| } |
| $donnees['moderation'] = false; |
| } |
| } |
| $resultat = $this->getVue(Config::get('dossier_squelettes_annuaires').'message_envoi_confirmation',$donnees); |
| return $resultat; |
| } |
| public function obtenirMailParTableauId($id_annuaire, $destinataires) { |
| // on remplace les identifiants par leurs destinataires |
| $this->chargerModele('AnnuaireModele'); |
| $destinataires_mails = $this->AnnuaireModele->obtenirMailParTableauId($id_annuaire, $destinataires); |
| return $destinataires_mails; |
| } |
| private function envoyerCopieMessageAuModerateur($id_annuaire, $expediteur, $sujet, $destinataires, $message) { |
| $donnees['expediteur_message'] = $expediteur; |
| $donnees['sujet_message'] = $sujet; |
| $donnees['contenu_message'] = $message; |
| if (is_array($destinataires)) { |
| $destinataires = implode(', ', $destinataires); |
| } |
| $donnees['destinataires_message'] = $destinataires; |
| if ($this->criteres_recherche_effectuee != null) { |
| $donnees['criteres'] = $this->criteres_recherche_effectuee; |
| } |
| $contenu_mail_copie = $this->getVue(Config::get('dossier_squelettes_mails').'mail_moderation_copie',$donnees); |
| return $this->envoyerMail($this->adresse_mail_annuaire, $this->mail_moderateur, 'Un message a été envoyé à travers l\'annuaire', $contenu_mail_copie); |
| } |
| /** |
| * Retrouve les informations d'un mail en attente de modération et envoie le mail |
| * @param string $code_confirmation le code associé au données en attente |
| */ |
| public function envoyerMailModere($code_confirmation) { |
| // chargement des données temporaire |
| $message_modele = $this->getModele('DonneeTemporaireModele'); |
| $mail_a_moderer = $message_modele->chargerDonneeTemporaire($code_confirmation); |
| if ($mail_a_moderer) { |
| if($this->traitement_messages_differe) { |
| // envoi différé à travers un script tournant en permanence |
| $mise_en_traitement = $message_modele->mettreDonneeTemporaireATraiter($code_confirmation); |
| $donnees = ($mise_en_traitement) ? array('mise_en_traitement_reussie' => true) : array('mise_en_traitement_echouee' => true); |
| } else { |
| // envoi classique (immédiat) |
| $resultat_envoi = $this->envoyerMail($mail_a_moderer['expediteur'], |
| $mail_a_moderer['destinataires'], |
| $mail_a_moderer['sujet'], |
| $mail_a_moderer['message']); |
| $donnees = ($resultat_envoi) ? array('envoi_reussi' => true) : array('envoi_echoue' => true); |
| $message_modele->supprimerDonneeTemporaire($code_confirmation); |
| } |
| } else { |
| $donnees = array('message_inexistant' => true); |
| } |
| $resultat = $this->getVue(Config::get('dossier_squelettes_annuaires').'message_moderation_confirmation',$donnees); |
| return $resultat; |
| } |
| /** |
| * Supprime un mail en attente de modération grâce au code donné en paramètre |
| * @param string $code_confirmation le code associé au données en attente |
| */ |
| public function supprimerMailModere($code_confirmation) { |
| $message_modele = $this->getModele('DonneeTemporaireModele'); |
| $message_modele->supprimerDonneeTemporaire($code_confirmation); |
| $donnees = array('message_supprime' => true); |
| $resultat = $this->getVue(Config::get('dossier_squelettes_annuaires').'message_moderation_confirmation',$donnees); |
| return $resultat; |
| } |
| /** |
| * Stocke un mail dans la base des données temporaires et envoie un mail au modérateur |
| * @param string $expediteur l'expéditeur du mail |
| * @param array $destinataires les destinataires du mail |
| * @param string $sujet sujet du message |
| * @param string $message corps du message |
| */ |
| private function stockerMailPourModeration($expediteur ,$destinataires, $sujet, $message) { |
| $mail = array('expediteur' => $expediteur, |
| 'destinataires' => $destinataires, |
| 'sujet' => $sujet, |
| 'message' => $message); |
| $message_modele = $this->getModele('DonneeTemporaireModele'); |
| $id_stockage = $message_modele->stockerDonneeTemporaire($mail, true); |
| if ($id_stockage) { |
| $this->envoyerMailModeration($id_stockage, $expediteur ,$destinataires, $sujet , $message); |
| return true; |
| } |
| return false; |
| } |
| /** |
| * Envoie un mail au modérateur contenant les liens pour, au choix, refuser ou bien accepter l'envoi du mail |
| * @param int $id_mail_a_moderer identifiant du mail à modérer (dans la table des données temporaires) |
| * @param string $sujet_message_a_moderer sujet du message |
| * @param string $message_a_moderer corps du message |
| */ |
| private function envoyerMailModeration($id_mail_a_moderer, $expediteur, $destinataires, $sujet_message_a_moderer, $message_a_moderer) { |
| $url_cette_page = $this->getUrlCettePage(); |
| $url_base = $url_cette_page; |
| $base_url = new URL($url_base); |
| $base_url->setVariablesRequete(array()); |
| $donnees = array(); |
| $base_url->setVariableRequete('id',$id_mail_a_moderer); |
| $lien_accepter_mail = clone($base_url); |
| $lien_refuser_mail = clone($base_url); |
| $lien_accepter_mail->setVariableRequete('m','message_moderation_confirmation'); |
| $lien_refuser_mail->setVariableRequete('m','message_moderation_suppression'); |
| $donnees['lien_accepter_mail'] = $lien_accepter_mail; |
| $donnees['lien_refuser_mail'] = $lien_refuser_mail; |
| $donnees['expediteur_message'] = $expediteur; |
| $donnees['sujet_message'] = $sujet_message_a_moderer; |
| $donnees['contenu_message'] = $message_a_moderer; |
| if (is_array($destinataires)) { |
| $destinataires = implode(', ', $destinataires); |
| } |
| $donnees['destinataires_message'] = $destinataires; |
| if ($this->criteres_recherche_effectuee != null) { |
| $donnees['criteres'] = $this->criteres_recherche_effectuee; |
| } |
| $contenu_mail = $this->getVue(Config::get('dossier_squelettes_mails').'mail_moderation_message',$donnees); |
| return $this->envoyerMail($this->adresse_mail_annuaire, $this->mail_moderateur, 'Un message est en attente de modération', $contenu_mail); |
| } |
| public function afficherMailsEnAttenteModeration() { |
| } |
| /** Transforme automatiquement le message html en message txt. |
| * |
| * Réalise un strip_tags et avant ça un remplacement des liens sur mesure pour les mettre au format email txt. |
| */ |
| private function filtrerChaine($messageHtml) { |
| $messageTxt = strip_tags($messageHtml); |
| if ($messageHtml != $messageTxt) { |
| $html = $this->ajouterHrefDansBalise($messageHtml); |
| $messageAvecEntites = strip_tags($html); |
| // TODO : en précisant l'encodage de l'appli dans html_entity_decode un double encodage UTF-8 se produit... |
| $messageTxt = html_entity_decode($messageAvecEntites, ENT_QUOTES); |
| } |
| return $messageTxt; |
| } |
| /** |
| * Extrait la valeur de l'attribut href des balises HTML de liens (a) et ajoute le lien entre |
| * chevrons (<>) dans le contenu de la balise "a". |
| */ |
| private function ajouterHrefDansBalise($html) { |
| $dom = new DOMDocument; |
| $dom->loadHTML($html); |
| foreach ($dom->getElementsByTagName('a') as $node) { |
| if ($node->hasAttribute( 'href' )) { |
| $href = $node->getAttribute('href'); |
| $node->nodeValue = $node->nodeValue." < $href >"; |
| } |
| } |
| $html = $dom->saveHtml(); |
| return $html; |
| } |
| private function encoderChainePourEnvoiMail($chaine) { |
| // TODO: fonction vide, à scinder en deux fonctions une pour les admins et l'autres |
| // pour les utilisateurs normaux (genre filtrer html ou non) |
| return $chaine; |
| } |
| } |
| /tags/v1.5-belier/controleurs/IdentificationControleur.php |
|---|
| New file |
| 0,0 → 1,104 |
| <?php |
| /** |
| * PHP Version 5 |
| * |
| * @category PHP |
| * @package annuaire |
| * @author aurelien <aurelien@tela-botanica.org> |
| * @copyright 2010 Tela-Botanica |
| * @license http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt Licence CECILL |
| * @version SVN: <svn_id> |
| * @link /doc/annuaire/ |
| */ |
| Class IdentificationControleur extends AppControleur { |
| private $nom_cookie_persistant = ''; |
| private $duree_identification = '0'; |
| private $fonction_cryptage_mdp_cookie = 'md5'; |
| private $objet_identification = null; |
| /*public function IdentificationControleur() { |
| Controleur::__construct(); |
| $this->cookie_persistant_nom = session_name().'-memo'; |
| $this->cookie_persistant_nom = 'pap-admin_papyrus_-memo'; |
| $this->duree_identification = time()+Config::get('duree_session_identification'); |
| $this->fonction_cryptage_mdp_cookie = Config::get('fonction_cryptage_mdp_cookie'); |
| }*/ |
| public function afficherFormulaireIdentification($id_annuaire, $donnees = array()) { |
| $this->chargerModele('AnnuaireModele'); |
| $annuaire = $this->AnnuaireModele->chargerAnnuaire($id_annuaire); |
| if(!isset($donnees['informations'])) { |
| $donnees['informations'] = array(); |
| } |
| $donnees['id_annuaire'] = $id_annuaire; |
| return $this->getVue(Config::get('dossier_squelettes_formulaires').'identification',$donnees); |
| } |
| public function loggerUtilisateur($utilisateur, $pass) { |
| $this->objet_identification = Config::get('objet_identification'); |
| // on cree le cookie |
| $this->creerCookie($utilisateur, $pass); |
| // On loggue l'utilisateur |
| $this->objet_identification->username = $utilisateur; |
| $this->objet_identification->password = $pass; |
| $this->objet_identification->login(); |
| return true; |
| } |
| public function deLoggerUtilisateur() { |
| $this->objet_identification = Config::get('objet_identification'); |
| $this->objet_identification->logout(); |
| return true; |
| } |
| public function setUtilisateur($nom_utilisateur) { |
| $this->objet_identification = Config::get('objet_identification'); |
| $this->objet_identification->setAuth($nom_utilisateur); |
| $pass = $this->objet_identification->password; |
| $this->creerCookie($nom_utilisateur, $pass, true); |
| } |
| public function creerCookie($utilisateur, $pass, $pass_deja_crypte = false) { |
| $this->objet_identification = Config::get('objet_identification'); |
| // Expiration si l'utilisateur ne referme pas son navigateur |
| $this->objet_identification->setExpire(0); |
| // Création d'un cookie pour rendre permanente l'identification de Papyrus |
| if(!$pass_deja_crypte) { |
| $pass_crypt = md5($pass); |
| } else { |
| $pass_crypt = $pass; |
| } |
| $cookie_val = $pass_crypt.$utilisateur; |
| setcookie(session_name().'-memo', $cookie_val, 0, '/'); |
| } |
| public function obtenirLoginUtilisateurParCookie() { |
| $nom_utilisateur = Config::get('nom_utilisateur'); |
| if(isset($_COOKIE[$nom_utilisateur])) { |
| $login_utilisateur = $_COOKIE[$nom_utilisateur]; |
| return $login_utilisateur; |
| } else { |
| return false; |
| } |
| } |
| } |
| ?> |
| /tags/v1.5-belier/controleurs/GestionAnnuaireControleur.php |
|---|
| New file |
| 0,0 → 1,232 |
| <?php |
| /** |
| * PHP Version 5 |
| * |
| * @category PHP |
| * @package annuaire |
| * @author aurelien <aurelien@tela-botanica.org> |
| * @copyright 2010 Tela-Botanica |
| * @license http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt Licence CECILL |
| * @version SVN: <svn_id> |
| * @link /doc/annuaire/ |
| */ |
| class GestionAnnuaireControleur extends AppControleur { |
| private $id_liste_champs = 30768; |
| /**--------Fonctions d'ajout et de modification des annuaires --------*/ |
| /** |
| * Charge la vue contenant les informations d'un annuaire donné en paramètre |
| * @param int $id l'identifiant de l'annuaire |
| * @return string la vue contenant les informations sur l'annuaire |
| */ |
| public function chargerAnnuaire($id) { |
| $this->chargerModele('AnnuaireModele'); |
| $this->chargerModele('MetadonneeModele'); |
| $data['erreurs'] = array(); |
| $data['champs_mappage'] = $this->obtenirChampsMappageAnnuaire($id); |
| $data['annuaire'] = $this->AnnuaireModele->chargerAnnuaire($id, true); |
| $data['metadonnees'] = $this->MetadonneeModele->chargerListeMetadonneeAnnuaire($id); |
| $annuaire = $this->getVue(Config::get('dossier_squelettes_gestion_annuaires').'annuaire', $data); |
| return $annuaire; |
| } |
| /** |
| * Affiche le formulaire d'ajout d'un annuaire |
| * @param Array $valeurs les valeurs à inclure dans le formulaire (dans le cas du retour erreur) |
| * @return string la vue contenant le formulaire |
| */ |
| public function afficherFormulaireAjoutAnnuaire($donnees) { |
| $champs = array( |
| "aa_nom" => '', |
| "aa_description" => '', |
| "aa_bdd" => '', |
| "aa_table" => '', |
| "aa_code" => '', |
| "aa_champ_id" => '', |
| "aa_champ_nom" => '', |
| "aa_champ_mail" => '', |
| "aa_champ_pass" => '' |
| ); |
| $donnees = $donnees; |
| $formulaire_ajout_annuaire = $this->getVue(Config::get('dossier_squelettes_gestion_annuaires').'annuaire_ajout',$donnees); |
| return $formulaire_ajout_annuaire; |
| } |
| public function ajouterAnnuaire($valeurs) { |
| $champs = array( |
| "aa_nom" => '', |
| "aa_description" => '', |
| "aa_bdd" => '', |
| "aa_table" => '', |
| "aa_code" => '', |
| "aa_champ_id" => '', |
| "aa_champ_nom" => '', |
| "aa_champ_mail" => '', |
| "aa_champ_pass" => '' |
| ); |
| $donnees = array('erreurs_champs' => array()); |
| // vérification de la présence de tous les champs |
| foreach($champs as $nom_champ => $valeur) { |
| if(!isset($valeurs[$nom_champ]) || $valeurs[$nom_champ] == '') { |
| $donnees['erreurs_champs'][$nom_champ] = 'Ce champ est obligatoire'; |
| } |
| } |
| // si il y a une erreur on réaffiche le formulaire |
| if(!empty($donnees['erreurs_champs'])) { |
| return $this->afficherFormulaireAjoutAnnuaire($donnees); |
| } |
| $champs_a_verifier = array($valeurs[aa_champ_id],$valeurs[aa_champ_nom],$valeurs[aa_champ_mail],$valeurs[aa_champ_pass]); |
| $informations_annuaire = array( |
| "aa_nom" => $valeurs['aa_nom'], |
| "aa_description" => $valeurs['aa_description'], |
| "aa_bdd" => $valeurs['aa_bdd'], |
| "aa_table" => $valeurs['aa_table'], |
| "aa_code" => $valeurs['aa_code'], |
| ); |
| $informations_champs = array( |
| "aa_champ_id" => $valeurs['aa_champ_id'], |
| "aa_champ_nom" => $valeurs['aa_champ_nom'], |
| "aa_champ_mail" => $valeurs['aa_champ_mail'], |
| "aa_champ_pass" => $valeurs['aa_champ_pass'] |
| ); |
| $this->chargerModele('GestionAnnuaireModele'); |
| $annuaire_existe = $this->GestionAnnuaireModele->verifierPresenceTable($valeurs['aa_bdd'], $valeurs['aa_table']); |
| // si l'annuaire existe déjà |
| if($annuaire_existe) { |
| $champs_existent = $this->GestionAnnuaireModele->verifierPresenceChamps($valeurs['aa_bdd'], $valeurs['aa_table'], $champs_a_verifier); |
| // si l'annuaire existe déjà |
| if($champs_existent) { |
| // tout existe déjà, rien à créer |
| } |
| } else { |
| $creation_table = $this->creerTableAnnuaire($informations_annuaire, $informations_champs); |
| if(!$creation_table) { |
| $donnees['erreurs'] = 'Impossible de créer la table '.$informations_annuaire['aa_table'].' dans la base '.$informations_annuaire['aa_bdd']; |
| } |
| } |
| // on insere un nouvel enregistrement dans la table des annuaire |
| $id_annuaire = $this->GestionAnnuaireModele->AjouterAnnuaire($informations_annuaire); |
| if(!$id_annuaire) { |
| $donnees['erreurs_champs'][$nom_champ] = 'Impossible d\'ajouter les infos de la table '.$valeurs['aa_table'].' dans la base de données '.$valeurs['aa_bdd'] ; |
| } |
| // on cree un set de métadonnées minimal |
| $this->creerEtMapperChampsMetadonneeMinimaux($id_annuaire, $informations_champs); |
| return $this->chargerAnnuaire($id_annuaire); |
| } |
| private function creerTableAnnuaire($informations_annuaire, $information_champs) { |
| $this->chargerModele('GestionAnnuaireModele'); |
| $this->GestionAnnuaireModele->creerTableAnnuaire($informations_annuaire, $information_champs); |
| } |
| private function creerEtMapperChampsMetadonneeMinimaux($id_annuaire, $informations_champs) { |
| $metadonnee_controleur = new MetadonneeControleur(); |
| $this->chargerModele('MappageModele'); |
| $this->chargerModele('MetadonneeModele'); |
| foreach($informations_champs as $type_champ => $nom) { |
| $role = str_replace('aa_','',$type_champ); |
| if($role == 'champ_id') { |
| $valeurs_mappage = array( |
| 'id_annuaire' => $id_annuaire, |
| 'id_champ_annuaire' => $nom, |
| 'role' => 'champ_id', |
| 'id_champ_metadonnee' => '' |
| ); |
| $creation = $this->MappageModele->ajouterNouveauMappage($id_annuaire, $nom, 'champ_id', '0'); |
| } else { |
| $valeurs_insertion = $this->renvoyerInformationChampPourType($id_annuaire, $role, $nom); |
| $metadonnee_controleur->ajouterNouvelleMetadonnee($valeurs_insertion); |
| $id_champ_metadonnee = $this->MetadonneeModele->renvoyerIdChampMetadonneeParAbreviation($id_annuaire, $valeurs_insertion['amc_abreviation']); |
| // on affecte à chaque champ son role |
| $this->MappageModele->ajouterNouveauMappage($id_annuaire, $nom, $role, $id_champ_metadonnee); |
| // et on le rend obligatoire |
| $this->MappageModele->ajouterNouveauMappage($id_annuaire, $nom, 'champ_obligatoire', $id_champ_metadonnee); |
| } |
| } |
| return true; |
| } |
| private function renvoyerInformationChampPourType($id_annuaire, $type, $nom) { |
| $valeurs = array(); |
| $this->chargerModele('MetadonneeModele'); |
| $id_liste_champs = $this->id_liste_champs; |
| switch($type) { |
| case 'champ_nom': |
| $affichage = $this->MetadonneeModele->renvoyerCorrespondanceIdParAbreviation('text',$id_liste_champs); |
| $valeurs = array('amc_nom' => $nom, |
| 'amc_abreviation' => 'nom' , |
| 'amc_description' => 'Nom', |
| 'amc_ce_annuaire' => $id_annuaire, |
| 'amc_ce_type_affichage' => $affichage, |
| 'amc_ce_ontologie' => '0' |
| ); |
| break; |
| case 'champ_mail': |
| $affichage = $this->MetadonneeModele->renvoyerCorrespondanceIdParAbreviation('mail',$id_liste_champs); |
| $valeurs = array('amc_nom' => $nom, |
| 'amc_abreviation' => 'mail', |
| 'amc_description' => 'Adresse electronique', |
| 'amc_ce_annuaire' => $id_annuaire, |
| 'amc_ce_type_affichage' => $affichage, |
| 'amc_ce_ontologie' => '0' |
| ); |
| break; |
| case 'champ_pass': |
| $affichage = $this->MetadonneeModele->renvoyerCorrespondanceIdParAbreviation('password',$id_liste_champs); |
| $valeurs = array('amc_nom' => $nom, |
| 'amc_abreviation' => 'pass', |
| 'amc_description' => 'Mot de passe', |
| 'amc_ce_annuaire' => $id_annuaire, |
| 'amc_ce_type_affichage' => $affichage, |
| 'amc_ce_ontologie' => '0' |
| ); |
| break; |
| } |
| return $valeurs; |
| } |
| } |
| ?> |
| /tags/v1.5-belier/controleurs/ApplicationExterneControleur.php |
|---|
| New file |
| 0,0 → 1,202 |
| <?php |
| /** |
| * PHP Version 5 |
| * |
| * @category PHP |
| * @package annuaire |
| * @author aurelien <aurelien@tela-botanica.org> |
| * @copyright 2010 Tela-Botanica |
| * @license http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt Licence CECILL |
| * @version SVN: <svn_id> |
| * @link /doc/annuaire/ |
| */ |
| /** |
| * Controleur chargé de la propagation et le rassemblement d'informations extérieures |
| * lors dce la consultation et modification des fiches utilisateurs |
| */ |
| Class ApplicationExterneControleur extends AppControleur { |
| private $applications_resume = null; |
| private $applications_gestion = null; |
| private $mode_reponse = 'json'; |
| public function ApplicationExterneControleur() { |
| $this->__construct(); |
| // on charge les variables de classes à partir du fichier de configuration |
| if(Config::get('url_services_applications_inscription') != null) { |
| $application_str = Config::get('url_services_applications_inscription'); |
| $this->applications_inscription = explode('##',$application_str); |
| } else { |
| $this->applications_inscription = array(); |
| } |
| // on charge les variables de classes à partir du fichier de configuration |
| if(Config::get('url_services_applications_resume') != null) { |
| $application_str = Config::get('url_services_applications_resume'); |
| $this->applications_resume = explode('##',$application_str); |
| } else { |
| $this->applications_resume = array(); |
| } |
| // on charge les variables de classes à partir du fichier de configuration |
| if(Config::get('url_services_applications_gestion') != null) { |
| $application_str = Config::get('url_services_applications_gestion'); |
| $this->applications_gestion = explode('##',$application_str); |
| } else { |
| $this->applications_gestion = array(); |
| } |
| } |
| /** |
| * parcourt la liste des applications et appelle une adresse spécifique pour l'inscription |
| * et l'inclut, le cas échéant. |
| * @param l'identifiant de l'utilisateur |
| * @param le mail de l'utilisateur |
| */ |
| public function ajouterInscription($id_utilisateur, $params) { |
| if(count($this->applications_inscription) > 0) { |
| foreach($this->applications_inscription as $application) { |
| $inscription = @file_get_contents($application.'Inscription/'.$this->fabriquerRequete($id_utilisateur, $params)); |
| $inscription = json_decode($inscription); |
| if($inscription && $inscription == "OK") { |
| } else { |
| //echo 'Erreur d\'inscription à l\'application '.$application; |
| } |
| } |
| } |
| return true; |
| } |
| /** |
| * parcourt la liste des applications et appelle une adresse spécifique pour la modification |
| * et l'inclut, le cas échéant. |
| * @param l'identifiant de l'utilisateur |
| * @param le mail de l'utilisateur |
| */ |
| public function modifierInscription($id_utilisateur,$params) { |
| if(count($this->applications_inscription) > 0) { |
| foreach($this->applications_inscription as $application) { |
| $modification = @file_get_contents($application.'Modification/'.$this->fabriquerRequete($id_utilisateur, $params)); |
| $modification = json_decode($modification); |
| if($modification && $modification == "OK") { |
| } else { |
| //echo 'Erreur de modification l\'application '.$application.'<br />'.$modification; |
| } |
| } |
| } |
| return true; |
| } |
| /** |
| * parcourt la liste des applications et appelle une adresse spécifique pour la suppression |
| * et l'inclut, le cas échéant. |
| * @param l'identifiant de l'utilisateur |
| * @param le mail de l'utilisateur |
| */ |
| public function supprimerInscription($id_utilisateur, $params) { |
| if(count($this->applications_inscription) > 0) { |
| foreach($this->applications_inscription as $application) { |
| $suppression = @file_get_contents($application.'Suppression/'.$this->fabriquerRequete($id_utilisateur, $params)); |
| $suppression = json_decode($suppression); |
| if($suppression && $suppression == "OK") { |
| } else { |
| //echo 'Erreur de desinscription à l\'application '.$application; |
| } |
| } |
| } |
| return true; |
| } |
| /** |
| * Parcourt le repertoire racine des applications et appelle un web service contenant la méthode |
| * Resume qui renvoie les informations associées à l'utilisateur qui seront affichées dans la fiche |
| * de profil |
| * @param l'identifiant de l'utilisateur |
| * @param le mail de l'utilisateur |
| * @return array un tableau associatif dont les clés sont les noms des applis et les valeurs sont le html qui sera |
| * inclus dans la fiche profil |
| */ |
| public function obtenirResume($id_utilisateur, $mail) { |
| $resumes = array(); |
| if(count($this->applications_resume) > 0) { |
| foreach($this->applications_resume as $application) { |
| $resume = @file_get_contents($application.'Resume'.DS.$id_utilisateur.DS.$mail); |
| if($resume) { |
| $resume = json_decode($resume, true); |
| $resumes[] = $resume; |
| } else { |
| $resume = array('elements' => array(), 'titre' => '', 'message' => ''); |
| } |
| } |
| } |
| return $resumes; |
| } |
| /** Parcourt le repertoire racine des applications et cherche un fichier spécifique contenant la méthode |
| * obtenirResume qui renvoie les informations associées à l'utilisateur qui seront affichées dans la fiche |
| * de profil |
| * @param l'identifiant de l'utilisateur |
| * @param le mail de l'utilisateur |
| * @return array un tableau associatif dont les clés sont les noms des applis et les valeurs sont le html qui sera |
| * inclus dans la fiche profil |
| */ |
| public function gererInscription($id_utilisateur, $mail) { |
| $gestions = array(); |
| if(count($this->applications_gestion) > 0) { |
| foreach($this->applications_gestion as $application) { |
| $gestion = file_get_contents($application.'Gestion'.DS.$id_utilisateur.DS.$mail); |
| if($gestion) { |
| $gestion = json_decode($gestion, true); |
| $gestions[] = $gestion; |
| } else { |
| $gestion = array('elements' => array(), 'titre' => '', 'message' => ''); |
| } |
| } |
| } |
| return $gestions; |
| } |
| private function fabriquerRequete($id, $params) { |
| $requete = '?'; |
| foreach($params as $cle => $param) { |
| $requete .= '&'.$cle.'='.$param; |
| } |
| return $requete; |
| } |
| } |
| ?> |
| /tags/v1.5-belier/controleurs/LettreControleur.php |
|---|
| New file |
| 0,0 → 1,240 |
| <?php |
| /** |
| * PHP Version 5 |
| * |
| * @category PHP |
| * @package annuaire |
| * @author aurelien <aurelien@tela-botanica.org> |
| * @copyright 2010 Tela-Botanica |
| * @license http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt Licence CECILL |
| * @version SVN: <svn_id> |
| * @link /doc/annuaire/ |
| */ |
| /** |
| * Controleur permettant l'abonnement à une liste de diffusion |
| * à travers un mécanisme de mail ou de web services |
| */ |
| class LettreControleur extends AppControleur { |
| /** Adresse de base des web services |
| * ex : http://mail.domaine.com/ |
| */ |
| private $adresse_service_lettre = null; |
| /** |
| * Nom du service permettant de s'inscrire |
| * ex : inscription.php |
| */ |
| private $service_inscription_lettre = null; |
| /** |
| * Nom du service permettant de s'inscrire |
| * ex : desinscription.php |
| */ |
| private $service_desinscription_lettre = null; |
| /** |
| * domaine de la liste |
| * ex : domaine.org |
| */ |
| private $domaine_lettre = null; |
| /** |
| * nom de la liste de diffusion |
| * ex : actualite |
| */ |
| private $nom_lettre = null; |
| /** |
| * adresse mail d'inscription (si on utilise les mails) |
| */ |
| private $adresse_inscription_lettre = null; |
| /** |
| * adresse mail de desinscription (si on utilise les mails) |
| */ |
| private $adresse_desinscription_lettre = null; |
| /** |
| * indique si on utilise les mails ou non |
| * (si les infos des web services sont entrées, on met cette variable à true) |
| */ |
| private $utilise_mail = false; |
| /** |
| * Constructeur sans paramètres |
| */ |
| public function LettreControleur() { |
| $this->__construct(); |
| // on charge les variables de classes à partir du fichier de configuration |
| if(Config::get('adresse_service_lettre') != null) { |
| $this->adresse_service_lettre = Config::get('adresse_service_lettre'); |
| } else { |
| $this->utilise_mail = true; |
| } |
| if(Config::get('service_inscription_lettre') != null) { |
| $this->service_inscription_lettre = Config::get('service_inscription_lettre'); |
| } else { |
| $this->utilise_mail = true; |
| } |
| if(Config::get('service_desinscription_lettre') != null) { |
| $this->service_desinscription_lettre = Config::get('service_desinscription_lettre'); |
| } else{ |
| $this->utilise_mail = true; |
| } |
| if(Config::get('domaine_lettre') != null) { |
| $this->domaine_lettre = Config::get('domaine_lettre'); |
| } else { |
| $this->utilise_mail = true; |
| } |
| if(Config::get('nom_lettre') != null) { |
| $this->nom_lettre = Config::get('nom_lettre'); |
| } else { |
| $this->utilise_mail = true; |
| } |
| // si l'une des variables pour les web services n'est pas valide |
| // alors on utilise les mails |
| if(Config::get('adresse_inscription_lettre') != null) { |
| $this->adresse_inscription_lettre = Config::get('adresse_inscription_lettre'); |
| } |
| if(Config::get('adresse_desinscription_lettre') != null) { |
| $this->adresse_desinscription_lettre = Config::get('adresse_desinscription_lettre'); |
| } |
| } |
| /** --------------------------------- Fonction liées à l'inscription ou la desinscription à la lettre d'actualité gérée par une liste externe -------------------------------------------*/ |
| /** |
| * Envoie un mail avec l'adresse de l'utilisateur donné en paramètre, |
| * à l'adresse donnée en paramètre |
| * @param string $adresse l'adresse de la liste à laquelle on veut abonner |
| * @param string $inscrit l'adresse de l'inscrit qui doit être abonné |
| * @param string $sujet sujet du mail |
| * @return boolean true ou false suivant le succès ou non de l'envoi |
| */ |
| private function envoyerMail($adresse, $inscrit, $sujet) { |
| // 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."\r\n"; |
| $entetes .= 'From: '.$inscrit."\r\n"; |
| $contenu_mail = ''; |
| return mail($adresse, $sujet, $contenu_mail, $entetes); |
| } |
| /** |
| * Inscrit une adresse à la lettre d'actu |
| * @param string $mail le mail à inscrire à la lettre |
| * @return boolean true ou false suivant le succès de la requete |
| */ |
| public function inscriptionLettreActualite($mail) { |
| if($this->utilise_mail) { |
| return $this->envoyerMail($this->adresse_inscription_lettre, $mail, 'inscription à la lettre d\'actualité'); |
| } else { |
| $params = '?domaine='.$this->domaine_lettre.'&liste='.$this->nom_lettre.'&mail='.$mail; |
| //Log::ajouterEntree('lettre','inscription params '.$this->adresse_service_lettre.$this->service_inscription_lettre.$params); |
| return file_get_contents($this->adresse_service_lettre.$this->service_inscription_lettre.$params); |
| } |
| } |
| /** |
| * Desinscrit une adresse à une liste donnée |
| * @param string $mail le mail à desinscrire à la lettre |
| * @return boolean true ou false suivant le succès de la requete |
| */ |
| public function desinscriptionLettreActualite($mail) { |
| if($this->utilise_mail) { |
| return $this->envoyerMail($this->adresse_inscription_lettre, $mail, 'desinscription à la lettre d\'actualité'); |
| } else { |
| $params = '?domaine='.$this->domaine_lettre.'&liste='.$this->nom_lettre.'&mail='.$mail; |
| //Log::ajouterEntree('lettre','desinscription params '.$this->adresse_service_lettre.$this->service_desinscription_lettre.$params); |
| return file_get_contents($this->adresse_service_lettre.$this->service_desinscription_lettre.$params); |
| } |
| } |
| /** |
| * Desinscrit l'ancien mail d'un utilisateur et réinscrit le nouveau |
| * @param string $ancien_mail l'ancien mail à desinscrire à la lettre |
| * @param string $nouveau_mail l'ancien mail à inscrire à la lettre |
| * @return boolean true ou false suivant le succès de la requete |
| */ |
| public function modificationInscriptionLettreActualite($ancien_mail, $nouveau_mail) { |
| if($this->utilise_mail) { |
| $adresse_deinscription_lettre = Config::get('adresse_desinscription_lettre'); |
| $suppression_ancien_mail = $this->envoyerMail($adresse_deinscription_lettre, $ancien_mail, 'desinscription à la lettre d\'actualité'); |
| $adresse_inscription_lettre = Config::get('adresse_inscription_lettre'); |
| $ajout_nouveau_mail = $this->envoyerMail($adresse_inscription_lettre, $nouveau_mail, 'inscription à la lettre d\'actualité'); |
| return $suppression_ancien_mail && $ajout_nouveau_mail; |
| } else { |
| $desinscription = $this->desinscriptionLettreActualite($ancien_mail); |
| $inscription = $this->inscriptionLettreActualite($nouveau_mail); |
| return ($desinscription && $inscription); |
| } |
| } |
| /** --------------------------------- Fonction de gestion du champ de données associé à la lettre d'actu (appelés par les web services) -------------------------------------------*/ |
| public function estAbonneLettreActualite($id_annuaire, $id_utilisateur) { |
| $annuaire_modele = $this->getModele('AnnuaireModele'); |
| $champs_description = $annuaire_modele->obtenirChampsDescriptionAnnuaire($id_annuaire); |
| $valeur = $annuaire_modele->obtenirValeurChampAnnuaireMappe($id_annuaire, $id_utilisateur, 'champ_lettre'); |
| return $valeur; |
| } |
| public function abonnerDesabonnerLettreActualite($id_annuaire, $id_utilisateur, $abonner = true) { |
| $annuaire_modele = $this->getModele('AnnuaireModele'); |
| $champs_description = $annuaire_modele->obtenirChampsDescriptionAnnuaire($id_annuaire); |
| $mail_utilisateur = $annuaire_modele->obtenirMailParId($id_annuaire, $id_utilisateur); |
| $champ_lettre = $champs_description[0]['champ_lettre']; |
| if($abonner) { |
| $valeur = 'on'; |
| } else { |
| $valeur = '0'; |
| } |
| $verificateur = new VerificationControleur(); |
| $valeur_modif = $verificateur->remplacerValeurChampPourModification($id_annuaire, $id_utilisateur, 'lettre', $valeur, $mail_utilisateur); |
| $annuaire_modele = $this->getModele('AnnuaireModele'); |
| $valeur_modif = $annuaire_modele->modifierValeurChampAnnuaireMappe($id_annuaire, $id_utilisateur, $champ_lettre, $valeur_modif); |
| $this->chargerModele('MetadonneeModele'); |
| $this->MetadonneeModele->modifierValeurMetadonnee($champ_lettre,$id_utilisateur,$valeur_modif); |
| return $valeur_modif; |
| } |
| } |
| ?> |
| /tags/v1.5-belier/controleurs/NavigationControleur.php |
|---|
| New file |
| 0,0 → 1,53 |
| <?php |
| /** |
| * PHP Version 5 |
| * |
| * @category PHP |
| * @package annuaire |
| * @author aurelien <aurelien@tela-botanica.org> |
| * @copyright 2010 Tela-Botanica |
| * @license http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt Licence CECILL |
| * @version SVN: <svn_id> |
| * @link /doc/annuaire/ |
| */ |
| class NavigationControleur extends AppControleur { |
| public function afficherContenuMenu($id_annuaire, $admin = false) { |
| $donnees['id_annuaire'] = $id_annuaire; |
| if($admin) { |
| $menu = $this->getVue(Config::get('dossier_squelettes_navigation').'menu_admin', $donnees); |
| } else { |
| $menu = $this->getVue(Config::get('dossier_squelettes_navigation').'menu', $donnees); |
| } |
| return $menu; |
| } |
| public function afficherBandeauNavigationUtilisateur($id_annuaire, $id_utilisateur = null, $page = 'fiche') { |
| if($id_utilisateur == null) { |
| $id_utilisateur = Registre::getInstance()->get('identification_id'); |
| } |
| $donnees['id_annuaire'] = $id_annuaire; |
| $donnees['id_utilisateur'] = $id_utilisateur; |
| $donnees['page'] = $page; |
| $navigation = $this->getVue(Config::get('dossier_squelettes_navigation').'bandeau', $donnees); |
| return $navigation; |
| } |
| public function afficherBandeauNavigationCartographie($donnees) { |
| $navigation = $this->getVue(Config::get('dossier_squelettes_navigation').'chemin_cartographie', $donnees); |
| return $navigation; |
| } |
| } |
| ?> |
| /tags/v1.5-belier/controleurs/OntologieControleur.php |
|---|
| New file |
| 0,0 → 1,162 |
| <?php |
| /** |
| * PHP Version 5 |
| * |
| * @category PHP |
| * @package annuaire |
| * @author aurelien <aurelien@tela-botanica.org> |
| * @copyright 2010 Tela-Botanica |
| * @license http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt Licence CECILL |
| * @version SVN: <svn_id> |
| * @link /doc/annuaire/ |
| */ |
| class OntologieControleur extends AppControleur { |
| /**--------Fonctions de gestion des ontologies --------------------------------*/ |
| /** |
| * charge et renvoie la vue contenant la liste des listes |
| * @return string le html contenant la liste des listes |
| */ |
| public function chargerListeListe() { |
| $this->chargerModele('OntologieModele'); |
| $data['ontologie'] = $this->OntologieModele->chargerListeListes(); |
| $data['titre'] = 'Liste des listes'; |
| $liste_des_listes = $this->getVue(Config::get('dossier_squelettes_ontologies').'liste_des_listes', $data); |
| return $liste_des_listes; |
| } |
| /** |
| * charge et renvoie la vue contenant la liste ontologie et ses éléments dont l'identifiant est passé en paramètre |
| * @param int $identifiant l'identifiant de la liste d'ontologie |
| * @return string le html contenant la liste et ses éléments |
| */ |
| public function chargerListeOntologie($identifiant) { |
| $this->chargerModele('OntologieModele'); |
| // On charge les informations de la liste (nom description etc...) |
| $data['informations'] = $this->OntologieModele->chargerInformationsOntologie($identifiant); |
| $data['ontologie'] = $this->OntologieModele->chargerListeOntologie($identifiant); |
| $liste_ontologie = $this->getVue(Config::get('dossier_squelettes_ontologies').'liste_ontologie', $data); |
| return $liste_ontologie; |
| } |
| /** |
| * Affiche le formulaire d'ajout de liste ontologie |
| * @param Array $valeurs un tableau de valeurs (dans le cas du retour erreur) |
| * @return string le formulaire de liste d'ontologie |
| */ |
| public function afficherFormulaireAjoutListeOntologie($valeurs) { |
| if(!isset($valeurs['amo_nom'])) { |
| $valeurs['amo_nom'] = ''; |
| } |
| if(!isset($valeurs['amo_abreviation'])) { |
| $valeurs['amo_abreviation'] = ''; |
| } |
| if(!isset($valeurs['amo_description'])) { |
| $valeurs['amo_description'] = ''; |
| } |
| if(!isset($valeurs['amo_ce_parent'])) { |
| $valeurs['amo_ce_parent'] = ''; |
| } |
| $liste_ontologie_ajout = $this->getVue(Config::get('dossier_squelettes_ontologies').'liste_ontologie_ajout', $valeurs); |
| return $liste_ontologie_ajout; |
| } |
| /** |
| * Affiche le formulaire de modification de liste ontologie |
| * @param Array un tableau de valeurs contenant l'id de la liste (et les élements pour le retour erreur) |
| * @return string le formulaire de modification ou la liste des liste si l'id est invalide |
| */ |
| public function afficherFormulaireModificationListeOntologie($id_ontologie) { |
| if(trim($id_ontologie) != '') { |
| $this->chargerModele('OntologieModele'); |
| $data['valeurs'] = $this->OntologieModele->chargerInformationsOntologie($id_ontologie); |
| $liste_ontologie_modification = $this->getVue(Config::get('dossier_squelettes_ontologies').'liste_ontologie_modification', $data); |
| return $liste_ontologie_modification; |
| } else { |
| return $this->chargerListeListe(); |
| } |
| } |
| /** |
| * Ajoute une nouvelle liste d'ontologie |
| * @param Array $valeurs les valeurs à ajouter |
| * @return string la vue contenant la liste des liste, ou bien le formulaire d'ajout en cas d'erreur |
| */ |
| public function ajouterNouvelleListeOntologie($valeurs) { |
| if(isset($valeurs['amo_nom']) |
| && isset($valeurs['amo_abreviation']) |
| && isset($valeurs['amo_description']) |
| && isset($valeurs['amo_ce_parent'])) { |
| $this->chargerModele('OntologieModele'); |
| $this->OntologieModele->ajouterNouvelleListeOntologie($valeurs); |
| } else { |
| return $this->afficherFormulaireAjoutListeOntologie($valeurs); |
| } |
| return $this->chargerListeOntologie($valeurs['amo_ce_parent']); |
| } |
| /** |
| * Affiche le formulaire d'ajout ou de modification de liste ontologie |
| * @param Array $valeurs les valeurs à modifier |
| * @return String la vue contenant liste des liste, ou le formulaire de modification si erreur |
| */ |
| public function modifierListeOntologie($valeurs) { |
| if(isset($valeurs['amo_nom']) &&isset($valeurs['amo_abreviation']) && isset($valeurs['amo_description'])) { |
| $this->chargerModele('OntologieModele'); |
| $this->OntologieModele->modifierListeOntologie($valeurs); |
| } else { |
| // TODO: afficher une erreur si la modification n'a pas fonctionné |
| return $this->afficherFormulaireListeOntologie($valeurs, true); |
| } |
| if($valeurs['amo_id_ontologie'] != 0) { |
| return $this->chargerListeOntologie($valeurs['amo_ce_parent']); |
| } else { |
| return $this->chargerListeListe(); |
| } |
| } |
| /** |
| * Supprime une liste d'ontologie |
| * @param int $id_ontologie l'identifant de la liste à supprimer |
| * @return string la vue contenant la liste des listes |
| */ |
| public function supprimerListeOntologie($id_ontologie) { |
| $id_ontologie_parent = 0; |
| if(trim($id_ontologie) != '') { |
| $this->chargerModele('OntologieModele'); |
| $infos_ontologie = $this->OntologieModele->chargerInformationsOntologie($id_ontologie); |
| $id_ontologie_parent = $infos_ontologie['amo_ce_parent']; |
| $this->OntologieModele->supprimerListeOntologie($id_ontologie); |
| } else { |
| // TODO: afficher une erreur si la suppression n'a pas fonctionné |
| return $this->chargerListeListe(); |
| } |
| return $this->chargerListeOntologie($id_ontologie_parent); |
| } |
| } |
| ?> |
| /tags/v1.5-belier/controleurs/AnnuaireControleur.php |
|---|
| New file |
| 0,0 → 1,1445 |
| <?php |
| /** |
| * PHP Version 5 |
| * |
| * @category PHP |
| * @package annuaire |
| * @author aurelien <aurelien@tela-botanica.org> |
| * @copyright 2010 Tela-Botanica |
| * @license http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt Licence CECILL |
| * @version SVN: <svn_id> |
| * @link /doc/annuaire/ |
| */ |
| class AnnuaireControleur extends AppControleur { |
| /** |
| * Fonction affichant la vue par défaut, ici le menu principal |
| * @return String la vue contenant le menu |
| */ |
| public function index() { |
| if (Registre::getInstance()->get('est_admin')) { |
| $data = array(); |
| $index_annuaire = $this->getVue('index_annuaire', $data); |
| return $index_annuaire; |
| } else { |
| return $this->afficherFicheUtilisateur(Registre::getInstance()->get('identification_id')); |
| } |
| } |
| /** |
| * Fonction d'affichage par défaut |
| */ |
| public function executerActionParDefaut() { |
| if (Registre::getInstance()->get('est_admin')) { |
| $data = array(); |
| $index_annuaire = $this->getVue('index_annuaire', $data); |
| return $index_annuaire; |
| } else { |
| return $this->afficherFicheUtilisateur(Registre::getInstance()->get('identification_id')); |
| } |
| } |
| /**-------- Fonctions de gestion des annuaires --------------------------------*/ |
| /** |
| * Charge la vue contenant la liste des annuaires gérés par l'application |
| * @return string la vue contenant la liste des annuaires |
| */ |
| public function chargerListeAnnuaire() { |
| $this->chargerModele('AnnuaireModele'); |
| $data['erreurs'] = null; |
| $data['annuaires'] = $this->AnnuaireModele->chargerListeAnnuaire(); |
| $liste_annu = $this->getVue(Config::get('dossier_squelettes_gestion_annuaires').'liste_annu', $data); |
| return $liste_annu; |
| } |
| /** |
| * Charge la vue contenant les informations d'un annuaire donné en paramètre |
| * @param int $id l'identifiant de l'annuaire |
| * @return string la vue contenant les informations sur l'annuaire |
| */ |
| public function chargerAnnuaire($id) { |
| $this->chargerModele('AnnuaireModele'); |
| $this->chargerModele('MetadonneeModele'); |
| $data['erreurs'] = array(); |
| $data['champs_mappage'] = $this->obtenirChampsMappageAnnuaire($id); |
| $data['annuaire'] = $this->AnnuaireModele->chargerAnnuaire($id, true); |
| $data['metadonnees'] = $this->MetadonneeModele->chargerListeMetadonneeAnnuaire($id); |
| $annuaire = $this->getVue(Config::get('dossier_squelettes_gestion_annuaires').'annuaire', $data); |
| return $annuaire; |
| } |
| /** |
| * Charge et affiche la liste des inscrits à un annuaire donné en paramètre |
| * @param $id int l'identifiant de l'annuaire |
| * @return string la vue contenant les inscrits à l'annuaire |
| */ |
| public function chargerAnnuaireListeInscrits($id_annuaire, $numero_page = 1, $taille_page = 50) { |
| $this->chargerModele('AnnuaireModele'); |
| $annuaire = $this->AnnuaireModele->chargerAnnuaire($id_annuaire); |
| $data['erreurs'] = array(); |
| $tableau_mappage = $this->obtenirChampsMappageAnnuaire($id_annuaire); |
| $champ_id_annuaire = $tableau_mappage[0]['champ_id']; |
| $resultat_recherche = $this->AnnuaireModele->chargerAnnuaireListeInscrits($id_annuaire, $numero_page, $taille_page); |
| $nb_resultats = $resultat_recherche['total']; |
| $resultat_recherche = $resultat_recherche['resultat']; |
| $resultats = array(); |
| foreach($resultat_recherche as $resultat) { |
| $id_utilisateur = $resultat[$champ_id_annuaire]; |
| $resultats[$id_utilisateur] = $this->obtenirValeursUtilisateur($id_annuaire, $id_utilisateur); |
| } |
| // on renvoie une liste identique à celle de la liste des inscrits |
| $donnees['resultats_recherche'] = $resultats; |
| $donnees['tableau_mappage'] = $tableau_mappage[1]; |
| $donnees['id_annuaire'] = $id_annuaire; |
| $donnees['nb_resultats'] = $nb_resultats; |
| $url_pagination = new URL(Registre::getInstance()->get('base_url_application')); |
| $url_pagination->setVariableRequete('m','annuaire_inscrits'); |
| $url_pagination->setVariableRequete('id_annuaire',$id_annuaire); |
| $donnees['criteres'] = urlencode(serialize(array('tous' => '1'))); |
| $donnees['pagination'] = $this->paginer($numero_page,$taille_page,$nb_resultats,$url_pagination, array()); |
| // S'il existe une page de résultats spécifique à l'annuaire pour la recherche |
| if($this->templateExiste($annuaire['informations']['aa_code'].'_resultat_recherche', Config::get('dossier_squelettes_annuaires'))) { |
| // on l'affiche |
| $annuaires_inscrits = $this->getVue(Config::get('dossier_squelettes_annuaires').$annuaire['informations']['aa_code'].'_resultat_recherche', $donnees); |
| } else { |
| // sinon on prend celle par défaut |
| $tableau_nom_mappage = $this->obtenirNomsChampsMappageAnnuaire($id_annuaire); |
| $donnees['mappage_nom_champs'] = $tableau_nom_mappage; |
| $annuaires_inscrits = $this->getVue(Config::get('dossier_squelettes_annuaires').'resultat_recherche', $donnees); |
| } |
| return $annuaires_inscrits; |
| } |
| /**-------- Fonctions d'affichage du formulaire de saisie d'un champ de metadonnée suivant le type de champ---------*/ |
| /** |
| * Affiche le formulaire d'inscription pour un annuaire donné |
| * @param int $id_annuaire l'identifiant de l'annuaire pour lequel on veut afficher le formulaire |
| * @param Array $donnees le tableau de données pour préremplir le formulaire si besoin (en cas de retour erreur) |
| */ |
| public function afficherFormulaireInscription($id_annuaire, $donnees = array()) { |
| $this->chargerModele('AnnuaireModele'); |
| $annuaire = $this->AnnuaireModele->chargerAnnuaire($id_annuaire, false); |
| $this->chargerModele('MetadonneeModele'); |
| $donnees['aa_id_annuaire'] = $id_annuaire; |
| $metadonnees = $this->MetadonneeModele->chargerListeMetadonneeAnnuaire($id_annuaire); |
| $tableau_mappage = $this->obtenirChampsMappageAnnuaire($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']; |
| $type_champ = $metadonnee['amc_ce_template_affichage']; |
| $nom_champ = $metadonnee['amc_abreviation']; |
| $metadonnee['aa_id_annuaire'] = $id_annuaire; |
| if(isset($donnees['erreurs'])) { |
| $metadonnee['erreurs'] = $donnees['erreurs']; |
| } |
| if(isset($donnees[$type_champ.'_'.$id_champ])) { |
| $metadonnee['valeur_defaut']['amv_valeur'] = $donnees[$type_champ.'_'.$id_champ]; |
| } |
| // on charge le formulaire d'affichage de chacune des métadonnées |
| $donnees['champs'][$nom_champ] = $this->afficherFormulaireChampMetadonnees($id_champ,$metadonnee); |
| } |
| $donnees['tableau_mappage'] = $tableau_mappage[1]; |
| if ($this->annuaireAvoirFormulaireInscription($annuaire['informations']['aa_code'])) { |
| $formulaire_inscription = $this->GetVue(Config::get('dossier_squelettes_formulaires').$annuaire['informations']['aa_code'].'_inscription',$donnees); |
| } else { |
| $tableau_nom_mappage = $this->obtenirNomsChampsMappageAnnuaire($id_annuaire); |
| $donnees['mappage_nom_champs'] = $tableau_nom_mappage; |
| $formulaire_inscription = $this->genererFormulaireInscription($donnees); |
| } |
| return $formulaire_inscription; |
| } |
| /**-------- Fonctions d'inscription -------------------------------------------------------------------------------*/ |
| /** |
| * Lors d'une tentative d'inscription, ajoute les infos dans la table d'inscription |
| * temporaire et envoie le mail contenant le lien de confirmation si tout s'est bien passé |
| * @param Array $valeurs les valeurs à ajouter |
| * @return string la vue contenant la confirmation de l'inscription |
| */ |
| public function ajouterInscriptionTemporaire($valeurs) { |
| $this->chargerModele('MetadonneeModele'); |
| $id_annuaire = $valeurs['aa_id_annuaire']; |
| unset($valeurs['aa_id_annuaire']); |
| $valeurs_mappees = array(); |
| $valeurs_a_inserer = array(); |
| $tableau_mappage = $this->obtenirChampsMappageAnnuaire($id_annuaire); |
| $verificateur = new VerificationControleur(); |
| $valeurs_collectees = $verificateur->collecterValeurInscription($valeurs, $tableau_mappage); |
| $valeurs_mappees = $valeurs_collectees['valeurs_mappees']; |
| $valeurs_a_inserer = $valeurs_collectees['valeurs_a_inserer']; |
| // vérification des champs minimaux : nom, prénom, mail, mot de passe |
| if($erreurs = $verificateur->verifierErreursChampsSelonType($id_annuaire,$valeurs_mappees, $tableau_mappage)) { |
| $valeurs['erreurs'] = $erreurs; |
| return $this->afficherFormulaireInscription($id_annuaire, $valeurs); |
| } |
| $valeurs_a_inserer['aa_id_annuaire'] = $id_annuaire ; |
| $this->chargerModele('DonneeTemporaireModele'); |
| $code_confirmation = $this->DonneeTemporaireModele->stockerDonneeTemporaire($valeurs_a_inserer); |
| $mail = $valeurs_mappees[$tableau_mappage[1]['champ_mail']]['valeur']; |
| $nom = $valeurs_mappees[$tableau_mappage[1]['champ_nom']]['valeur']; |
| if (isset($tableau_mappage[1]['champ_prenom']) && isset($valeurs_mappees[$tableau_mappage[1]['champ_prenom']]['valeur'])) { |
| $prenom = $valeurs_mappees[$tableau_mappage[1]['champ_prenom']]['valeur']; |
| } else { |
| $prenom = ''; |
| } |
| $messagerie = new MessageControleur(); |
| $messagerie->envoyerMailConfirmationInscription($mail, $nom, $prenom, $code_confirmation); |
| $tableau_vide = array(); |
| // Si tout s'est bien passé, on affiche la page de confirmation |
| return $this->getVue(Config::get('dossier_squelettes_annuaires').'annuaire_inscription_reussie',$tableau_vide); |
| } |
| /** |
| * Ajoute une nouvelle inscription à un annuaire à partir de données d'une table temporaire. |
| * Typiquement, on déclenche cette fonction en cliquant sur le lien contenu dans le mail de confirmation |
| * @param int $indentifant L'identifant de session d'une tentative d'inscription |
| */ |
| public function ajouterNouvelleInscription($identifiant) { |
| $this->chargerModele('DonneeTemporaireModele'); |
| $valeurs = $this->DonneeTemporaireModele->chargerDonneeTemporaire($identifiant); |
| if (!$valeurs || count($valeurs) == 0) { |
| return false; |
| } |
| $this->chargerModele('AnnuaireModele'); |
| $id_annuaire = $valeurs['aa_id_annuaire']; |
| unset($valeurs['aa_id_annuaire']); |
| $this->chargerModele('MetadonneeModele'); |
| $verificateur = new VerificationControleur(); |
| $tableau_mappage = $this->obtenirChampsMappageAnnuaire($id_annuaire); |
| $valeurs_mappees = array(); |
| $valeurs_metadonnees = array(); |
| $mail_nouvel_inscrit = $valeurs['mail_'.$tableau_mappage[1]['champ_mail']]; |
| $pass_nouvel_inscrit = $valeurs['password_'.$tableau_mappage[1]['champ_pass']]; |
| // Dernière vérification du mail au cas où la personne aurait fait plusieurs demandes |
| // d'inscription et aurait déjà validée l'une d'entre elles |
| // TODO: supprimer la demande d'inscription si c'est le cas ? |
| // (elle sera supprimée de toute façon par la gestion des données obsolètes) |
| if($this->AnnuaireModele->utilisateurExisteParMail($id_annuaire, $mail_nouvel_inscrit)) { |
| return false; |
| } |
| $valeurs['text_'.$tableau_mappage[1]['champ_nom']] = AppControleur::formaterMotEnMajuscule($valeurs['text_'.$tableau_mappage[1]['champ_nom']]); |
| $nom = $valeurs['text_'.$tableau_mappage[1]['champ_nom']]; |
| $mail = $mail_nouvel_inscrit; |
| $pass = $valeurs['password_'.$tableau_mappage[1]['champ_pass']]; |
| if (isset($tableau_mappage[0]['champ_prenom']) && isset($valeurs_mappees[$tableau_mappage[0]['champ_prenom']])) { |
| $valeurs['text_'.$tableau_mappage[1]['champ_prenom']] = AppControleur::formaterMotPremiereLettreChaqueMotEnMajuscule($valeurs['text_'.$tableau_mappage[1]['champ_prenom']]); |
| $prenom = $valeurs['text_'.$tableau_mappage[1]['champ_prenom']]; |
| } else { |
| $prenom = ''; |
| } |
| if (isset($tableau_mappage[0]['champ_pays']) && isset($valeurs_mappees[$tableau_mappage[0]['champ_pays']])) { |
| $pays = $valeurs['select_'.$tableau_mappage[1]['champ_pays']]; |
| } else { |
| $pays = ''; |
| } |
| // 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, 2); |
| $type = $ids_champ[0]; |
| $condition = false; |
| $id_champ = $ids_champ[1]; |
| // on fait des vérifications et des remplacements sur certaines valeurs |
| $valeur = $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) { |
| // 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 |
| unset($valeurs[$nom_champ]); |
| } else { |
| $valeurs_metadonnees[$nom_champ] = $valeur; |
| } |
| } |
| // cas spécial du champ pays ou l'on fait un double stockage des données |
| if (isset($tableau_mappage[0]['champ_pays']) && isset($valeurs_mappees[$tableau_mappage[0]['champ_pays']])) { |
| $pays = $valeurs_mappees[$tableau_mappage[0]['champ_pays']]; |
| $valeurs_metadonnees[$tableau_mappage[1]['champ_pays']] = $pays; |
| $pays = $this->MetadonneeModele->renvoyerCorrespondanceAbreviationId($pays); |
| $valeurs_mappees[$tableau_mappage[0]['champ_pays']] = $pays; |
| } |
| // obtenir l'id du nouvel arrivant en faisant un select sur le mail qui doit être unique |
| $id_nouvel_inscrit = $this->AnnuaireModele->ajouterInscriptionDansAnnuaireMappe($id_annuaire,$valeurs_mappees, $tableau_mappage[0]); |
| // les champs de metadonnees arrivent avec un identifiant sous la forme type_condition_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]; |
| // Si l'insertion dans la base a réussi |
| if ($this->MetadonneeModele->ajouterNouvelleValeurMetadonnee($id_champ,$id_nouvel_inscrit,$valeur)) { |
| // on continue |
| } else { |
| // Si une des insertions échoue, on supprime les méta valeurs déjà entrées. |
| // La transaction du pauvre en quelque sorte |
| $this->MetadonneeModele->supprimerValeursMetadonneesParIdEnregistrementLie($id_nouvel_inscrit); |
| return false; |
| } |
| } |
| $appli_controleur = new ApplicationExterneControleur(); |
| $infos_nouvel_inscrit = array ( |
| 'id_utilisateur' => $id_nouvel_inscrit, |
| 'prenom' => $prenom, |
| 'nom' => $nom, |
| 'mail' => trim($mail), |
| 'pass' => $pass, |
| 'pays' => $pays, |
| 'nouveau_pass' => '', |
| 'nouveau_mail' => '' |
| ); |
| // on crée un controleur qui appelle les webservice pour chaque application externe |
| $resumes_controleur = new ApplicationExterneControleur(); |
| $resumes_controleur->ajouterInscription($id_nouvel_inscrit, $infos_nouvel_inscrit); |
| // Si tout a réussi on supprime les données d'inscription temporaire |
| $this->DonneeTemporaireModele->supprimerDonneeTemporaire($identifiant); |
| $infos_nouvel_inscrit['id_annuaire'] = $id_annuaire; |
| return $infos_nouvel_inscrit; |
| } |
| public function ajouterNouvelleInscriptionSansIdentifier($code_confirmation) { |
| // TODO: ajouter un controle d'erreurs |
| $inscription_ajout = $this->ajouterNouvelleInscription($code_confirmation); |
| $id_annuaire = $inscription_ajout['id_annuaire']; |
| return $this->afficherInscritsEnAttenteConfirmation($id_annuaire); |
| } |
| public function ajouterNouvelleInscriptionEtIdentifier($code_confirmation) { |
| $inscription_ajout = $this->ajouterNouvelleInscription($code_confirmation); |
| if (!$inscription_ajout) { |
| $identificateur = new IdentificationControleur(); |
| $donnees['titre'] = 'Erreur d\'inscription'; |
| $donnees['message'] = 'Erreur : aucune demande d\'inscription ne correspond à ce lien <br />'. |
| 'La demande a peut être déjà été validée, essayez de vous connecter sur le site <br />'. |
| 'Si votre demande d\'inscription date de moins de deux semaines, essayez de vous connecter avec les informations fournies lors de l\'inscription<br />'. |
| 'Si votre demande d\'inscription date de plus de deux semaines, alors celle ci doit être renouvelée'; |
| $vue_resultat_inscription = $this->getVue(Config::get('dossier_squelettes_annuaires').'information_simple',$donnees).$identificateur->afficherFormulaireIdentification(Config::get('annuaire_defaut'), array()); |
| } else { |
| $mail = $inscription_ajout['mail']; |
| $pass = $inscription_ajout['pass']; |
| $id_nouvel_inscrit = $inscription_ajout['id_utilisateur']; |
| $prenom = $inscription_ajout['prenom']; |
| $nom = $inscription_ajout['nom']; |
| $id_annuaire = $inscription_ajout['id_annuaire']; |
| $annuaire = $this->AnnuaireModele->chargerAnnuaire($id_annuaire, false); |
| // Identifier l'utilisateur ! |
| $identificateur = new IdentificationControleur(); |
| if(config::get('identification')) { |
| $identificateur->deloggerUtilisateur(); |
| } |
| $identificateur->loggerUtilisateur($mail, $pass); |
| if ($this->annuaireAvoirPageAccueilPostInscription($annuaire['informations']['aa_code'])) { |
| // on l'affiche |
| $donnees = array('id_utilisateur' => $id_nouvel_inscrit, 'id_annuaire' => $id_annuaire); |
| $vue_resultat_inscription = $this->getVue(Config::get('dossier_squelettes_annuaires').$annuaire['informations']['aa_code'].'_inscription_confirmation', $donnees); |
| } else { |
| // sinon on le redirige |
| $vue_resultat_inscription = $this->afficherFicheUtilisateur($id_annuaire, $id_nouvel_inscrit); |
| } |
| } |
| return $vue_resultat_inscription; |
| } |
| public function afficherInscritsEnAttenteConfirmation($id_annuaire) { |
| $donnees['id_annuaire'] = $id_annuaire; |
| $this->chargerModele('AnnuaireModele'); |
| $annuaire = $this->AnnuaireModele->chargerAnnuaire($id_annuaire); |
| $this->chargerModele('DonneeTemporaireModele'); |
| $tableau_mappage = $this->obtenirChampsMappageAnnuaire($id_annuaire); |
| $inscrits_en_attente = $this->DonneeTemporaireModele->chargerListeDonneeTemporaire('8'); |
| $inscrits_en_attente_formates = array(); |
| foreach ($inscrits_en_attente as $inscrit_attente) { |
| if ($id_annuaire == $inscrit_attente['aa_id_annuaire']) { |
| $lien_confirmation_inscription = AppControleur::getUrlConfirmationInscriptionAdmin($inscrit_attente['code_confirmation']); |
| $lien_suppression_inscription = AppControleur::getUrlSuppressionInscriptionTemporaire($id_annuaire, $inscrit_attente['code_confirmation']); |
| $date_inscription_formatee = AppControleur::formaterDateMysqlVersDateAnnuaire($inscrit_attente['date']); |
| $inscrits_en_attente_formates[] = array( |
| 'lien_confirmation' => $lien_confirmation_inscription, |
| 'lien_suppression' => $lien_suppression_inscription, |
| 'date_inscription' => $date_inscription_formatee, |
| 'mail' => $inscrit_attente['mail_'.$tableau_mappage[1]['champ_mail']], |
| 'nom' => $inscrit_attente['text_'.$tableau_mappage[1]['champ_nom']], |
| 'prenom' => $inscrit_attente['text_'.$tableau_mappage[1]['champ_prenom']]); |
| } |
| } |
| $donnees['inscrits_en_attente'] = $inscrits_en_attente_formates; |
| return $this->getVue(Config::get('dossier_squelettes_annuaires').'annuaire_inscrits_en_attente', $donnees); |
| } |
| public function supprimerInscriptionEnAttente($id_annuaire, $id_inscrit_en_attente) { |
| $this->chargerModele('DonneeTemporaireModele'); |
| $inscrits_en_attente = $this->DonneeTemporaireModele->supprimerDonneeTemporaire($id_inscrit_en_attente); |
| return $this->afficherInscritsEnAttenteConfirmation($id_annuaire); |
| } |
| public function afficherPage($id_annuaire, $id_utilisateur, $page) { |
| $donnees['id_annuaire'] = $id_annuaire; |
| $donnees['id_utilisateur'] = $id_utilisateur; |
| $this->chargerModele('AnnuaireModele'); |
| $annuaire = $this->AnnuaireModele->chargerAnnuaire($id_annuaire); |
| $donnees['aa_id_annuaire'] = $id_annuaire; |
| $this->chargerModele('MetadonneeModele'); |
| $champ_metadonnees = $this->MetadonneeModele->chargerListeMetadonneeAnnuaire($id_annuaire); |
| $valeurs_metadonnees = $this->obtenirValeursUtilisateur($id_annuaire, $id_utilisateur); |
| $tableau_mappage = $this->obtenirChampsMappageAnnuaire($id_annuaire); |
| foreach ($champ_metadonnees as $champ_metadonnee) { |
| $id_champ = $champ_metadonnee['amc_id_champ']; |
| $nom_champ = $champ_metadonnee['amc_abreviation']; |
| if(isset($valeurs_metadonnees[$nom_champ])) { |
| $champ_metadonnee['valeur_defaut'] = $valeurs_metadonnees[$nom_champ]; |
| } |
| $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,$champ_metadonnee); |
| $donnees['valeurs'] = $valeurs_metadonnees; |
| } |
| $navigateur = new NavigationControleur(); |
| $donnees['navigation'] = $navigateur->afficherBandeauNavigationUtilisateur($id_annuaire ,$id_utilisateur, $page); |
| if ($this->templateExiste($page, '/pages/')) { |
| return $this->getVue(Config::get('dossier_squelettes_pages').$page, $donnees); |
| } |
| } |
| /** |
| * Affiche la fiche principale d'un utilisateur |
| * @param int $id_annuaire l'identifiant de l'annuaire |
| * @param int $id_utilisateur l'identifiant de l'utilisateur |
| * @return string la vue contenant la fiche utilisateur |
| */ |
| public function afficherFicheUtilisateur($id_annuaire, $id_utilisateur) { |
| // Chargement des informations de l'utilisateur dans la table annuaire principale |
| $this->chargerModele('AnnuaireModele'); |
| $annuaire = $this->AnnuaireModele->chargerAnnuaire($id_annuaire); |
| $tableau_mappage = $this->AnnuaireModele->obtenirChampsMappageAnnuaire($id_annuaire); |
| $donnees['id_annuaire'] = $id_annuaire; |
| $donnees['id_utilisateur'] = $id_utilisateur; |
| $verificateur = new VerificationControleur(); |
| $champs = $this->obtenirValeursUtilisateur($id_annuaire, $id_utilisateur); |
| $donnees['tableau_mappage'] = $tableau_mappage[1]; |
| $donnees['champs'] = $champs; |
| $url_modification_profil = self::getUrlModificationProfil($id_annuaire, $id_utilisateur); |
| $donnees['url_modification_profil'] = $url_modification_profil; |
| $navigateur = new NavigationControleur(); |
| $donnees['navigation'] = $navigateur->afficherBandeauNavigationUtilisateur($id_annuaire ,$id_utilisateur, 'fiche'); |
| // S'il existe une fiche spécifique pour l'annuaire |
| if ($this->annuaireAvoirFicheUtilisateur($annuaire['informations']['aa_code'])) { |
| // on l'affiche |
| $fiche_inscrit = $this->getVue(Config::get('dossier_squelettes_fiches').$annuaire['informations']['aa_code'].'_fiche',$donnees); |
| } else { |
| // sinon on en génère une minimale par défaut |
| $tableau_nom_mappage = $this->obtenirNomsChampsMappageAnnuaire($id_annuaire); |
| $donnees['mappage_nom_champs'] = $tableau_nom_mappage; |
| $fiche_inscrit = $this->genererFicheInscrit($donnees); |
| } |
| return $fiche_inscrit; |
| } |
| /** Affiche le resumé des contributions d'un utilisateur |
| * @param int $id_annuaire l'identifiant de l'annuaire |
| * @param int $id_utilisateur l'identifiant de l'utilisateur |
| * @return string la vue contenant les contributions utilisateur |
| */ |
| public function afficherFicheResumeUtilisateur($id_annuaire, $id_utilisateur) { |
| $this->chargerModele('AnnuaireModele'); |
| $annuaire = $this->AnnuaireModele->chargerAnnuaire($id_annuaire); |
| $champs = $this->obtenirValeursUtilisateur($id_annuaire, $id_utilisateur); |
| $mail_utilisateur = $this->AnnuaireModele->obtenirMailParId($id_annuaire,$id_utilisateur); |
| $donnees['id_annuaire'] = $id_annuaire; |
| $donnees['id_utilisateur'] = $id_utilisateur; |
| $donnees['mail_utilisateur'] = $mail_utilisateur; |
| $url_modification_profil = self::getUrlModificationProfil($id_annuaire, $id_utilisateur); |
| $url_oubli_mdp = self::getUrlOubliMotDePasse($id_annuaire, $id_utilisateur); |
| $donnees['url_oubli_mdp'] = $url_oubli_mdp; |
| $donnees['url_modification_profil'] = $url_modification_profil; |
| $donnees['champs'] = $champs; |
| $navigateur = new NavigationControleur(); |
| $donnees['navigation'] = $navigateur->afficherBandeauNavigationUtilisateur($id_annuaire ,$id_utilisateur, 'resume'); |
| // on crée un controleur appelle les hooks de résumé pour chaque application externe |
| $resumes_controleur = new ApplicationExterneControleur(); |
| $donnees['resumes'] = $resumes_controleur->obtenirResume($id_utilisateur,$mail_utilisateur); |
| $donnees['carte_id'] = $this->getVue(Config::get('dossier_squelettes_fiches').$annuaire['informations']['aa_code'].'_carte_id',$donnees); |
| $fiche_contrib = $this->getVue(Config::get('dossier_squelettes_fiches').$annuaire['informations']['aa_code'].'_resume',$donnees); |
| return $fiche_contrib; |
| } |
| public function gererInscriptionExterne($id_annuaire, $id_utilisateur) { |
| $this->chargerModele('AnnuaireModele'); |
| $mail_utilisateur = $this->AnnuaireModele->obtenirMailParId($id_annuaire,$id_utilisateur); |
| $donnees['id_annuaire'] = $id_annuaire; |
| $donnees['id_utilisateur'] = $id_utilisateur; |
| $url_modification_profil = self::getUrlModificationProfil($id_annuaire,$id_utilisateur); |
| $url_oubli_mdp = self::getUrlOubliMotDePasse($id_annuaire,$id_utilisateur); |
| $donnees['url_oubli_mdp'] = $url_oubli_mdp; |
| $donnees['url_modification_profil'] = $url_modification_profil; |
| // on crée un controleur appelle les hooks de résumé pour chaque application externe |
| $resumes_controleur = new ApplicationExterneControleur(); |
| $donnees['champs'] = $this->obtenirValeursUtilisateur($id_annuaire, $id_utilisateur); |
| $navigateur = new NavigationControleur(); |
| $donnees['navigation'] = $navigateur->afficherBandeauNavigationUtilisateur($id_annuaire ,$id_utilisateur, 'gestion'); |
| //Debug::printr($champs); |
| $donnees['resumes'] = $resumes_controleur->gererInscription($id_utilisateur,$mail_utilisateur); |
| $donnees['carte_id'] = $this->getVue(Config::get('dossier_squelettes_fiches').'annuaire_tela_inscrits_carte_id',$donnees); |
| $fiche_contrib = $this->getVue(Config::get('dossier_squelettes_fiches').'annuaire_tela_inscrits_gestion_inscription',$donnees); |
| return $fiche_contrib; |
| } |
| public function afficherFormulaireModificationInscription($id_annuaire, $id_utilisateur, $erreurs = array()) { |
| $this->chargerModele('AnnuaireModele'); |
| $annuaire = $this->AnnuaireModele->chargerAnnuaire($id_annuaire); |
| $donnees['aa_id_annuaire'] = $id_annuaire; |
| $this->chargerModele('MetadonneeModele'); |
| $champ_metadonnees = $this->MetadonneeModele->chargerListeMetadonneeAnnuaire($id_annuaire); |
| $valeurs_metadonnees = $this->obtenirValeursUtilisateur($id_annuaire, $id_utilisateur); |
| $tableau_mappage = $this->obtenirChampsMappageAnnuaire($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 ($champ_metadonnees as $champ_metadonnee) { |
| $id_champ = $champ_metadonnee['amc_id_champ']; |
| $nom_champ = $champ_metadonnee['amc_abreviation']; |
| if (isset($valeurs_metadonnees[$nom_champ])) { |
| $champ_metadonnee['valeur_defaut'] = $valeurs_metadonnees[$nom_champ]; |
| } |
| $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,$champ_metadonnee); |
| } |
| $donnees['tableau_mappage'] = $tableau_mappage[1]; |
| $donnees['id_utilisateur'] = $id_utilisateur; |
| $donnees['erreurs'] = $erreurs; |
| // Si le formulaire spécifique à l'annuaire existe, on l'affiche |
| if ($this->annuaireAvoirFormulaireModificationInscription($annuaire['informations']['aa_code'])) { |
| // Sinon on prend celui par defaut |
| $formulaire_modification = $this->GetVue(Config::get('dossier_squelettes_formulaires').$annuaire['informations']['aa_code'].'_modification',$donnees); |
| } else { |
| $tableau_nom_mappage = $this->obtenirNomsChampsMappageAnnuaire($id_annuaire); |
| $donnees['mappage_nom_champs'] = $tableau_nom_mappage; |
| $formulaire_modification = $this->genererFormulaireModificationInscription($donnees); |
| } |
| return $formulaire_modification; |
| } |
| public function modifierInscription($valeurs) { |
| $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('AnnuaireModele'); |
| $tableau_mappage = $this->obtenirChampsMappageAnnuaire($id_annuaire); |
| $mail_utilisateur = $this->AnnuaireModele->obtenirMailParId($id_annuaire, $id_utilisateur); |
| $ancien_mail = $mail_utilisateur; |
| $verificateur = new VerificationControleur(); |
| $valeurs_mappees = array(); |
| $valeurs_metadonnees = array(); |
| $erreurs = array(); |
| // on itère sur le tableau de valeur pour récupérer les métadonnées |
| // et les valeurs |
| foreach($valeurs as $nom_champ => $valeur) { |
| // pour chaque valeur |
| // on extrait l'id du champ |
| $ids_champ = mb_split("_",$nom_champ); |
| $confirmation = false; |
| $valeur_a_ignorer = false; |
| // 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]; |
| } |
| if($type == 'checkbox' && $condition != 'hidden') { |
| // on récupère la valeur |
| $nom_champ = $type.'_'.$id_champ; |
| $valeur = $valeurs[$type.'_'.$id_champ]; |
| } |
| // 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 { |
| // sinon la valeur a déjà été traitée et doit être ignorée |
| $valeur_a_ignorer = true; |
| } |
| } |
| if ($type == 'mail') { |
| $mail_utilisateur = $valeur; |
| } |
| // cas du changement de mot de passe |
| if ($type == 'password') { |
| if ($condition == 'conf') { |
| $valeur_a_ignorer = true; |
| } |
| $tentative_changemement_mdp = false; |
| if (isset($valeurs[$type.'_conf_'.$id_champ]) && trim($valeurs[$type.'_conf_'.$id_champ]) != '') { |
| $tentative_changemement_mdp = true; |
| } else { |
| $valeur_a_ignorer = true; |
| } |
| if ($tentative_changemement_mdp) { |
| $confirmation = $valeurs[$type.'_conf_'.$id_champ]; |
| } |
| } |
| // Si la valeur n'est présente dans le formulaire que pour des raisons de vérification |
| // on passe à l'iteration suivante |
| if ($valeur_a_ignorer) { |
| continue; |
| } |
| $verification = $verificateur->verifierErreurChampModification($id_annuaire, $id_utilisateur, $type , $valeur, $confirmation); |
| if ($verification[0] == false) { |
| $erreurs[$type.'_'.$id_champ] = $verification[1]; |
| } |
| // on fait des vérifications et des remplacements sur certaines valeurs |
| // et quelques fois des actions externes |
| $valeur = $verificateur->remplacerValeurChampPourModification($id_annuaire, $id_utilisateur, $type, $valeur, $mail_utilisateur); |
| // 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; |
| } else { |
| // sinon, il est stocké dans les valeurs de metadonnées |
| $valeurs_metadonnees[$id_champ] = $valeur; |
| } |
| } |
| if (count($erreurs) > 0) { |
| return $this->afficherFormulaireModificationInscription($id_annuaire,$id_utilisateur,$erreurs); |
| } |
| if (isset($tableau_mappage[0]['champ_pays']) && isset($valeurs_mappees[$tableau_mappage[0]['champ_pays']])) { |
| $pays = $valeurs_mappees[$tableau_mappage[0]['champ_pays']]; |
| $valeurs_metadonnees[$tableau_mappage[1]['champ_pays']] = $pays; |
| $pays = $this->MetadonneeModele->renvoyerCorrespondanceAbreviationId($pays); |
| $valeurs_mappees[$tableau_mappage[0]['champ_pays']] = $pays; |
| } else { |
| $pays = ''; |
| } |
| $changement_mail = false; |
| if ($ancien_mail != $mail_utilisateur) { |
| $changement_mail = true; |
| } |
| if (isset($tableau_mappage[0]['champ_prenom']) && isset($valeurs_mappees[$tableau_mappage[0]['champ_prenom']])) { |
| $valeurs['text_'.$tableau_mappage[1]['champ_prenom']] = AppControleur::formaterMotPremiereLettreChaqueMotEnMajuscule($valeurs['text_'.$tableau_mappage[1]['champ_prenom']]); |
| $prenom = $valeurs['text_'.$tableau_mappage[1]['champ_prenom']]; |
| } else { |
| $prenom = ''; |
| } |
| $valeurs['text_'.$tableau_mappage[1]['champ_nom']] = AppControleur::formaterMotEnMajuscule($valeurs['text_'.$tableau_mappage[1]['champ_nom']]); |
| $nom = $valeurs['text_'.$tableau_mappage[1]['champ_nom']]; |
| $mail = $mail_utilisateur; |
| $pass = $valeurs['password_'.$tableau_mappage[1]['champ_pass']]; |
| $this->chargerModele('AnnuaireModele'); |
| $modification_annuaire = $this->AnnuaireModele->modifierInscriptionDansAnnuaireMappe($id_annuaire, $id_utilisateur ,$valeurs_mappees, $tableau_mappage[0]); |
| $nouveau_mail = $this->AnnuaireModele->obtenirMailParId($id_annuaire, $id_utilisateur); |
| // Si le mail a changé alors il faut appeler les applications externes pour modification |
| if ($ancien_mail != $mail_utilisateur || $tentative_changemement_mdp) { |
| $appli_controleur = new ApplicationExterneControleur(); |
| $params = array ( |
| 'id_utilisateur' => $id_utilisateur, |
| 'prenom' => $prenom, |
| 'nom' => $nom, |
| 'mail' => trim($ancien_mail), |
| 'pass' => $pass, |
| 'pays' => $pays, |
| 'nouveau_pass' => $pass, |
| 'nouveau_mail' => trim($nouveau_mail) |
| ); |
| $appli_controleur->modifierInscription($id_utilisateur, $params); |
| } |
| // les champs arrivent avec un identifiant sous la forme type_xxx_id |
| foreach ($valeurs_metadonnees as $id_champ => $valeur) { |
| // S'il existe déjà une valeur de metadonnée pour cette colonne et cet utilisateur |
| // car on a pu ajouter de nouveaux champs entre temps |
| if ($this->MetadonneeModele->valeurExiste($id_champ,$id_utilisateur)) { |
| // On se contente de la modifier |
| $this->MetadonneeModele->modifierValeurMetadonnee($id_champ,$id_utilisateur,$valeur); |
| } 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 { |
| return false; |
| } |
| } |
| } |
| if ($changement_mail) { |
| $identificateur = new IdentificationControleur(); |
| $identificateur->setUtilisateur($nouveau_mail); |
| } |
| $statistique = new StatistiqueControleur(); |
| $statistique->ajouterEvenementStatistique($id_annuaire, $id_utilisateur, 'modification'); |
| return $this->afficherFicheUtilisateur($id_annuaire, $id_utilisateur); |
| } |
| public function bloquerDebloquerUtilisateur($id_annuaire, $id_utilisateur, $bloquer = true) { |
| $annuaire_modele = $this->getModele('AnnuaireModele'); |
| $champs_description = $annuaire_modele->obtenirChampsDescriptionAnnuaire($id_annuaire); |
| $valeur = '0'; |
| if ($bloquer) { |
| $valeur = '1'; |
| } |
| $metadonne_modele = $this->getModele('MetadonneeModele'); |
| $metadonne_modele->modifierValeurMetadonnee($champs_description[1]['champ_statut'],$id_utilisateur,$valeur); |
| return $this->afficherFicheUtilisateur($id_annuaire, $id_utilisateur); |
| } |
| /** |
| * Affiche le formulaire permettant d'entrer un mail et de recevoir le mot de passe |
| * associé sur cette adresse |
| * @param int $id_annuaire l'identifiant de l'annuaire associé |
| */ |
| public function afficherFormulaireOubliMotDePasse($id_annuaire) { |
| $donnees['aa_id_annuaire'] = $id_annuaire; |
| return $this->getVue(Config::get('dossier_squelettes_formulaires').'oubli_mdp',$donnees); |
| } |
| /** |
| * Supprime l'ancien mot de passe d'un utilisateur et crée un nouveau mot de passe |
| * aléatoire qui sera envoyé par mail |
| * @param int $id_annuaire l'identifiant de l'annuaire associé |
| * @param int $mail le mail auquel on envoie le mot de passe |
| * |
| */ |
| public function reinitialiserMotDePasse($id_annuaire, $mail) { |
| $this->chargerModele('AnnuaireModele'); |
| $verificateur = new VerificationControleur(); |
| $messagerie = new MessageControleur(); |
| $donnees = array(); |
| 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); |
| } |
| $nouveau_mdp = $verificateur->genererMotDePasse(); |
| $nouveau_mdp_encrypte = $verificateur->encrypterMotDePasse($nouveau_mdp); |
| $modif_mdp = $this->AnnuaireModele->reinitialiserMotDePasse($id_annuaire, $mail, $nouveau_mdp_encrypte); |
| if (!$modif_mdp) { |
| $donnees['erreurs']['mdp'] = 'Impossible de générer un nouveau mot de passe'; |
| $donnees['aa_id_annuaire'] = $id_annuaire; |
| return $this->getVue(Config::get('dossier_squelettes_formulaires').'oubli_mdp',$donnees); |
| } |
| if ($messagerie->envoyerMailOubliMdp($id_annuaire, $mail, $nouveau_mdp)) { |
| $donnees['titre'] = 'Mot de passe envoyé'; |
| $donnees['message'] = 'Votre nouveau mot de passe a été envoyé à l\'adresse '.$mail; |
| } else { |
| $donnees['titre'] = 'Impossible de renvoyer le nouveau mot de passe'; |
| $donnees['message'] = 'Votre nouveau mot de passe n\'a pas pu être envoyé à l\'adresse indiquée '; |
| } |
| return $this->getVue(Config::get('dossier_squelettes_annuaires').'information_simple',$donnees); |
| } |
| public function afficherFormulaireSuppressionInscription($id_annuaire, $id_utilisateur) { |
| $donnees['id_annuaire'] = $id_annuaire; |
| $donnees['id_utilisateur'] = $id_utilisateur; |
| return $this->getVue(Config::get('dossier_squelettes_formulaires').'suppression_inscription',$donnees); |
| } |
| /** |
| * Supprime l'inscription d'un utilisateur dans un annuaire donné |
| * @param int $id_annuaire l'identifiant de l'annuaire associé |
| * @param int $id_utilisateur l'identifiant de l'utilisateur à supprimer |
| */ |
| public function supprimerInscription($id_annuaire, $id_utilisateur) { |
| if (!$id_utilisateur || $id_utilisateur == '') { |
| return $this->index(); |
| } |
| $this->chargerModele('AnnuaireModele'); |
| $annuaire = $this->AnnuaireModele->chargerAnnuaire($id_annuaire); |
| $champs_mappage = $this->obtenirChampsMappageAnnuaire($id_annuaire); |
| $mail_utilisateur = $this->AnnuaireModele->obtenirMailParId($id_annuaire, $id_utilisateur); |
| $suppression_inscription = $this->AnnuaireModele->supprimerInscriptionDansAnnuaireMappe($id_annuaire, $id_utilisateur); |
| if (!$mail_utilisateur || $mail_utilisateur == '') { |
| return $this->index(); |
| } |
| $donnees = array('erreurs' => array()); |
| $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'] = 'Erreur lors de la suppression de l\'inscription '; |
| return $this->getVue(Config::get('dossier_squelettes_elements').'erreurs',$donnees); |
| } |
| $params = array ( |
| 'id_utilisateur' => $id_utilisateur, |
| 'prenom' => '', |
| 'nom' => '', |
| 'mail' => $mail_utilisateur, |
| 'pass' => '', |
| 'pays' => '', |
| 'nouveau_pass' => '', |
| 'nouveau_mail' => '' |
| ); |
| // on appelle les controleur de lettre actu et d'applications externes |
| $appli_controleur = new ApplicationExterneControleur(); |
| $appli_controleur->supprimerInscription($id_utilisateur, $params); |
| // pour qu'ils lancent les procédures de désinscription associées |
| $lettre_controleur = new LettreControleur(); |
| $lettre_controleur->desinscriptionLettreActualite($mail_utilisateur); |
| if ($id_utilisateur == Registre::getInstance()->get('identification_id')) { |
| $identificateur = new IdentificationControleur(); |
| $identificateur->deloggerUtilisateur(); |
| } |
| $donnees = array(); |
| // Si le formulaire spécifique à l'annuaire existe, on l'affiche |
| if ($this->annuaireAvoirPagePostDesinscription($annuaire['informations']['aa_code'])) { |
| $informations_desinscription = $this->GetVue(Config::get('dossier_squelettes_annuaires').$annuaire['informations']['aa_code'].'_desinscription_confirmation',$donnees); |
| } else { |
| // Sinon on prend celui par defaut |
| $donnees['titre'] = 'Vous êtes maintenant désinscrit de l\'annuaire'; |
| $donnees['message'] = 'Votre désinscription a bien été prise en compte <br />'; |
| $informations_desinscription = $this->getVue(Config::get('dossier_squelettes_annuaires').'information_simple',$donnees); |
| } |
| $statistique = new StatistiqueControleur(); |
| $statistique->ajouterEvenementStatistique($id_annuaire, $id_utilisateur, 'suppression'); |
| return $informations_desinscription; |
| } |
| /** |
| * Affiche le formulaire de recherche pour un annuaire donné ou en génère un à la volée |
| * @param int $id_annuaire l'identifiant de l'annuaire |
| * @param array $donnees des données utilisées pour pré remplir le formulaire |
| * @return string le html contenant le formulaire de recherche |
| */ |
| 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 $nom_champ => $metadonnee) { |
| $id_champ = $metadonnee['amc_id_champ']; |
| $type_champ = $metadonnee['amc_ce_template_affichage']; |
| $nom_champ = $metadonnee['amc_abreviation']; |
| if(isset($donnees[$type_champ.'_'.$id_champ])) { |
| $metadonnee['valeur_defaut']['amv_valeur'] = $donnees[$type_champ.'_'.$id_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); |
| } |
| // Si le formulaire spécifique à l'annuaire existe, on l'affiche |
| if ($this->annuaireAvoirFormulaireRecherche($annuaire['informations']['aa_code'])) { |
| // Sinon on prend celui par defaut |
| $formulaire_recherche = $this->GetVue(Config::get('dossier_squelettes_formulaires').$annuaire['informations']['aa_code'].'_recherche',$donnees); |
| } else { |
| $tableau_nom_mappage = $this->obtenirNomsChampsMappageAnnuaire($id_annuaire); |
| $donnees['mappage_nom_champs'] = $tableau_nom_mappage; |
| $formulaire_recherche = $this->genererFormulaireRecherche($donnees); |
| } |
| return $formulaire_recherche; |
| } |
| /** |
| * 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 |
| */ |
| public function rechercherInscrit($id_annuaire, $valeurs_recherchees, $exclusive = true) { |
| $this->chargerModele('AnnuaireModele'); |
| $annuaire = $this->AnnuaireModele->chargerAnnuaire($id_annuaire, true); |
| if (isset($_GET['numero_page'])) { |
| $numero_page = $_GET['numero_page']; |
| unset($_GET['numero_page']); |
| unset($valeurs_recherchees['numero_page']); |
| } else { |
| $numero_page = 1; |
| } |
| if (isset($_GET['taille_page'])) { |
| $taille_page = $_GET['taille_page']; |
| unset($_GET['taille_page']); |
| unset($valeurs_recherchees['taille_page']); |
| } else { |
| $taille_page = 50; |
| } |
| $tableau_mappage = $this->AnnuaireModele->obtenirChampsMappageAnnuaire($id_annuaire); |
| $valeurs_mappees = array(); |
| $valeurs = array(); |
| $collecteur = new VerificationControleur(); |
| $tableau_valeur_collectees = $collecteur->collecterValeursRechercheMoteur($valeurs_recherchees, $tableau_mappage); |
| $valeurs_recherchees = $tableau_valeur_collectees['valeurs_recherchees']; |
| $valeurs_mappees = $tableau_valeur_collectees['valeurs_mappees']; |
| $valeurs_get = $tableau_valeur_collectees['valeurs_get']; |
| $admin = Registre::getInstance()->get('est_admin'); |
| // 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); |
| // 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, $numero_page, $taille_page); |
| $resultat_recherche = $resultat_annuaire_mappe['resultat']; |
| $nb_resultats = $resultat_annuaire_mappe['total']; |
| $champ_id_annuaire = $tableau_mappage[0]['champ_id']; |
| $resultats = array(); |
| foreach ($resultat_recherche as $resultat) { |
| $id_utilisateur = $resultat[$champ_id_annuaire]; |
| $resultats[$id_utilisateur] = $this->obtenirValeursUtilisateur($id_annuaire, $id_utilisateur); |
| } |
| // on renvoie une liste identique à celle de la liste des inscrits |
| $donnees['resultats_recherche'] = $resultats; |
| $donnees['tableau_mappage'] = $tableau_mappage[1]; |
| $donnees['id_annuaire'] = $id_annuaire; |
| $donnees['nb_resultats'] = $nb_resultats; |
| $url_base = new URL(Registre::getInstance()->get('base_url_application')); |
| $url_pagination = clone($url_base); |
| $valeurs_get['m'] = $_GET['m']; |
| $valeurs_get['id_annuaire'] = $id_annuaire; |
| $donnees['pagination'] = $this->paginer($numero_page,$taille_page,$nb_resultats,$url_pagination, $valeurs_get); |
| $valeurs_get['exclusive'] = $exclusive; |
| $donnees['criteres'] = urlencode(serialize($valeurs_get)); |
| $valeurs_get['id_annuaire'] = $id_annuaire; |
| // S'il existe une page de résultats spécifique à l'annuaire pour la recherche |
| if ($this->annuaireAvoirPageResultatRecherche($annuaire['informations']['aa_code'])) { |
| // on l'affiche |
| $vue_resultat_recherche = $this->getVue(Config::get('dossier_squelettes_annuaires').$annuaire['informations']['aa_code'].'_resultat_recherche', $donnees); |
| } else { |
| // sinon on prend celle par défaut |
| $tableau_nom_mappage = $this->obtenirNomsChampsMappageAnnuaire($id_annuaire); |
| $donnees['mappage_nom_champs'] = $tableau_nom_mappage; |
| $vue_resultat_recherche = $this->getVue(Config::get('dossier_squelettes_annuaires').'resultat_recherche', $donnees); |
| } |
| return $this->afficherFormulaireRecherche($id_annuaire, $valeurs_get).$vue_resultat_recherche; |
| } |
| /** Recherche un ou plusieurs inscrits selon des indications géographiques, 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 rechercherInscritParlocalisation($id_annuaire,$valeurs_recherchees) { |
| if (isset($_GET['taille_page'])) { |
| $taille_page = $_GET['taille_page']; |
| } else { |
| $taille_page = 50; |
| } |
| if (isset($_GET['numero_page'])) { |
| $numero_page = $_GET['numero_page']; |
| } else { |
| $numero_page = 1; |
| } |
| $this->chargerModele('AnnuaireModele'); |
| $annuaire = $this->AnnuaireModele->chargerAnnuaire($id_annuaire, true); |
| $tableau_mappage = $this->obtenirChampsMappageAnnuaire($id_annuaire); |
| $valeurs_get = $valeurs_recherchees; |
| $valeurs_mappees = array(); |
| $valeurs = array(); |
| $continent = $valeurs_recherchees['continent']; |
| $champ_id_annuaire = $tableau_mappage[0]['champ_id']; |
| $valeur = $valeurs_recherchees['pays']; |
| $champ_critere = $tableau_mappage[0]['champ_pays']; |
| $criteres = array($tableau_mappage[0]['champ_pays'] => $valeurs_recherchees['pays']); |
| if (isset($valeurs_recherchees['departement'])) { |
| $valeur = $valeurs_recherchees['departement']; |
| $champ_critere = $tableau_mappage[0]['champ_code_postal']; |
| $criteres = array( |
| $tableau_mappage[0]['champ_pays'] => $valeurs_recherchees['pays'], |
| $tableau_mappage[0]['champ_code_postal'] => $valeurs_recherchees['departement'] |
| ); |
| } |
| $resultat_annuaire_mappe = $this->AnnuaireModele->rechercherInscritDansAnnuaireMappeParTableauChamps($id_annuaire, $criteres, true, $numero_page, $taille_page); |
| $resultat_recherche = $resultat_annuaire_mappe; |
| $nb_resultats = $resultat_recherche['total']; |
| $resultat_recherche = $resultat_recherche['resultat']; |
| $resultats = array(); |
| foreach ($resultat_recherche as $resultat) { |
| $id_utilisateur = $resultat[$champ_id_annuaire]; |
| $resultats[$id_utilisateur] = $this->obtenirValeursUtilisateur($id_annuaire, $id_utilisateur); |
| } |
| // on renvoie une liste identique à celle de la liste des inscrits |
| $donnees['resultats_recherche'] = $resultats; |
| $donnees['tableau_mappage'] = $tableau_mappage[1]; |
| $donnees['id_annuaire'] = $id_annuaire; |
| $donnees['nb_resultats'] = $nb_resultats; |
| $donnees['criteres'] = urlencode(serialize(array( |
| 'select_'.$tableau_mappage[1]['champ_pays'] => $valeurs_recherchees['pays'], |
| 'text_'.$tableau_mappage[1]['champ_code_postal'] => $valeurs_recherchees['departement'], |
| 'exclusive' => true |
| ))); |
| $url_base = new URL(Registre::getInstance()->get('base_url_application')); |
| $url_pagination = clone($url_base); |
| $valeurs_get['id_annuaire'] = $id_annuaire; |
| $valeurs_get['m'] = $_GET['m']; |
| $donnees['pagination'] = $this->paginer($numero_page,$taille_page,$nb_resultats,$url_pagination, $valeurs_get); |
| if ($this->annuaireAvoirPageResultatRecherche($annuaire['informations']['aa_code'])) { |
| // on l'affiche |
| $navigation_carto = new NavigationControleur(); |
| $cartographe = new CartoControleur(); |
| $donnees_navigation = $cartographe->obtenirUrlsNavigation($id_annuaire,$valeurs_recherchees['continent'],$valeurs_recherchees['pays'],$valeurs_recherchees['departement']); |
| $donnees['navigation'] = $navigation_carto->afficherBandeauNavigationCartographie($donnees_navigation); |
| $vue_resultat_recherche = $this->getVue(Config::get('dossier_squelettes_annuaires').$annuaire['informations']['aa_code'].'_resultat_recherche', $donnees); |
| } else { |
| // sinon on prend celle par défaut |
| $tableau_nom_mappage = $this->obtenirNomsChampsMappageAnnuaire($id_annuaire); |
| $donnees['mappage_nom_champs'] = $tableau_nom_mappage; |
| $vue_resultat_recherche = $this->getVue(Config::get('dossier_squelettes_annuaires').'resultat_recherche', $donnees); |
| } |
| return $vue_resultat_recherche; |
| } |
| public function rechercherDoublons($id_annuaire) { |
| if (isset($_GET['taille_page'])) { |
| $taille_page = $_GET['taille_page']; |
| } else { |
| $taille_page = 50; |
| } |
| if (isset($_GET['numero_page'])) { |
| $numero_page = $_GET['numero_page']; |
| } else { |
| $numero_page = 1; |
| } |
| $this->chargerModele('AnnuaireModele'); |
| $annuaire = $this->AnnuaireModele->chargerAnnuaire($id_annuaire, true); |
| $tableau_mappage = $this->obtenirChampsMappageAnnuaire($id_annuaire); |
| $champ_id_annuaire = $tableau_mappage[0]['champ_id']; |
| $resultat_recherche_doublons= $this->AnnuaireModele->rechercherDoublonsDansAnnuaireMappe($id_annuaire, $numero_page, $taille_page); |
| $nb_resultats = $resultat_recherche_doublons['total']; |
| $resultat_recherche = $resultat_recherche_doublons['resultat']; |
| $resultats = array(); |
| foreach ($resultat_recherche as $resultat) { |
| $id_utilisateur = $resultat[$champ_id_annuaire]; |
| $resultats[$id_utilisateur] = $this->obtenirValeursUtilisateur($id_annuaire, $id_utilisateur); |
| } |
| // on renvoie une liste identique à celle de la liste des inscrits |
| $donnees['resultats_recherche'] = $resultats; |
| $donnees['tableau_mappage'] = $tableau_mappage[1]; |
| $donnees['id_annuaire'] = $id_annuaire; |
| $donnees['nb_resultats'] = $nb_resultats; |
| $url_base = new URL(Registre::getInstance()->get('base_url_application')); |
| $url_pagination = clone($url_base); |
| $valeurs_get = array('m' => 'annuaire_recherche_doublons', 'id_annuaire' => $id_annuaire); |
| $donnees['pagination'] = $this->paginer($numero_page,$taille_page,$nb_resultats,$url_pagination, $valeurs_get); |
| if ($this->annuaireAvoirPageResultatRecherche($annuaire['informations']['aa_code'])) { |
| // on l'affiche |
| $vue_resultat_recherche = $this->getVue(Config::get('dossier_squelettes_annuaires').$annuaire['informations']['aa_code'].'_resultat_recherche', $donnees); |
| } else { |
| // sinon on prend celle par défaut |
| $tableau_nom_mappage = $this->obtenirNomsChampsMappageAnnuaire($id_annuaire); |
| $donnees['mappage_nom_champs'] = $tableau_nom_mappage; |
| $vue_resultat_recherche = $this->getVue(Config::get('dossier_squelettes_annuaires').'resultat_recherche', $donnees); |
| } |
| return $vue_resultat_recherche; |
| } |
| /** --- Fonction pour les images ------------------------------------------------------------------------*/ |
| public function afficherFormulaireUploadImage($id_annuaire,$id_utilisateur, $donnees = array()) { |
| $donnees['aa_id_annuaire'] = $id_annuaire; |
| $donnees['id_utilisateur'] = $id_utilisateur; |
| $donnees['amc_nom'] = 'Image de profil'; |
| $this->chargerModele('AnnuaireModele'); |
| $id_champ_image = $this->AnnuaireModele->obtenirChampAvatar($id_annuaire); |
| if (!$id_champ_image) { |
| $donnees['erreurs'] = 'Aucun champ n\'est défini pour l\'image de profil'; |
| return $this->getVue(Config::get('dossier_squelettes_elements').'erreurs',$donnees); |
| } |
| $formats = str_replace('|',', ',Config::get('extensions_acceptees')); |
| $donnees['formats'] = $formats; |
| $taille_max = Config::get('taille_max_images'); |
| $taille_max_formatee = VerificationControleur::convertirTailleFichier(Config::get('taille_max_images')); |
| $donnees['taille_max_formatee'] = $taille_max_formatee; |
| $donnees['taille_max'] = $taille_max; |
| $donnees['amc_id_champ'] = $id_champ_image; |
| return $this->getVue(Config::get('dossier_squelettes_champs').'image',$donnees); |
| } |
| /** |
| * Ajoute une image uploadée à travers le formulaire |
| * |
| */ |
| public function ajouterImageUtilisateur($id_annuaire, $id_utilisateur, $fichier_a_stocker, $retourner_booleen = false) { |
| $donnees = array('erreurs' => array(), 'aa_id_annuaire' => $id_annuaire); |
| foreach ($fichier_a_stocker as $nom_champ => $fichier) { |
| $ids_champ = mb_split("_",$nom_champ, 3); |
| if (count($ids_champ) == 2) { |
| $type = $ids_champ[0]; |
| $id_champ = $ids_champ[1]; |
| } else { |
| trigger_error('Ce champ n\'est pas relié à un annuaire'); |
| return false; |
| } |
| $this->chargerModele('ImageModele'); |
| $format_accepte = $this->ImageModele->verifierFormat($fichier['name']); |
| if (!$format_accepte) { |
| $formats = str_replace('|',', ',Config::get('extensions_acceptees')); |
| $donnees['erreurs'][$id_champ] = 'Cette extension de fichier n\'est pas prise en charge. Veuillez utiliser un fichier portant l\'une des extensions suivantes :'.$formats ; |
| return $this->afficherFormulaireUploadImage($id_annuaire, $id_utilisateur,$donnees); |
| } |
| $stockage_image = $this->ImageModele->stockerFichier($id_annuaire, $id_utilisateur, $fichier); |
| $this->chargerModele('MetadonneeModele'); |
| if ($this->MetadonneeModele->valeurExiste($id_champ,$id_utilisateur)) { |
| // On se contente de la modifier |
| if ($stockage_image && $this->MetadonneeModele->modifierValeurMetadonnee($id_champ,$id_utilisateur,$id_utilisateur)) { |
| } else { |
| $donnees['erreurs'][$id_champ] = 'Problème durant le stockage de l\'image'; |
| return $this->afficherFormulaireUploadImage($id_annuaire, $id_utilisateur,$donnees); |
| } |
| } else { |
| // S'il n'existe pas de valeur, on ajoute une nouvelle ligne à la table de valeurs de meta données |
| if ($stockage_image && $this->MetadonneeModele->ajouterNouvelleValeurMetadonnee($id_champ,$id_utilisateur,$id_utilisateur)) { |
| // Si l'insertion a réussi, on continue |
| } else { |
| $donnees['erreurs'][$id_champ] = 'Problème durant le stockage de l\'image'; |
| return $this->afficherFormulaireUploadImage($id_annuaire, $id_utilisateur,$id_champ,$donnees); |
| } |
| } |
| } |
| if ($retourner_booleen) { |
| return true; |
| } else { |
| return $this->afficherFicheUtilisateur($id_annuaire, $id_utilisateur) ; |
| } |
| } |
| public function obtenirTableauDerniersInscrits($id_annuaire, $limite = '20') { |
| // Chargement des informations de l'utilisateur dans la table annuaire principale |
| $this->chargerModele('AnnuaireModele'); |
| $annuaire = $this->AnnuaireModele->chargerAnnuaire($id_annuaire); |
| $tableau_mappage = $this->obtenirChampsMappageAnnuaire($id_annuaire); |
| $this->chargerModele('AnnuaireModele'); |
| $tableau_ids = $this->AnnuaireModele->obtenirTableauIdsUtilisateurs($id_annuaire, $tableau_mappage[0]); |
| $derniers_inscrits = array(); |
| foreach ($tableau_ids as $id) { |
| $id_utilisateur = $id[$tableau_mappage[0][champ_id]]; |
| $derniers_inscrits[$id_utilisateur] = $this->obtenirValeursUtilisateur($id_annuaire, $id_utilisateur); |
| } |
| return $derniers_inscrits; |
| } |
| public function chargerNombreAnnuaireListeInscrits($id_annuaire) { |
| $annuaire_modele = $this->getModele('AnnuaireModele'); |
| return $annuaire_modele->chargerNombreAnnuaireListeInscrits($id_annuaire); |
| } |
| public function chargerNombreAnnuaireListeInscritsParPays($id_annuaire, $id_zones) { |
| $annuaire_modele = $this->getModele('AnnuaireModele'); |
| return $annuaire_modele->chargerNombreAnnuaireListeInscritsParPays($id_annuaire, $id_zones); |
| } |
| public function chargerNombreAnnuaireListeInscritsParDepartement($id_annuaire) { |
| $this->chargerModele('AnnuaireModele'); |
| return $this->AnnuaireModele->chargerNombreAnnuaireListeInscritsParDepartement($id_annuaire); |
| } |
| } |
| Property changes: |
| Added: svnkit:entry:sha1-checksum |
| +944bd9cfcd47b6193f55d5774b921b5d4a220ca4 |
| \ No newline at end of property |