WebSVN – eFlore/Applications.coel – Diff – /trunk/src/org/tela_botanica/client/modeles/UtilisateurAsyncDao.java


package org.tela_botanica.client.modeles;
 
import java.util.HashMap;
 
import org.tela_botanica.client.Coel;
import org.tela_botanica.client.RegistreId;
import org.tela_botanica.client.http.JsonRestRequestBuilder;
import org.tela_botanica.client.http.JsonRestRequestCallback;
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.util.UtilDAO;
 
import com.extjs.gxt.ui.client.Registry;
import com.google.gwt.http.client.Request;
import com.google.gwt.http.client.Response;
import com.google.gwt.json.client.JSONArray;
import com.google.gwt.json.client.JSONBoolean;
import com.google.gwt.json.client.JSONNumber;
import com.google.gwt.json.client.JSONObject;
import com.google.gwt.json.client.JSONString;
import com.google.gwt.json.client.JSONValue;
import com.google.gwt.user.client.Timer;
 
/**
 * Modele DAO, specifique, permettant la validation, l'acces aux donnees distantes et la présentation des donnees en retour
 * 
 */
public class UtilisateurAsyncDao {
	private static final String SERVICE_NOM = "CoelUtilisateur";
	
	private Utilisateur utilisateur = null;
	private Rafraichissable vueARafraichir = null;
 
	private static Timer rafraichisseurJeton = null;
	
	/**
	 * Constructeur
	 * @param retour : méthode appellée en retour d'appel. 
	 */
	public UtilisateurAsyncDao(Rafraichissable vueARafraichirCourrante) {
		vueARafraichir = vueARafraichirCourrante;
		utilisateur = (Utilisateur) Registry.get(RegistreId.UTILISATEUR_COURANT);
	}
 
	/**
	 * 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();
					}
				}
			}
		}
		
		return authInfo;
	}
 
	/**
	 * Enregistre le jeton (potentiellement NULL), sa durée de vie; appelle le service Coel pour
	 * obtenir les données de l'utilisateur relatives à l'application; 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)
	 */
	protected void gererRetourAuthInfo(AuthInfo objetRetour) {
		// 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;
				//delaiRepetition = 10000; // debug
				rafraichisseurJeton = new Timer() {
					@Override
					public void run() {
						//Coel.LogVersFirebug("rafraichir utilisateur");
						// Appel de l'annuaire pour rafraîchir le jeton (cb nul pour l'instant)
						getEtatUtilisateur();
					}
				};
				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
		//Coel.LogVersFirebug("va chercher utilisateur Coel");
		getEtatUtilisateurSansAnnuaire();
	}
 
	/**
	 * Méthode déconnectant un utilisateur de l'application. 
	 * @param identifiant de l'utilisateur à déconnecter.
	 */
	public void deconnecterUtilisateur() {
		//Coel.LogVersFirebug("deconnexion");
		final JsonRestRequestBuilder rb = UtilDAO.construireRequeteAuth("deconnexion", null);
		rb.envoyerRequete(null, new JsonRestRequestCallback() {
			@Override
			public void surReponse(JSONValue responseValue) {
				//Coel.LogVersFirebug(responseValue.toString());
				AuthInfo info = parserAuthJson(responseValue);
				gererRetourAuthInfo(info);
			}
		});
	}
	
	/**
	 * Méthode connectant un utilisateur à l'application
	 */
	public void connecterUtilisateur() {
		HashMap<String, String> parametres = new HashMap<String, String>();
		parametres.put("login", utilisateur.getLogin());
		parametres.put("password", utilisateur.getMotDePasse());
		//Coel.LogVersFirebug("connexion");
		final JsonRestRequestBuilder rb = UtilDAO.construireRequeteAuth("connexion", parametres);
		
		rb.envoyerRequete(null, new JsonRestRequestCallback() {
			@Override
			public void surReponse(JSONValue responseValue) {
				AuthInfo info = parserAuthJson(responseValue);
				gererRetourAuthInfo(info);
			}
			@Override
			public void onErrorHTTP(Request request, Response reponse) {
				// Si on a été déconnecté, on va chercher un profil utilisateur "anonyme" et
				// on avertit l'interface
				//Coel.LogVersFirebug("j'ai une erreur mais je suis content");
				gererRetourAuthInfo(new AuthInfo());
			}
		});
	}
 
