Subversion Repositories eFlore/Applications.del

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

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) {
                        RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.GET, authBaseUrl + "identite");
                        try {
                                rb.sendRequest(null, new AuthCallback() {
                                        public void surErreur(String message) {
                                                // Même si l'annuaire n'est pas content, on va chercher un profil utilisateur "anonyme"
                                                obtenirUtilisateurSansAnnuaire(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, 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 (cb nul pour l'instant)
                                                // @TODO gérer le possible changement de profil / coordonnées de l'utilisateur
                                                // en cours de connexion
                                                obtenirUtilisateur(null);
                                        }
                                };
                                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);
        }

}