Subversion Repositories eFlore/Applications.del

package org.tela_botanica.del.client.services.rest;

import org.tela_botanica.del.client.Del;

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 org.tela_botanica.del.client.utils.StringUtils;

import com.google.gwt.core.shared.GWT;

import com.google.gwt.user.client.Window;

import com.google.gwt.user.client.Timer;

public class UtilisateurServiceConcret implements UtilisateurService {

	private String baseUrl;

	private String authBaseUrl;

	private static Timer rafraichisseurJeton = null;

	public UtilisateurServiceConcret() {

		this(new Config());

	}

	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, final UtilisateurCallback callback) {

		RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.GET, authBaseUrl + "connexion?login=" + login + "&password=" + motDePasse);

		try {

			// 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) {

					gererRetourAuthInfo(objetRetour, callback);

				}

			});

		} catch (Exception e) {

			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(final UtilisateurCallback callback) {

		RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.GET, authBaseUrl + "deconnexion");

		try {

			// 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) {

					gererRetourAuthInfo(objetRetour, callback);

				}

			});

		} catch (Exception e) {

			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) {

			// ne transmet pas le header Authorization, sans quoi l'annuaire rafraîchit le

			// jeton mis en cache et on ne peut pas se déconnecter depuis une autre application

			RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.GET, authBaseUrl + "identite", false);

			try {

				rb.sendRequest(null, new AuthCallback() {

					public void surErreur(String message) {

						// Si l'annuaire n'est pas content (déconnecté depuis ailleurs ou jeton expiré), on va

						// chercher un profil utilisateur "anonyme" et on déconnecte dans l'interface

						gererRetourAuthInfo(new AuthInfo(), callback);

					}

					@Override

					public void surRetour(AuthInfo objetRetour) {

						gererRetourAuthInfo(objetRetour, 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/");

		try {

			rb.sendRequest(null, callback);

		} catch (Exception e) {

			// TODO: handle exception

		}

	}

	@Override

	public void obtenirActiviteUtilisateur(String idUtilisateur, ActiviteUtilisateurCallback callback) {

		RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.GET, baseUrl + "utilisateurs/"+idUtilisateur+"/activite");

		try {

			rb.sendRequest(null, callback);

		} catch (Exception e) {

			// TODO: handle exception

		}

	}

	/**

	 * Enregistre le jeton (potentiellement NULL), sa durée de vie, et appelle

	 * le service Del pour obtenir le profil utilisateur associé; lorsque le jeton

	 * n'est pas nul et que sa durée de vie est spécifiée, déclenche un rafraîchissement

	 * périodique du jeton

	 *

	 * @param objetRetour le retour de l'appel au service annuaire:auth (connexion, deconnexion ou identite)

	 * @param callback

	 */

	protected void gererRetourAuthInfo(AuthInfo objetRetour, final UtilisateurCallback callback) {

		// Stockage du jeton rafraîchi et de sa durée (pourrait avoir changé)

		Utilisateur.setJeton(objetRetour.token);

		Utilisateur.setDureeJeton(objetRetour.duration);

		// Rafraîchissement automatique du jeton - s'annule lorsque le jeton devient nul

		if (Utilisateur.getJeton() != null && Utilisateur.getDureeJeton() > 0) {

			if (rafraichisseurJeton == null) { // on sait jamais

				// 3/4 de la durée de vie du jeton, en millisecondes (ça laisse de la marge)

				int delaiRepetition = (Utilisateur.getDureeJeton() * 1000) * 3 / 4;

				rafraichisseurJeton = new Timer() {

					@Override

					public void run() {

						// Appel de l'annuaire pour rafraîchir le jeton et mettre à jour les

						// données utilisateur si besoin

						obtenirUtilisateur(callback);

					}

				};

				rafraichisseurJeton.scheduleRepeating(delaiRepetition);

			}

		} else {

			if (rafraichisseurJeton != null) { // on sait jamais non plus

				rafraichisseurJeton.cancel();

				rafraichisseurJeton = null;

			}

		}

		// Obtention de l'utilisateur final d'après le service de préférences

		obtenirUtilisateurSansAnnuaire(callback);

	}

}