	/**
	 * Va chercher les infos de l'utilisateur en vérifiant d'abord l'identité auprès de l'annuaire
	 */
	public void getEtatUtilisateur() {
		getEtatUtilisateur(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)
	 */
	public void getEtatUtilisateur(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) {
			//Coel.LogVersFirebug("get état");
			// sans header Authorization, sinon une déconnexion depuis une autre appli ne sera pas
			// prise en compte et le jeton sera rafraîchi indéfiniment
			final JsonRestRequestBuilder rb = UtilDAO.construireRequeteAuth("identite", null, false);
			rb.envoyerRequete(null, new JsonRestRequestCallback() {
				@Override
				public void surReponse(JSONValue responseValue) {
					AuthInfo info = parserAuthJson(responseValue);
					gererRetourAuthInfo(info);
				}
				@Override
				public void onErrorHTTP(Request request, Response reponse) {
					// Si on a été déconnecté, on va chercher un profil utilisateur "anonyme" et
					// on avertit l'interface
					gererRetourAuthInfo(new AuthInfo());
				}
			});
		} else { // sinon on optimise, quand on vient de se (de)connecter, pas la peine de rappeler l'annuaire
			getEtatUtilisateurSansAnnuaire();
		}
	}
 
	/**
	 * Va chercher les infos de l'utilisateur Coel sans vérifier l'identité auprès de l'annuaire;
	 * transmet un jeton SSO à chaque fois pour que le service se base dessus
	 */
	public void getEtatUtilisateurSansAnnuaire() {
		final JsonRestRequestBuilder rb = UtilDAO.construireRequete(SERVICE_NOM);
		rb.envoyerRequete(null, new JsonRestRequestCallback() {
			@Override
			public void surReponse(JSONValue responseValue) {
				//Coel.LogVersFirebug("réponse reçue");
				JSONArray reponse = responseValue.isArray();
				if (reponse != null) {
					// Identifiant utilisateur ou identifiant de session si non identifié
					String login = ((JSONString) reponse.get(1)).stringValue();
 
					// Drapeau leve si utilisateur deja identifié
					boolean identifie = ((JSONBoolean) reponse.get(2)).booleanValue();
 
					utilisateur.setIdentification(identifie);
					utilisateur.setLogin(login);
 
					//Ajout des informations licence
					if (reponse.get(0).isString() != null)	{
						//Coel.LogVersFirebug("1 : set licence [" + reponse.get(0).isString().stringValue() + "]");
						utilisateur.setLicence(reponse.get(0).isString().stringValue());
					} else {
						//Coel.LogVersFirebug("2 : set licence vide");
						utilisateur.setLicence("");						
					}
 
					//Coel.LogVersFirebug("Utilisateur CoeL chargé !!");
					//Coel.LogVersFirebug("id: " + identifie + ", login: " + login + ", licence: " + utilisateur.getLicence());
					//Coel.LogVersFirebug("Taille réponse:" + reponse.size());
 
					// Utilisateur connecté (non anonyme)
					if (reponse.size() > 3) {
						//Coel.LogVersFirebug("Utilisateur identifié, on charge plus de trucs !");
						// Identifiant de l'utilisateur ou identifiant de session si non identifié
						String idUtilisateur = ((JSONString) reponse.get(1)).stringValue();
						//Coel.LogVersFirebug("ID utilisateur: " + idUtilisateur);
						utilisateur.setId(idUtilisateur);
 
						// Nom complet de l'utilisateur
						if (reponse.get(3).isString() != null) {
							String nomComplet = ((JSONString) reponse.get(3)).stringValue();
							//Coel.LogVersFirebug("Nom complet: " + nomComplet);
							utilisateur.setNomComplet(nomComplet);
						}
						// Prénom de l'utilisateur
						if (reponse.get(4).isString() != null) {
							String prenom = ((JSONString) reponse.get(4)).stringValue();
							utilisateur.setPrenom(prenom);
							//Coel.LogVersFirebug("Prénom: " + prenom);
						}
						// Nom de l'utilisateur
						if (reponse.get(5).isString() != null) {
							String nom = ((JSONString) reponse.get(5)).stringValue();
							utilisateur.setNom(nom);
							//Coel.LogVersFirebug("Nom: " + nom);
						}
						// Paramètre => was ist das ?
						if (reponse.get(6).isString() != null) {
							String parametre = ((JSONString) reponse.get(6)).stringValue();
							utilisateur.setParametre(parametre);
							//Coel.LogVersFirebug("Paramètre: " + parametre);
						}
					}
 
					//Coel.LogVersFirebug("Rafraîchissement vue");
					vueARafraichir.rafraichir(utilisateur);
				}
			}
		});
	}
 
