Subversion Repositories eFlore/Applications.del

Compare Revisions

Ignore whitespace Rev 2076 → Rev 2077

/trunk/build.xml
48,7 → 48,7
<java classname="com.google.gwt.dev.Compiler" fork="true">
<arg line="-style DETAILED -draftCompile ${projectTestName}" />
<arg line="-logLevel INFO" />
<arg line="-style OBF" />
<!--<arg line="-style OBF" />-->
<arg value="org.tela_botanica.del.Del" />
<classpath>
<path>
/trunk/services/modules/0.1/utilisateurs/Deconnecter.php
File deleted
\ No newline at end of file
/trunk/services/modules/0.1/utilisateurs/Connecter.php
File deleted
\ No newline at end of file
/trunk/services/modules/0.1/utilisateurs/Preferences.php
1,7 → 1,7
<?php
// declare(encoding='UTF-8');
/**
* Permet la gestion des préférences utilisateur.
* Permet la gestion des préférences utilisateur
*
* @category DEL
* @package Services
15,40 → 15,30
* @copyright 1999-2014 Tela Botanica <accueil@tela-botanica.org>
*/
 
class Preferences {
class Preferences extends GestionUtilisateur {
 
private $conteneur;
private $bdd;
 
public function __construct(Conteneur $conteneur) {
session_start();
$this->conteneur = $conteneur;
$this->bdd = $this->conteneur->getBdd();
}
 
/**
* Renvoie les préférences utilisateurs
* Renvoie les préférences d'un utilisateur
* @param array $ressources les ressources situées après l'url de base (ex : http://url/ressource1/ressource2)
* @param array $parametres les paramètres situés après le ? dans l'url
* */
public function consulter($ressources, $parametres) {
$id_utilisateur = $ressources[0];
 
$this->controleUtilisateurIdentifie($id_utilisateur);
// Mettre en forme le résultat et l'envoyer pour affichage
$resultat = new ResultatService();
$gestion_utilisateur = new GestionUtilisateur($this->conteneur);
$resultat->corps = $gestion_utilisateur->obtenirPreferencesUtilisateur($id_utilisateur);
$resultat->corps = $this->obtenirPreferencesUtilisateur($id_utilisateur);
return $resultat;
}
 
/**
* Méthode principale de la classe.
* Modifie les préférences utilisateurs
* Modifie les préférences de l'utilisateur
* @param array $ressources les ressources situées après l'url de base (ex : http://url/ressource1/ressource2)
* @param array $parametres les paramètres situés dans le post
* @param array $parametres les paramètres situés d ans le post
* */
public function modifier($ressources, $parametres) {
$id_utilisateur = $ressources[0];
$this->controleUtilisateurIdentifie($id_utilisateur);
$prefs = $this->modifierPreferencesUtilisateur($id_utilisateur, $parametres);
// Mettre en forme le résultat et l'envoyer pour affichage
$resultat = new ResultatService();
/trunk/services/modules/0.1/utilisateurs/Activite.php
15,22 → 15,21
class Activite extends GestionUtilisateur {
 
/**
* Méthode principale de la classe.
* Lance la récupération des images dans la base et les place dans un objet ResultatService
* pour l'afficher.
* @param array $ressources les ressources situées après l'url de base (ex : http://url/ressource1/ressource2)
* @param array $parametres les paramètres situés après le ? dans l'url
* Retourne l'activité de l'utilisateur en cours, ou false si aucun utilisateur connu
* n'est identifié (mode anonyme) @TODO retrouner un truc mieux
* */
public function consulter($ressources, $parametres) {
$utilisateur = $this->getUtilisateurIdentifie();
$id_utilisateur = $utilisateur['id_utilisateur'];
$activite = $this->getEvenements($id_utilisateur);
 
// Mettre en forme le résultat et l'envoyer pour affichage
$resultat = new ResultatService();
$resultat->corps = $activite;
return $resultat;
if ($this->utilisateur['connecte'] === true) {
$id_utilisateur = $this->utilisateur['id_utilisateur'];
$activite = $this->getEvenements($id_utilisateur);
 
// Mettre en forme le résultat et l'envoyer pour affichage
$resultat = new ResultatService();
$resultat->corps = $activite;
 
return $resultat;
}
return false;
}
}
/trunk/services/modules/0.1/utilisateurs/Identification.php
1,7 → 1,7
<?php
// declare(encoding='UTF-8');
/**
* Permt de gérer "l'identification" anonyme.
* Gestion de l'identification des utilisateurs
*
* @category DEL
* @package Services
16,24 → 16,15
*/
class Identification extends GestionUtilisateur {
 
/**
* Méthode principale de la classe.
* Lance la récupération des images dans la base et les place dans un objet ResultatService
* pour l'afficher.
* @param array $ressources les ressources situées après l'url de base (ex : http://url/ressource1/ressource2)
* @param array $parametres les paramètres situés après le ? dans l'url
* */
public function consulter($ressources, $parametres) {
$utilisateur = $this->getUtilisateurIdentifie();
if ($utilisateur != null) {
$utilisateur['connecte'] = true;
$utilisateur = $this->utilisateur;
if ($utilisateur['connecte'] === true) {
$this->ajouterEvenements($utilisateur);
} else {
$utilisateur = $this->getUtilisateurAnonyme();
}
 
$resultat = new ResultatService();
$resultat->corps = $utilisateur;
 
return $resultat;
}
}
/trunk/services/modules/0.1/images/VotesImage.php
171,6 → 171,7
$idImgP = $this->bdd->proteger($this->ressources[0]);
$idProtocoleP = $this->bdd->proteger($this->parametres['protocole']);
$idUtilisateurP = $this->bdd->proteger($this->parametres['utilisateur']);
// @SECURE vérifier que l'utilisateur qui modifie son vote est bien celui qui est connecté
$requete = 'UPDATE del_image_vote '.
"SET valeur = $valeurP, date = NOW() ".
"WHERE ce_image = $idImgP AND ce_protocole = $idProtocoleP AND ce_utilisateur = $idUtilisateurP ".
242,12 → 243,12
}
 
private function verifierAutorisationSuppression($voteInfos) {
$controle_acces = $this->conteneur->getControleAcces();
$utilisateur = $controle_acces->getInfosUtilisateurConnecte();
 
$gestion_utilisateur = $this->conteneur->getUtilisateur();
$utilisateur = $gestion_utilisateur->getUtilisateur();
// @SECURE vérifier que l'utilisateur qui modifie son vote est bien celui qui est connecté
if (isset($utilisateur['id_utilisateur']) &&
$utilisateur['id_utilisateur'] != $voteInfos['id_utilisateur'] &&
$controle_acces->getIdAnonymeTemporaire() != $voteInfos['id_utilisateur']) {
$gestion_utilisateur->getIdAnonymeTemporaire() != $voteInfos['id_utilisateur']) {
$message = "Vous n'êtes pas autorisé à supprimer le vote : {$voteInfos['id_vote']}";
throw new Exception($message, RestServeur::HTTP_CODE_ACCES_NON_AUTORISE);
}
/trunk/services/modules/0.1/images/ListeImages.php
153,8 → 153,8
* @return mixed Chaine "OK" (en majuscule) en cas de succès, booléen "false" en cas d'échec
*/
public function supprimer($ressources) {
$controlAcces = $this->conteneur->getControleAcces();
$controlAcces->etreUtilisateurAvecDroitAdmin();
$gestionUtilisateurs = $this->conteneur->getUtilisateur();
$gestionUtilisateurs->etreUtilisateurAvecDroitAdmin();
 
$urlServiceBase = $this->conteneur->getParametre('urlServiceCelImage');
$idImage = $ressources[0];
/trunk/services/modules/0.1/observations/VoteObservation.php
197,10 → 197,14
$msg = "Aucun identifiant de proposition n'est lié à cette observation.";
throw new Exception($msg, RestServeur::HTTP_CODE_MAUVAISE_REQUETE);
}
// protection anti-usurpateurs
/*$idUtilisateur = $this->parametres['utilisateur'];
$gestionUtilisateurs = $this->conteneur->getUtilisateur();
$gestionUtilisateurs->controleUtilisateurIdentifie($idUtilisateur);*/
 
$idObsP = $this->bdd->proteger($this->ressources[0]);
$idPropositionP = $this->bdd->proteger($idProposition);
$idUtilisateurP = $this->bdd->proteger($this->parametres['utilisateur']);
$idUtilisateurP = $this->bdd->proteger($idUtilisateur);
$valeurP = $this->bdd->proteger($this->parametres['valeur']);
$requete = 'UPDATE del_commentaire_vote '.
"SET valeur = $valeurP, date = NOW() ".
209,7 → 213,7
 
$resultat = $this->bdd->executer($requete);
if ($resultat === false) {
$msg = "Un erreur est survenu lors de la tentative de modification du vote.";
$msg = "Une erreur est survenue lors de la tentative de modification du vote.";
throw new Exception($msg, RestServeur::HTTP_CODE_ERREUR);
} else if ($resultat === 0) {
$msg = "Aucun vote ne correspond au critères fournis : ".
/trunk/services/modules/0.1/observations/ListeObservations.php
107,16 → 107,17
}
private function renvoyerRequeteSelonType() {
//TODO: interdire l'appel si l'on est pas connecté ?
if($this->monActiviteEstDemandee()) {
$gestion_utilisateur = new GestionUtilisateur($this->conteneur);
$utilisateur = $gestion_utilisateur->getUtilisateurIdentifie();
$id_utilisateur = $utilisateur['id_utilisateur'];
$requete = $this->sql->getRequeteIdObsMonactiviteTout($id_utilisateur, $this->sql->getLimit()).' -- '.__FILE__.':'.__LINE__;
// Enregistrement de la date de consultation pour ne pas réafficher des évènements déjà consultés
$gestion_utilisateur->setDerniereDateConsultationEvenements($id_utilisateur, date('Y-m-d H:i:s'));
$utilisateur = $gestion_utilisateur->getUtilisateur();
if ($utilisateur['connecte'] === true) {
$id_utilisateur = $utilisateur['id_utilisateur'];
$requete = $this->sql->getRequeteIdObsMonactiviteTout($id_utilisateur, $this->sql->getLimit()).' -- '.__FILE__.':'.__LINE__;
// Enregistrement de la date de consultation pour ne pas réafficher des événements déjà consultés
$gestion_utilisateur->setDerniereDateConsultationEvenements($id_utilisateur, date('Y-m-d H:i:s'));
} else {
//TODO: que faire si l'on n'est pas connecté ?
}
} else {
$requete = 'SELECT SQL_CALC_FOUND_ROWS id_observation '.
'FROM del_observation AS do '.
162,10 → 163,9
return $this->bdd->recupererTous($requete);
}
private function stockerEvenementsObs($idsObsConcat) {
private function stockerEvenementsObs($idsObsConcat) {
$gestion_utilisateur = new GestionUtilisateur($this->conteneur);
$utilisateur = $gestion_utilisateur->getUtilisateurIdentifie();
$utilisateur = $gestion_utilisateur->getUtilisateur();
$id_utilisateur = $utilisateur['id_utilisateur'];
$evenements = $this->sql->getEvenementsObs($idsObsConcat, $id_utilisateur);
/trunk/services/modules/0.1/observations/ObservationDetails.php
185,8 → 185,8
* @return mixed Chaine "OK" (en majuscule) en cas de succès, booléen "false" en cas d'échec
*/
public function modifier($ressources, $parametres) {
$controlAcces = $this->conteneur->getControleAcces();
$controlAcces->etreUtilisateurAvecDroitAdmin();
$gestionUtilisateurs = $this->conteneur->getUtilisateur();
$gestionUtilisateurs->etreUtilisateurAvecDroitAdmin();
 
$retour = false;
if (isset($parametres['transmission'])) {
/trunk/services/modules/0.1/Utilisateurs.php
75,14 → 75,10
if (!isset($this->ressources) || empty($this->ressources)) {
$this->sousServiceNom = 'identification';
} else {
if (count($this->ressources) == 1 && ($this->ressources[0] == 'deconnecter')) {
$this->sousServiceNom = 'deconnecter';
} else if(count($this->ressources) == 2 && $this->ressources[1] == 'preferences') {
if(count($this->ressources) == 2 && $this->ressources[1] == 'preferences') {
$this->sousServiceNom = 'preferences';
} else if(count($this->ressources) == 2 && $this->ressources[1] == 'activite') {
$this->sousServiceNom = 'activite';
} else if (count($this->ressources) == 2) {
$this->sousServiceNom = 'connecter';
} else {
$this->sousServiceNom = 'identification';
}
/trunk/services/modules/0.1/determinations/ValiderDetermination.php
138,8 → 138,8
}
 
private function verifierDroitUtilisateur() {
$controleAcces = $this->conteneur->getControleAcces();
$utilisateurInfos = $controleAcces->getInfosUtilisateurConnecte();
$gestionUtilisateur = $this->conteneur->getUtilisateur();
$utilisateurInfos = $gestionUtilisateur->getUtilisateur();
$utilisateurId = $utilisateurInfos['id_utilisateur'];
 
// si l'utilisateur connecté n'est ni auteur de l'observation, ni au moins administrateur de niveau 1
166,8 → 166,8
private function avertirAuteurObservation() {
// le validateur est forcément celui qui est actuellement connecté
$controleAcces = $this->conteneur->getControleAcces();
$utilisateurInfos = $controleAcces->getInfosUtilisateurConnecte();
$gestionUtilisateur = $this->conteneur->getUtilisateur();
$utilisateurInfos = $gestionUtilisateur->getUtilisateur();
$infos_obs = $this->getInfosObs();
/trunk/services/configurations/config.defaut.ini
108,6 → 108,7
; AUTRES SERVICES
; URL de base des services de l'annuaire
urlServiceBaseAnnuaire = "http://localhost/service:annuaire:"
urlServiceBaseAuth = "https://localhost/service:annuaire:auth/"
 
; +------------------------------------------------------------------------------------------------------+
; APPLI OBS = PictoFlora
/trunk/services/bibliotheque/GestionUtilisateur.php
20,7 → 20,7
protected $contexte;
protected $bdd;
 
private $utilisateur = array();
protected $utilisateur = array();
 
public function __construct(Conteneur $conteneur) {
$this->conteneur = $conteneur;
29,6 → 29,10
$this->chargerUtilisateur();
}
 
/**
* Charge des données utilisateur : un vrai profil si l'utilisateur est identifié,
* un profil "anonyme" sinon
*/
private function chargerUtilisateur() {
$this->demarrerSession();
$infos = $this->getUtilisateurIdentifie();
38,23 → 42,116
private function demarrerSession() {
if (session_id() == '') {
// TODO : modifier ce test lors du passage en php 5.4
// TODO : expliquer pourquoi SVP :)
session_start();
}
}
 
// rétrocompat avec un vieux machin
public function getIdAnonymeTemporaire() {
return $this->utilisateur['session_id'];
}
 
/**
* Retourne l'utilisateur en cours, chargé dans le constructeur
* par getutilisateurIdentifié()
*/
public function getUtilisateur() {
return $this->utilisateur;
}
/**
* Recherche un jeton SSO dans l'entête HTTP "Authorization", vérifie ce
* jeton auprès de l'annuaire et en cas de succès charge les informations
* de l'utilisateur associé
*
* @return Array un profil utilisateur ou null
*/
public function getUtilisateurIdentifie() {
$utilisateur = null;
$delCourriel = $this->contexte->getCookie('del_courriel');
$delMdp = $this->contexte->getCookie('del_mot_de_passe');
if ($delCourriel != null && $delMdp != null) {
$utilisateur = $this->identifierUtilisateurSansEncryptionMotDePasse($delCourriel, $delMdp);
// lecture du jeton
$jeton = $this->lireJetonEntete();
if ($jeton != null) {
// validation par l'annuaire
$valide = $this->verifierJeton($jeton);
if ($valide === true) {
// décodage du courriel utilisateur depuis le jeton
$donneesJeton = $this->decoderJeton($jeton);
if ($donneesJeton != null && $donneesJeton["sub"] != "") {
// récupération de l'utilisateur
$courriel = $donneesJeton["sub"];
$utilisateur = $this->recupererUtilisateurEnBdd($courriel);
}
}
}
if ($utilisateur != null) {
$utilisateur['session_id'] = session_id();
$utilisateur = $this->completerInfosUtilisateur($utilisateur);
}
return $utilisateur;
}
 
/**
* Essaye de trouver un jeton JWT non vide dans l'entête HTTP "Authorization"
*
* @return String un jeton JWT ou null
*/
protected function lireJetonEntete() {
$jwt = null;
$headers = apache_request_headers();
if (isset($headers["Authorization"]) && ($headers["Authorization"] != "")) {
$jwt = $headers["Authorization"];
}
return $jwt;
}
 
/**
* Vérifie un jeton auprès de l'annuaire
*
* @param String $jeton un jeton JWT
* @return true si le jeton est vérifié, false sinon
*/
protected function verifierJeton($jeton) {
$urlServiceVerification = $this->conteneur->getParametre("urlServiceBaseAuth") . "verifierjeton";
$urlServiceVerification .= "?token=" . $jeton;
 
// file_get_contents râle si le certificat HTTPS est auto-signé
//$retour = file_get_contents($urlServiceVerification);
 
// curl avec les options suivantes ignore le pb de certificat (pour tester en local)
$ch = curl_init();
$timeout = 5;
curl_setopt($ch, CURLOPT_URL, $urlServiceVerification);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_CONNECTTIMEOUT, $timeout);
// équivalent de "-k"
curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, false);
curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false);
$data = curl_exec($ch);
curl_close($ch);
$retour = $data;
 
$retour = json_decode($retour, true);
 
return ($retour === true);
}
 
/**
* Décode un jeton JWT (SSO) précédemment validé et retourne les infos
* qu'il contient (payload / claims)
* @param String $jeton un jeton JWT précédemment validé
*/
protected function decoderJeton($jeton) {
$parts = explode('.', $jeton);
$payload = $parts[1];
$payload = base64_decode($payload);
$payload = json_decode($payload, true);
 
return $payload;
}
 
/**
* Retourne un profil d'utilisateur non connecté (anonyme), avec un identifiant de session
* PHP qui permet de suivre son activité
*/
public function getUtilisateurAnonyme() {
return array(
'connecte' => false,
68,24 → 165,22
);
}
 
protected function identifierUtilisateur($login, $mot_de_passe) {
return $this->recupererUtilisateurEnBdd($login, $mot_de_passe, 'MD5');
}
/**
* Récupère les données d'un utilisateur dans la BDD depuis son login; considère que
* l'utilisateur est légitime car il fournit un jeton SSO vérifié par l'annuaire
*
* @param String $login le courriel de l'utilisateur
* @return array les infos de l'utilisateur
*/
private function recupererUtilisateurEnBdd($login) {
$loginP = $this->bdd->proteger($login);
 
protected function identifierUtilisateurSansEncryptionMotDePasse($login, $mot_de_passe) {
return $this->recupererUtilisateurEnBdd($login, $mot_de_passe);
}
 
private function recupererUtilisateurEnBdd($login, $mot_de_passe, $cryptage = false) {
$loginP = $this->bdd->proteger($login);
$mdpP = $this->bdd->proteger($mot_de_passe);
$mdpSql = $cryptage ? "$cryptage($mdpP)" : $mdpP;
$requete = 'SELECT du.id_utilisateur, nom, prenom, courriel, mot_de_passe, dui.admin '.
$requete = 'SELECT du.id_utilisateur, nom, prenom, courriel, dui.admin '.
'FROM del_utilisateur AS du '.
' LEFT JOIN del_utilisateur_infos AS dui ON (du.id_utilisateur = dui.id_utilisateur) '.
"WHERE courriel = $loginP ".
"AND mot_de_passe = $mdpSql ".
' -- '.__FILE__.' : '.__LINE__;
 
return $this->bdd->recuperer($requete);
}
 
95,32 → 190,6
return $utilisateur;
}
 
protected function poserCookieUtilisateur($utilisateur) {
$this->setPersistentCookie('del_courriel', $utilisateur['courriel'], 1);
$this->setPersistentCookie('del_mot_de_passe', $utilisateur['mot_de_passe'], 1);
}
 
protected function setPersistentCookie($name, $value, $remember = 1) {
setcookie($name, $value, time() + ($remember ? (60*60*24*100) : (60*60)),'/');
}
 
protected function oublierUtilisateur() {
setcookie('del_courriel', $this->contexte->getCookie('del_courriel'), time()-3600, '/');
setcookie('del_mot_de_passe', $this->contexte->getCookie('del_mot_de_passe'), time()-3600, '/');
$this->contexte->setCookie('del_courriel', null);
$this->contexte->setCookie('del_mot_de_passe', null);
}
 
public function etreAdmin() {
$idUtilisateurP = $this->bdd->proteger($this->utilisateur['id_utilisateur']);
$requete = 'SELECT admin '.
'FROM del_utilisateur_infos '.
"WHERE id_utilisateur = $idUtilisateurP ".
' -- '.__FILE__.' : '.__LINE__;
$resultat = $this->bdd->recuperer($requete);
return ($resultat && $resultat['admin'] == 1);
}
protected function getEvenements($id_utilisateur) {
$sql = $this->conteneur->getSql();
135,7 → 204,7
return $evenements;
}
 
public function getDerniereDateConsultationEvenements($id_utilisateur) {
$requete = "SELECT date_derniere_consultation_evenements FROM del_utilisateur_infos ".
"WHERE id_utilisateur = ".$this->bdd->proteger($id_utilisateur);
143,7 → 212,7
$date = !empty($date['date_derniere_consultation_evenements']) ? $date['date_derniere_consultation_evenements'] : "0";
return $date;
}
 
public function setDerniereDateConsultationEvenements($id_utilisateur, $date) {
// Vérification que la ligne correspondant à l'utilisateur dans la table
// infos existe bien (sinon on la crée)
156,12 → 225,12
"WHERE id_utilisateur = ".$this->bdd->proteger($id_utilisateur);
$this->bdd->executer($requete);
}
 
protected function ajouterEvenements(&$utilisateur) {
$evenements = $this->getEvenements($utilisateur['id_utilisateur']);
$utilisateur = array_merge($utilisateur, $evenements);
}
 
public function obtenirPreferencesUtilisateur($id_utilisateur) {
$prefs_utilisateur = $this->obtenirInfosUtilisateur($id_utilisateur);
if (empty($prefs_utilisateur)) {
178,11 → 247,11
return $prefs_utilisateur;
}
 
private function obtenirTableauPreferenceDefaut() {
return array('mail_notification_mes_obs' => '1', 'mail_notification_toutes_obs' => '0');
}
 
private function renvoyerInfosUtilisateurDefaut($id_utilisateur) {
return array('id_utilisateur' => $id_utilisateur,
'admin' => '0',
190,7 → 259,7
'date_premiere_utilisation' => date('Y-m-d H:i:s'),
'date_derniere_consultation_evenements' => '0000-00-00 00:00:00');
}
 
public function obtenirInfosUtilisateur($id_utilisateur) {
$requete = 'SELECT * '.
'FROM del_utilisateur_infos '.
199,7 → 268,7
$prefs_utilisateur = $this->bdd->recuperer($requete);
return $prefs_utilisateur;
}
 
public function initialiserInfosUtilisateur($id_utilisateur) {
$preferences_defaut = $this->obtenirTableauPreferenceDefaut();
$prefsEncodeesP = $this->bdd->proteger(json_encode($preferences_defaut));
211,4 → 280,41
' -- '.__FILE__.' : '.__LINE__;
return $this->bdd->executer($requete);
}
 
/**
* Vérifie qu'un utilisateur connu est identifié (mode non anonyme) et
* que son identifiant numérique est égal à $id_utilisateur; si non,
* retourne une erreur HTTP 401 et quitte le programme
*
* @param integer $id_utilisateur l'utilisateur attendu
*/
public function controleUtilisateurIdentifie($id_utilisateur) {
$ok = ($this->utilisateur['connecte'] === true && $this->utilisateur['id_utilisateur'] == $id_utilisateur);
if (! $ok) {
$message = "";
if ($this->utilisateur['connecte'] === true) {
$message = "Vous n'êtes pas propriétaire de la ressource demandée";
} else {
$message = "Vous n'êtes pas identifié";
}
$code = RestServeur::HTTP_CODE_ACCES_NON_AUTORISE;
throw new Exception($message, $code);
}
}
 
// rétrocompat'
public function etreAdmin() {
return ($this->utilisateur['admin'] == 1);
}
 
// rétrocompat'
public function etreUtilisateurAvecDroitAdmin() {
$etreAdmin = $this->etreAdmin();
if (! $etreAdmin) {
$message = "Vous ne pouvez pas accéder à ce service car vous n'avez pas les droits d'administrateur !\n";
$code = RestServeur::HTTP_CODE_ACCES_NON_AUTORISE;
throw new Exception($message, $code);
}
return $etreAdmin;
}
}
/trunk/services/bibliotheque/ControleAcces.php
1,11 → 1,12
<?php
// declare(encoding='UTF-8');
/**
* Classe de controle d'accès aux services de DEL.
* Classe de controle d'accès HTTP AUTH aux services de DEL, à n'utiliser
* que dans ce cas (HTTP AUTH), et pas dans le cas de l'identification générale sur le SSO
*
* Cette classe propose des méthodes permettant :
* - l'authentification http pour bloquer ou autoriser l'accès
* - de déterminer les droits des utilisateurs
* - l'authentification HTTP pour bloquer ou autoriser l'accès
* - de déterminer le statut d'admin des utilisateurs
*
* @category DEL
* @package Services
20,8 → 21,8
*/
class ControleAcces {
 
private $conteneur;
private $bdd;
protected $conteneur;
protected $bdd;
 
public function __construct($conteneur) {
$this->conteneur = $conteneur;
28,6 → 29,11
$this->bdd = $this->conteneur->getBdd();
}
 
/**
* Vérifie que l'IP du client est dans la liste "ip_autorisees" de la config
* @throws Exception
* @return boolean
*/
public function controlerIpAutorisees() {
$ipsAutorisees = $this->conteneur->getParametreTableau('ip_autorisees');
 
44,6 → 50,9
return true;
}
 
/**
* Exige qu'un administrateur s'autenthentifie à l'aide de HTTP AUTH
*/
public function demanderAuthentificationAdmin() {
if (!$this->etreAdminAutoriseParHttp()) {
$this->authentifierAdmin();
50,6 → 59,9
}
}
 
/**
* Exige qu'un utilisateur s'autenthentifie à l'aide de HTTP AUTH
*/
public function demanderAuthentificationUtilisateur() {
if (!$this->etreUtilisateurAutoriseParHttp()) {
$this->authentifierUtilisateur();
56,66 → 68,61
}
}
 
private function etreUtilisateurAutoriseParHttp() {
/**
* Lit les entêtes HTTP AUTH et vérifie si l'utilisateur
* existe (courriel / mot de passe); si $doitEtreAdmin est true,
* vérifiera également que l'utilisateur est administrateur de Del
*
* @return boolean true si l'utilisateur est identifié, false sinon
*/
protected function etreUtilisateurAutoriseParHttp($doitEtreAdmin=false) {
$identifiant = $this->getAuthIdentifiant();
$mdp = $this->getAuthMotDePasse();
$existe = $this->obtenirUtilisateur($identifiant, $mdp);
 
$autorisation = (isset($existe) && $existe) ? true :false;
return $autorisation;
}
$autorisation = (isset($existe) && $existe) ? true :false; // c'est quoi ces tests de clodos ??
 
private function obtenirUtilisateur($login, $motDePasse) {
$login = $this->bdd->proteger($login);
$motDePasse = $this->bdd->proteger($motDePasse);
$requete = 'SELECT id_utilisateur, nom, prenom, courriel, mot_de_passe '.
'FROM del_utilisateur AS du '.
"WHERE courriel = $login ".
" AND mot_de_passe = MD5($motDePasse) ".
' -- '.__FILE__.':'.__LINE__."\n";
$utilisateur = $this->bdd->recuperer($requete);
return $utilisateur;
}
 
private function etreAdminAutoriseParHttp() {
$identifiant = $this->getAuthIdentifiant();
$autorisation = ($this->etreAdmin($identifiant) && $this->etreUtilisateurAutorise()) ? true : false;
if ($doitEtreAdmin === true) {
$autorisation = ($autorisation && $this->etreAdmin($identifiant));
}
return $autorisation;
}
 
private function etreAdmin($courriel) {
$courriel = $this->bdd->proteger($courriel);
$requete = 'SELECT dui.admin '.
'FROM del_utilisateur AS du LEFT JOIN del_user_infos AS dui ON (du.id_utilisateur = dui.id_utilisateur) '.
"WHERE du.courriel = $courriel ".
' -- '.__FILE__.':'.__LINE__."\n";
$infoUtilisateur = $this->bdd->recuperer($requete);
 
$etreAdmin = $this->verifierDroitAdmin($infoUtilisateur['admin']);
return $etreAdmin;
/**
* Lit les entêtes HTTP AUTH et vérifie que l'utilisateur est identifié
* et est administrateur de Del
*
* @return boolean true si l'utilisateur est identifié et admin de Del, false sinon
*/
protected function etreAdminAutoriseParHttp() {
return $this->etreUtilisateurAutoriseParHttp(true);
}
 
private function verifierDroitAdmin($droit) {
$droitAdmin = $this->conteneur->getParametre('droit_superadmin');
$etreAdmin = false;
if (isset($droit) && $droit == $droitAdmin) {
$etreAdmin = true;
}
return $etreAdmin;
}
 
private function getAuthIdentifiant() {
/**
* Lit l'identifiant utilisateur dans les entêtes HTTP AUTH
* @return String l'identifiant utilisateur ou null
*/
protected function getAuthIdentifiant() {
$id = (isset($_SERVER['PHP_AUTH_USER'])) ? $_SERVER['PHP_AUTH_USER'] : null;
return $id;
}
 
private function getAuthMotDePasse() {
/**
* Lit le mot de passe dans les entêtes HTTP AUTH
* @return String le mot de passe ou null
*/
protected function getAuthMotDePasse() {
$mdp = (isset($_SERVER['PHP_AUTH_PW'])) ? $_SERVER['PHP_AUTH_PW'] : null;
return $mdp;
}
 
//TODO: externaliser noms et adresses spécifiques à Tela Botanica
private function authentifierAdmin() {
/**
* Envoie un message HTTP 401 / une boîte de login HTTP AUTH avec des
* messages correspondant à la demande d'authentification d'un administrateur
* TODO: externaliser noms et adresses spécifiques à Tela Botanica
* @return boolean
*/
protected function authentifierAdmin() {
$message_accueil = "Veuillez vous identifier avec votre compte administrateur Tela Botanica.";
$message_echec = "Accès limité aux administrateurs de DEL.\n".
"Votre tentative d'identification a échoué.\n".
123,7 → 130,13
return $this->authentifier($message_accueil, $message_echec, 'Admin');
}
 
private function authentifierUtilisateur() {
/**
* Envoie un message HTTP 401 / une boîte de login HTTP AUTH avec des
* messages correspondant à la demande d'authentification d'un utilisateur
* TODO: externaliser noms et adresses spécifiques à Tela Botanica
* @return boolean
*/
protected function authentifierUtilisateur() {
$message_accueil = "Veuillez vous identifier avec votre compte Tela Botanica.";
$message_echec = "Accès limité aux utilisateurs de DEL.\n".
"Inscrivez vous http://www.tela-botanica.org/page:inscription pour le devenir.\n".
132,7 → 145,11
return $this->authentifier($message_accueil, $message_echec, 'Utilisateur');
}
 
private function authentifier($message_accueil, $message_echec, $type) {
/**
* Envoie l'authentification HTTP AUTH , et accepte un mode "debug" pour
* les petits malins
*/
protected function authentifier($message_accueil, $message_echec, $type) {
$id = $this->getAuthIdentifiant();
if (!isset($id)) {
$this->envoyerAuth($message_accueil, $message_echec);
150,54 → 167,68
return true;
}
 
public function etreUtilisateurAvecDroitAdmin() {
$infos = $this->getInfosUtilisateurConnecte();
 
$etreAdmin = false;
if (isset($infos['admin'])) {
$etreAdmin = $this->verifierDroitAdmin($infos['admin']);
}
 
if ($etreAdmin == false) {
$message = "Vous ne pouvez pas accéder à ce service car vous n'avez pas les droits d'administrateur !\n";
$code = RestServeur::HTTP_CODE_ACCES_NON_AUTORISE;
throw new Exception($message, $code);
}
return $etreAdmin;
/**
* Envoie un message HTTP 401 / une boîte de login HTTP AUTH
* @param string $message_accueil
* @param string $message_echec
*/
private function envoyerAuth($message_accueil, $message_echec) {
header('HTTP/1.0 401 Unauthorized');
header('WWW-Authenticate: realm="'.mb_convert_encoding($message_accueil, 'ISO-8859-1', 'UTF-8').'"');
header('Content-type: text/plain; charset=UTF-8');
print $message_echec;
exit(0);
}
 
public function getInfosUtilisateurConnecte() {
$utilisateur = array();
if (isset($_COOKIE['del_courriel'])) {
$courriel = $_COOKIE['del_courriel'];
$motDePasse = $_COOKIE['del_mot_de_passe'];
$utilisateur = $this->obtenirUtilisateurSansEncryptionMdp($courriel, $motDePasse);
}
return $utilisateur;
}
 
private function obtenirUtilisateurSansEncryptionMdp($login, $motDePasseEncrypte) {
/**
* Authentifie et récupère un utilisateur directement depuis la table des
* utilisateurs Del, utile pour l'authentification HTTP AUTH - ne pas
* utiliser pour les services Del qui doivent être branchés au SSO
*/
protected function obtenirUtilisateur($login, $motDePasse) {
$login = $this->bdd->proteger($login);
$motDePasseEncrypte = $this->bdd->proteger($motDePasseEncrypte);
$requete = 'SELECT du.*, admin, preferences, date_premiere_utilisation '.
$motDePasse = $this->bdd->proteger($motDePasse);
$requete = 'SELECT id_utilisateur, nom, prenom, courriel, mot_de_passe '.
'FROM del_utilisateur AS du '.
' LEFT JOIN del_utilisateur_infos AS dui ON (du.id_utilisateur = dui.id_utilisateur) '.
"WHERE du.courriel = $login ".
" AND du.mot_de_passe = $motDePasseEncrypte ".
"WHERE courriel = $login ".
" AND mot_de_passe = MD5($motDePasse) ".
' -- '.__FILE__.':'.__LINE__."\n";
$utilisateur = $this->bdd->recuperer($requete);
return $utilisateur;
}
 
public function getIdAnonymeTemporaire() {
$this->demarrerSession();
return session_id();
/**
* Vérifie dans la table des utilisateurs Del qu'un utilisateur
* (identifié par son courriel) est administrateur de Del
*
* @param string $courriel
* @return boolean true si l'utilisateur est administrateur de Del, false sinon
*/
protected function etreAdmin($courriel) {
$courriel = $this->bdd->proteger($courriel);
$requete = 'SELECT dui.admin '.
'FROM del_utilisateur AS du LEFT JOIN del_user_infos AS dui ON (du.id_utilisateur = dui.id_utilisateur) '.
"WHERE du.courriel = $courriel ".
' -- '.__FILE__.':'.__LINE__."\n";
$infoUtilisateur = $this->bdd->recuperer($requete);
$etreAdmin = $this->verifierDroitAdmin($infoUtilisateur['admin']);
return $etreAdmin;
}
 
private function demarrerSession() {
if (session_id() == '') {
// TODO : modifier ce test lors du passage en php 5.4
session_start();
/**
* Vérifie que la valeur "admin" d'un profil utilisateur correspond à la valeur
* attendue dans la config
*
* @return true si sébon, false si sépabon
*/
protected function verifierDroitAdmin($droit) {
$droitAdmin = $this->conteneur->getParametre('droit_superadmin');
$etreAdmin = false;
if (isset($droit) && $droit == $droitAdmin) {
$etreAdmin = true;
}
return $etreAdmin;
}
 
}
/trunk/src/org/tela_botanica/del/client/utils/UtilitairesServiceResultat.java
12,6 → 12,7
import org.tela_botanica.del.client.config.Config;
import org.tela_botanica.del.client.i18n.I18n;
import org.tela_botanica.del.client.modeles.ActiviteUtilisateur;
import org.tela_botanica.del.client.modeles.AuthInfo;
import org.tela_botanica.del.client.modeles.Commentaire;
import org.tela_botanica.del.client.modeles.Contributeur;
import org.tela_botanica.del.client.modeles.EvenementObs;
29,12 → 30,14
import org.tela_botanica.del.client.modeles.VoteProtocole;
 
import com.google.gwt.core.shared.GWT;
import com.google.gwt.user.client.Window;
import com.google.gwt.i18n.client.DateTimeFormat;
import com.google.gwt.json.client.JSONArray;
import com.google.gwt.json.client.JSONNumber;
import com.google.gwt.json.client.JSONObject;
import com.google.gwt.json.client.JSONParser;
import com.google.gwt.json.client.JSONString;
import com.google.gwt.json.client.JSONValue;
import com.google.gwt.user.client.Window;
 
/**
* Centralisation des methodes de parsing du code JSON retourné par les
491,7 → 494,6
String courrielUtilisateur = utilisateurJson.get("courriel").isString().stringValue();
String nomUtilisateur = utilisateurJson.get("nom").isString().stringValue();
String prenomUtilisateur = utilisateurJson.get("prenom").isString().stringValue();
String mdpHashUtilisateur = utilisateurJson.get("mot_de_passe").isString().stringValue();
String adminNiveau = "";
if (utilisateurJson.get("admin").isString() != null) {
502,7 → 504,7
String dateDerniereConsultationEvts = utilisateurJson.get("date_derniere_consultation_evenements").isString().stringValue();
 
utilisateur = new Utilisateur(sessionId, idUtilisateur, prenomUtilisateur, nomUtilisateur,
courrielUtilisateur, mdpHashUtilisateur, adminNiveau);
courrielUtilisateur, adminNiveau);
ActiviteUtilisateur activite = new ActiviteUtilisateur();
activite.setNbEvenements(nbEvtsUtilisateur);
514,6 → 516,61
}
return utilisateur;
}
 
/**
* Recupere des informations d'authentification à partir du JSON renvoyé par les
* services Auth de l'annuaire (SSO)
*
* @param valeurJson
* @return AuthInfo
*/
public static AuthInfo parserAuthJson(JSONValue valeurJson) {
AuthInfo authInfo = new AuthInfo();
JSONObject authJson = valeurJson.isObject();
 
JSONValue erreurJSON = authJson.get("error");
// test si erreur
if (erreurJSON != null) {
JSONString erreur = erreurJSON.isString();
if (erreur != null) {
authInfo.error = erreur.stringValue();
} else {
authInfo.error = "erreur d'authentification";
}
} else {
boolean session = authJson.get("session").isBoolean().booleanValue();
authInfo.session = session;
// test si session ouverte
if (session) {
JSONValue tokenJson = authJson.get("token");
String token = null;
// protection paranoïaque
if (tokenJson != null) {
JSONString tokenString = tokenJson.isString();
if (tokenString != null) {
token = tokenString.stringValue();
}
}
String tokenId = authJson.get("token_id").isString().stringValue();
int duration = (int) authJson.get("duration").isNumber().doubleValue();
JSONValue lastModifJson = authJson.get("last_modif");
 
authInfo.token = token;
authInfo.tokenId = tokenId;
authInfo.duration = duration;
// test si lastModif est null
if (lastModifJson != null) {
JSONNumber lastModif = lastModifJson.isNumber();
if (lastModif != null) {
authInfo.lastModif = (int) lastModif.doubleValue();
}
}
}
}
//GWT.log(valeurJson.toString());
return authInfo;
}
/**
* Recupere un utilisateur à partir du JSON
/trunk/src/org/tela_botanica/del/client/services/RequestBuilderWithCredentials.java
1,5 → 1,7
package org.tela_botanica.del.client.services;
 
import org.tela_botanica.del.client.modeles.Utilisateur;
 
import com.google.gwt.http.client.RequestBuilder;
 
public class RequestBuilderWithCredentials extends RequestBuilder {
6,6 → 8,9
 
public RequestBuilderWithCredentials(Method httpMethod, String url) {
super(httpMethod, url);
if(Utilisateur.getJeton() != null && ! Utilisateur.getJeton().isEmpty()) {
this.setHeader("Authorization", Utilisateur.getJeton());
}
this.setIncludeCredentials(true);
}
}
/trunk/src/org/tela_botanica/del/client/services/rest/async/AuthCallback.java
New file
0,0 → 1,20
package org.tela_botanica.del.client.services.rest.async;
 
import org.tela_botanica.del.client.modeles.AuthInfo;
import org.tela_botanica.del.client.utils.UtilitairesServiceResultat;
 
import com.google.gwt.json.client.JSONParser;
import com.google.gwt.user.client.Window;
 
/**
* Retour des services annuaire:auth : connexion, deconnexion, identite - un jeton
* JWT si identifié, false sinon
*/
public abstract class AuthCallback extends PHPCallback<AuthInfo> {
 
@Override
public AuthInfo parserJSON(String retourService) {
AuthInfo authInfo = UtilitairesServiceResultat.parserAuthJson(JSONParser.parseStrict(retourService));
return authInfo;
}
}
/trunk/src/org/tela_botanica/del/client/services/rest/async/UtilisateurCallback.java
4,6 → 4,7
import org.tela_botanica.del.client.utils.UtilitairesServiceResultat;
 
import com.google.gwt.json.client.JSONParser;
import com.google.gwt.user.client.Window;
 
/**
* Objet passé en paramètre d'un service de recuperation d'un utilisateur
14,7 → 15,9
 
@Override
public Utilisateur parserJSON(String retourService) {
return UtilitairesServiceResultat.parserUtilisateurJson(JSONParser.parseStrict(retourService));
Utilisateur util = UtilitairesServiceResultat.parserUtilisateurJson(JSONParser.parseStrict(retourService));
return util;
}
 
}
/trunk/src/org/tela_botanica/del/client/services/rest/async/PHPCallback.java
29,6 → 29,7
protected ModeRequete mode;
 
public PHPCallback() {
this.mode = ModeRequete.LECTURE;
}
 
public void setMode(ModeRequete mode) {
56,10 → 57,10
codeAttendu = Arrays.asList(500);
break;
}
GWT.log("Codes attendus:"+codeAttendu.toString());
GWT.log("Code:"+statusCode);
if (codeAttendu.contains(statusCode)) {
GWT.log("Code: OK");
//GWT.log("Codes attendus:"+codeAttendu.toString());
//GWT.log("Code:"+statusCode);
if (codeAttendu != null && codeAttendu.contains(statusCode)) {
//GWT.log("Code: OK");
try {
T reponseParsee = parserJSON(response.getText());
surRetour(reponseParsee);
/trunk/src/org/tela_botanica/del/client/services/rest/UtilisateurServiceConcret.java
1,15 → 1,21
package org.tela_botanica.del.client.services.rest;
 
import org.tela_botanica.del.client.config.Config;
import org.tela_botanica.del.client.modeles.AuthInfo;
import org.tela_botanica.del.client.modeles.Utilisateur;
import org.tela_botanica.del.client.services.rest.async.ActiviteUtilisateurCallback;
import org.tela_botanica.del.client.services.rest.async.AuthCallback;
import org.tela_botanica.del.client.services.rest.async.UtilisateurCallback;
import org.tela_botanica.del.client.services.rest.async.PHPCallback.ModeRequete;
 
import org.tela_botanica.del.client.services.RequestBuilderWithCredentials;
 
import com.google.gwt.core.shared.GWT;
import com.google.gwt.user.client.Window;
 
public class UtilisateurServiceConcret implements UtilisateurService {
private String baseUrl;
private String authBaseUrl;
public UtilisateurServiceConcret() {
this(new Config());
17,34 → 23,110
public UtilisateurServiceConcret(Config config) {
this.baseUrl = config.getUrl("serviceUtilisateursBaseUrl");
this.authBaseUrl = config.getUrl("serviceAuthBaseUrl");
}
 
/**
* Connecte l'utilisateur en appelant l'annuaire (auth::connexion, SSO), puis enchaîne avec
* le service "utilisateur" de Del, pour retourner les infos requises par l'interface
*/
@Override
public void connecterUtilisateur(String login, String motDePasse, UtilisateurCallback callback) {
RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.GET, baseUrl + "utilisateurs/" + login + "/" + motDePasse);
callback.setMode(ModeRequete.LECTURE);
public void connecterUtilisateur(String login, String motDePasse, final UtilisateurCallback callback) {
RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.GET, authBaseUrl + "connexion?login=" + login + "&password=" + motDePasse);
try {
rb.sendRequest(null, callback);
// Callback intermédiaire qui lit les infos de l'annuaire et appelle le service de préférences
rb.sendRequest(null, new AuthCallback() {
public void surErreur(String message) {
// merci, de rien, au revoir messieurs-dames
callback.surErreur("");
}
@Override
public void surRetour(AuthInfo objetRetour) {
// Stockage du jeton
Utilisateur.setJeton(objetRetour.token);
// Obtention de l'utilisateur final d'après le service de préférences
obtenirUtilisateurSansAnnuaire(callback); // RequestBulledair passe le jeton dans les headers HTTP
}
});
} catch (Exception e) {
// TODO: handle exception
Window.alert("Exception : " + e.getMessage());
}
}
 
/**
* Déconnecte l'utilisateur en appelant l'annuaire (auth::deconnexion, SSO), puis enchaîne avec
* le service "utilisateur" de Del, pour retourner les infos requises par l'interface
*/
@Override
public void deconnecterUtilisateur(UtilisateurCallback callback) {
RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.GET, baseUrl + "utilisateurs/deconnecter");
callback.setMode(ModeRequete.LECTURE);
public void deconnecterUtilisateur(final UtilisateurCallback callback) {
RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.GET, authBaseUrl + "deconnexion");
try {
rb.sendRequest(null, callback);
// Callback intermédiaire qui lit les infos de l'annuaire et appelle le service de préférences
rb.sendRequest(null, new AuthCallback() {
public void surErreur(String message) {
callback.surErreur("");
}
@Override
public void surRetour(AuthInfo objetRetour) {
// Stockage du jeton, qui devrait être NULL (mais on sait jamais à l'avenir)
Utilisateur.setJeton(objetRetour.token);
// Obtention du pseudo-utilisateur non connecté (id de session) d'après le service de préférences
obtenirUtilisateurSansAnnuaire(callback);
}
});
} catch (Exception e) {
// TODO: handle exception
GWT.log("Exception : " + e.getMessage());
}
}
 
/**
* Va chercher les infos de l'utilisateur en vérifiant d'abord l'identité auprès de l'annuaire
* @param callback
*/
@Override
public void obtenirUtilisateur(UtilisateurCallback callback) {
obtenirUtilisateur(callback, false);
}
 
/**
* Va chercher les infos de l'utilisateur; si ignorerAnnuaire est false, vérifiera d'abord
* l'identité auprès de l'annuaire (service annuaire:auth/identite)
* @param callback
*/
@Override
public void obtenirUtilisateur(final UtilisateurCallback callback, boolean ignorerAnnuaire) {
// par défaut, on appelle d'abord le service auth/identite de l'annuaire, afin de connaître
// le statut de l'utilisateur vis à vis du SSO (connecté ou non) et rafraîchir le jeton
if (! ignorerAnnuaire) {
RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.GET, authBaseUrl + "identite");
try {
rb.sendRequest(null, new AuthCallback() {
public void surErreur(String message) {
// Même si l'annuaire n'est pas content, on va chercher un profil utilisateur "anonyme"
obtenirUtilisateurSansAnnuaire(callback);
}
@Override
public void surRetour(AuthInfo objetRetour) {
// Stockage du jeton rafraîchi
Utilisateur.setJeton(objetRetour.token);
// Obtention de l'utilisateur final d'après le service de préférences
obtenirUtilisateurSansAnnuaire(callback);
}
});
} catch (Exception e) {
// TODO: handle exception
}
} else { // sinon on optimise, quand on vient de se (de)connecter, pas la peine de rappeler l'annuaire
obtenirUtilisateurSansAnnuaire(callback);
}
}
 
/**
* Va chercher les infos de l'utilisateur sans vérifier l'identité auprès de l'annuaire
* @param callback
*/
public void obtenirUtilisateurSansAnnuaire(UtilisateurCallback callback) {
RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.GET, baseUrl + "utilisateurs/");
callback.setMode(ModeRequete.LECTURE);
try {
rb.sendRequest(null, callback);
} catch (Exception e) {
55,7 → 137,6
@Override
public void obtenirActiviteUtilisateur(String idUtilisateur, ActiviteUtilisateurCallback callback) {
RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.GET, baseUrl + "utilisateurs/"+idUtilisateur+"/activite");
callback.setMode(ModeRequete.LECTURE);
try {
rb.sendRequest(null, callback);
} catch (Exception e) {
/trunk/src/org/tela_botanica/del/client/services/rest/UtilisateurService.java
8,5 → 8,6
public void connecterUtilisateur(String login, String motDePasse, UtilisateurCallback callback);
public void deconnecterUtilisateur(UtilisateurCallback callback);
public void obtenirUtilisateur(UtilisateurCallback callback);
public void obtenirUtilisateur(UtilisateurCallback callback, boolean ignorerAnnuaire);
public void obtenirActiviteUtilisateur(String idUtilisateur, ActiviteUtilisateurCallback callback);
}
/trunk/src/org/tela_botanica/del/client/config/Config.java
46,6 → 46,7
urls.put("profil", configuration.get("profilUrl"));
urls.put("images", configuration.get("imagesUrl"));
urls.put("serviceUtilisateursBaseUrl", configuration.get("serviceUtilisateursBaseUrl"));
urls.put("serviceAuthBaseUrl", configuration.get("serviceAuthBaseUrl"));
 
infos.put("popupOptions", "menubar=yes,location=yes,resizable=yes,scrollbars=yes,status=yes");
}
/trunk/src/org/tela_botanica/del/client/composants/formulaires/identification/identification.css
52,7 → 52,7
.erreur {
color: red;
position:absolute;
margin-top:13px;
margin-top:7px;
}
 
.boutonOK {
/trunk/src/org/tela_botanica/del/client/modeles/AuthInfo.java
New file
0,0 → 1,30
package org.tela_botanica.del.client.modeles;
 
/**
* Une mini classe pour stocker facilement le retour d'un appel aux services
* annuaire:auth (connexion, deconnexion, identite)
*
* @author mathias
*/
public class AuthInfo {
 
public String token;
public boolean session;
public String tokenId;
public int duration;
public Integer lastModif; // Integer pour pouvoir mettre null dedans
public String error;
 
public AuthInfo(String token, boolean session, String tokenId, int duration, Integer lastModif, String error) {
this.token = token;
this.session = session;
this.tokenId = tokenId;
this.duration = duration;
this.lastModif = lastModif;
this.error = error;
}
 
public AuthInfo() {
this(null, false, null, 0, null, null);
}
}
/trunk/src/org/tela_botanica/del/client/modeles/Utilisateur.java
13,7 → 13,6
private String nom = "";
private String prenom = "";
private String courriel = "";
private String motDePasseHash = "";
private String id = "0";
private String sessionId = "";
private String adminNiveau = "0";
22,31 → 21,24
// TODO: avoir une liste d'activités avec des types différents
private ActiviteUtilisateur activiteUtilisateur = new ActiviteUtilisateur();
 
// Jeton encodé en base64 passé de manière automatique aux services dans un header
private static String jeton = "";
 
public Utilisateur(String sessionId, String id) {
this.id = id;
this.sessionId = sessionId;
}
public Utilisateur(String sessionId, String id, String prenom, String nom, String courriel,
String motDePasseHash, String adminNiveau) {
public Utilisateur(String sessionId, String id, String prenom, String nom, String courriel, String adminNiveau) {
this(sessionId, id);
this.prenom = prenom;
this.nom = nom;
this.courriel = courriel;
this.motDePasseHash = motDePasseHash;
this.adminNiveau = adminNiveau;
identifie = true;
}
public String getMotDePasseHash() {
return motDePasseHash;
}
public void setMotDePasseHash(String motDePasseHash) {
this.motDePasseHash = motDePasseHash;
}
public String getNom() {
return nom;
}
99,7 → 91,7
}
public String toString() {
String utilisateur = id + "\n" + nom + "\n" + prenom + "\n" + courriel + "\n" + motDePasseHash + "\n" +
String utilisateur = id + "\n" + nom + "\n" + prenom + "\n" + courriel + "\n" +
sessionId + "\n" + adminNiveau + "\n";
return utilisateur;
}
111,4 → 103,12
public ActiviteUtilisateur getActivite() {
return this.activiteUtilisateur;
}
 
public static String getJeton() {
return jeton;
}
 
public static void setJeton(String jeton) {
Utilisateur.jeton = jeton;
}
}
/trunk/war/config/config.defaut.js
1,6 → 1,7
var configuration = {
serviceBaseUrl:"http://www.tela-botanica.org/eflore-test/del/services/0.1/",
serviceUtilisateursBaseUrl:"http://api-test.tela-botanica.org/service:del:0.1/",
serviceAuthBaseUrl:"https://www.tela-botanica.org/service:annuaire:auth/",
bogueUrl:"http://www.tela-botanica.net/suivi/index.php?project=41",
commentaireUrl:"http://www.tela-botanica.org/wikini/eflore-test/wakka.php?wiki=AideDelCommentaire",
delUrl:"http://www.tela-botanica.org/appli:del",