/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/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/modules/0.1/utilisateurs/Connecter.php |
---|
File deleted |
\ No newline at end of file |
/trunk/services/modules/0.1/utilisateurs/Deconnecter.php |
---|
File deleted |
\ No newline at end of file |
/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']; |
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/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 |
* */ |
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/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,17 → 107,18 |
} |
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(); |
$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 |
// 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 '. |
$this->sql->getJoin(). |
163,9 → 164,8 |
} |
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/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(); |
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; |
if ($doitEtreAdmin === true) { |
$autorisation = ($autorisation && $this->etreAdmin($identifiant)); |
} |
private function etreAdminAutoriseParHttp() { |
$identifiant = $this->getAuthIdentifiant(); |
$autorisation = ($this->etreAdmin($identifiant) && $this->etreUtilisateurAutorise()) ? true : false; |
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']); |
/** |
* 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); |
} |
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; |
} |
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); |
516,6 → 518,61 |
} |
/** |
* 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 |
* |
* @param imageJson |
/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/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/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/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"; |
23,30 → 22,23 |
// 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", |