	/**
	 * Envoie une info au service utilisateur de Coel comme quoi le mec a accepté la licence
	 */
	public void accepterLicence()	{
		//Coel.LogVersFirebug("accepter licence: " + utilisateur.getLogin());
		String[] parametres = {
			"setLicence",
			utilisateur.getLogin()
		};
		
		final JsonRestRequestBuilder rb = UtilDAO.construireRequete(SERVICE_NOM, parametres);
		rb.envoyerRequete(null, new JsonRestRequestCallback() {
			@Override
			public void surReponse(JSONValue responseValue) {
				//Coel.LogVersFirebug("sur réponse setLicence");
				if (responseValue.isArray() != null) {
					final JSONArray reponse = responseValue.isArray();
					if (reponse.get(0).isString() != null)	{
						String licenceAcceptee = reponse.get(0).isString().stringValue();
						Information info = new Information("maj_licence");
						info.setDonnee(0, licenceAcceptee);
						//Coel.LogVersFirebug("licence acceptée : " + licenceAcceptee);
						vueARafraichir.rafraichir(info);
					}
				}
			}
		});
	}
}	

Subversion Repositories eFlore/Applications.coel

(root)/trunk/src/org/tela_botanica/client/modeles/UtilisateurAsyncDao.java – Rev 1908 → 1909

Rev 1908		Rev 1909
1	`package org.tela_botanica.client.modeles;`	1	`package org.tela_botanica.client.modeles;`
2		2
3	`import java.util.HashMap;`	3	`import java.util.HashMap;`
4		4
5	`import org.tela_botanica.client.Coel;`	5	`import org.tela_botanica.client.Coel;`
6	`import org.tela_botanica.client.RegistreId;`	6	`import org.tela_botanica.client.RegistreId;`
7	`import org.tela_botanica.client.http.JsonRestRequestBuilder;`	7	`import org.tela_botanica.client.http.JsonRestRequestBuilder;`
8	`import org.tela_botanica.client.http.JsonRestRequestCallback;`	8	`import org.tela_botanica.client.http.JsonRestRequestCallback;`
9	`import org.tela_botanica.client.interfaces.Rafraichissable;`	9	`import org.tela_botanica.client.interfaces.Rafraichissable;`
10	`import org.tela_botanica.client.util.UtilDAO;`	10	`import org.tela_botanica.client.util.UtilDAO;`
11		11
12	`import com.extjs.gxt.ui.client.Registry;`	12	`import com.extjs.gxt.ui.client.Registry;`
13	`import com.google.gwt.http.client.Request;`	13	`import com.google.gwt.http.client.Request;`
14	`import com.google.gwt.http.client.Response;`	14	`import com.google.gwt.http.client.Response;`
15	`import com.google.gwt.json.client.JSONArray;`	15	`import com.google.gwt.json.client.JSONArray;`
16	`import com.google.gwt.json.client.JSONBoolean;`	16	`import com.google.gwt.json.client.JSONBoolean;`
17	`import com.google.gwt.json.client.JSONNumber;`	17	`import com.google.gwt.json.client.JSONNumber;`
18	`import com.google.gwt.json.client.JSONObject;`	18	`import com.google.gwt.json.client.JSONObject;`
19	`import com.google.gwt.json.client.JSONString;`	19	`import com.google.gwt.json.client.JSONString;`
20	`import com.google.gwt.json.client.JSONValue;`	20	`import com.google.gwt.json.client.JSONValue;`
21	`import com.google.gwt.user.client.Timer;`	21	`import com.google.gwt.user.client.Timer;`
22		22
23	`/**`	23	`/**`
24	`* Modele DAO, specifique, permettant la validation, l'acces aux donnees distantes et la présentation des donnees en retour`	24	`* Modele DAO, specifique, permettant la validation, l'acces aux donnees distantes et la présentation des donnees en retour`
25	`*`	25	`*`
26	`*/`	26	`*/`
27	`public class UtilisateurAsyncDao {`	27	`public class UtilisateurAsyncDao {`
28	`private static final String SERVICE_NOM = "CoelUtilisateur";`	28	`private static final String SERVICE_NOM = "CoelUtilisateur";`
29		29
30	`private Utilisateur utilisateur = null;`	30	`private Utilisateur utilisateur = null;`
31	`private Rafraichissable vueARafraichir = null;`	31	`private Rafraichissable vueARafraichir = null;`
32		32
33	`private static Timer rafraichisseurJeton = null;`	33	`private static Timer rafraichisseurJeton = null;`
34		34
35	`/**`	35	`/**`
36	`* Constructeur`	36	`* Constructeur`
37	`* @param retour : méthode appellée en retour d'appel.`	37	`* @param retour : méthode appellée en retour d'appel.`
38	`*/`	38	`*/`
39	`public UtilisateurAsyncDao(Rafraichissable vueARafraichirCourrante) {`	39	`public UtilisateurAsyncDao(Rafraichissable vueARafraichirCourrante) {`
40	`vueARafraichir = vueARafraichirCourrante;`	40	`vueARafraichir = vueARafraichirCourrante;`