| 1,5 → 1,8 |
|---|
| 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; |
| 7,11 → 10,15 |
|---|
| import org.tela_botanica.client.util.UtilDAO; |
| |
| import com.extjs.gxt.ui.client.Registry; |
| import com.google.gwt.core.client.GWT; |
| 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 |
| 22,6 → 29,8 |
|---|
| |
| private Utilisateur utilisateur = null; |
| private Rafraichissable vueARafraichir = null; |
| |
| private static Timer rafraichisseurJeton = null; |
| |
| /** |
| * Constructeur |
| 31,72 → 40,196 |
|---|
| vueARafraichir = vueARafraichirCourrante; |
| utilisateur = (Utilisateur) Registry.get(RegistreId.UTILISATEUR_COURANT); |
| } |
| |
| |
| /** |
| * Méthode de classe d'appel du service des gestion d'identification. |
| * Recupere des informations d'authentification à partir du JSON renvoyé par les |
| * services Auth de l'annuaire (SSO) |
| * |
| * @param valeurJson |
| * @return AuthInfo |
| */ |
| public void getEtatUtilisateur() { |
| final JsonRestRequestBuilder rb = UtilDAO.construireRequete(SERVICE_NOM); |
| rb.envoyerRequete(null, new JsonRestRequestCallback() { |
| @Override |
| public void surReponse(JSONValue responseValue) { |
| if (responseValue.isArray() != null) { |
| final JSONArray reponse = responseValue.isArray(); |
| // Identifiant utilisateur ou identifiant de session si non identifié |
| String login = ((JSONString) reponse.get(2)).stringValue(); |
| // Drapeau leve si utilisateur deja identifié |
| boolean identifie = ((JSONBoolean) reponse.get(3)).booleanValue(); |
| utilisateur.setIdentification(identifie); |
| utilisateur.setLogin(login); |
| vueARafraichir.rafraichir(utilisateur); |
| 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() { |
| String[] parametres = {utilisateur.getId()}; |
| |
| final JsonRestRequestBuilder rb = UtilDAO.construireRequete(SERVICE_NOM, parametres); |
| //Coel.LogVersFirebug("deconnexion"); |
| final JsonRestRequestBuilder rb = UtilDAO.construireRequeteAuth("deconnexion", null); |
| rb.envoyerRequete(null, new JsonRestRequestCallback() { |
| @Override |
| public void surReponse(JSONValue responseValue) { |
| if (responseValue.isArray() != null) { |
| final JSONArray reponse = responseValue.isArray(); |
| // Identifiant utilisateur ou identifiant de session si non identifié |
| String id = ((JSONString) reponse.get(1)).stringValue(); |
| // Drapeau levé si l'utilisateur est déjà identifié |
| boolean identifie = ((JSONBoolean) reponse.get(2)).booleanValue(); |
| |
| // Nous réinitialisons l'utilisateur |
| utilisateur = new Utilisateur(id, identifie); |
| |
| GWT.log(utilisateur.toString(), null); |
| vueARafraichir.rafraichir(utilisateur); |
| } |
| //Coel.LogVersFirebug(responseValue.toString()); |
| AuthInfo info = parserAuthJson(responseValue); |
| gererRetourAuthInfo(info); |
| } |
| }); |
| } |
| |
| /** |
| * Méthode connectant un utilisateur à l'application. |
| * @param Utilisateur l'utilisateur courant. |
| * Méthode connectant un utilisateur à l'application |
| */ |
| public void connecterUtilisateur() { |
| String[] parametres = {utilisateur.getLogin(), utilisateur.getMotDePasse()}; |
| 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); |
| |
| final JsonRestRequestBuilder rb = UtilDAO.construireRequete(SERVICE_NOM, parametres); |
| |
| rb.envoyerRequete(null, new JsonRestRequestCallback() { |
| @Override |
| public void surReponse(JSONValue responseValue) { |
| if (responseValue.isArray() != null) { |
| final JSONArray reponse = responseValue.isArray(); |
| |
| AuthInfo info = parserAuthJson(responseValue); |
| gererRetourAuthInfo(info); |
| } |
| }); |
| } |
| |
| /** |
| * 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) { |
| utilisateur.setLicence(reponse.get(0).isString().stringValue()); |
| 103,46 → 236,55 |
|---|
| } else { |
| utilisateur.setLicence(""); |
| } |
| |
| if (reponse.size() > 0) { |
| |
| |
| //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é |
| utilisateur.setId(((JSONString) reponse.get(1)).stringValue()); |
| |
| // Drapeau levé si l'utilisateur est déjà identifié |
| utilisateur.setIdentification(((JSONBoolean) reponse.get(2)).booleanValue()); |
| |
| // Plus de deux valeurs, l'utilisateur est identifié nous récupérons des données supplémentaires |
| if (reponse.size() > 3) { |
| // Nom complet de l'utilisateur |
| if (reponse.get(3).isString() != null) { |
| utilisateur.setNomComplet(((JSONString) reponse.get(3)).stringValue()); |
| } |
| // Prénom de l'utilisateur |
| if (reponse.get(4).isString() != null) { |
| utilisateur.setPrenom(((JSONString) reponse.get(4)).stringValue()); |
| } |
| |
| // Nom de l'utilisateur |
| if (reponse.get(5).isString() != null) { |
| utilisateur.setNom(((JSONString) reponse.get(5)).stringValue()); |
| } |
| |
| // Paramètres |
| if (reponse.get(6).isString() != null) { |
| utilisateur.setParametre(((JSONString) reponse.get(6)).stringValue()); |
| } |
| |
| 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); |
| } |
| vueARafraichir.rafraichir(utilisateur); |
| // 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); |
| } |
| } |
| }); |
| } |
| |
| /* |
| * */ |
| |
| /** |
| * @TODO CHANGER ÇA ! |
| */ |
| public void accepterLicence() { |
| String[] parametres = {utilisateur.getLogin(), utilisateur.getMotDePasse(), utilisateur.getId()}; |
| |