Subversion Repositories eFlore/Applications.coel

Rev

Rev 1732 | Rev 1908 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | RSS feed

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

        /**
         * 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());
                                        } else {
                                                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);
                                }
                        }
                });
        }

        /**
         * @TODO CHANGER ÇA !
         */
        public void accepterLicence()   {
                String[] parametres = {utilisateur.getLogin(), utilisateur.getMotDePasse(), utilisateur.getId()};
                
                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();
                                        if (reponse.get(0).isString() != null)  {
                                                String licenceAcceptee = reponse.get(0).isString().stringValue();
                                                Information info = new Information("maj_licence");
                                                info.setDonnee(0, licenceAcceptee);
                                                vueARafraichir.rafraichir(info);
                                        }
                                }
                        }
                });
        }
}