Subversion Repositories eFlore/Applications.coel

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

					}

				}

			}

		});

	}

}